struct BinaryNode : public Node
{
    NodePtr node_0;
    NodePtr node_1;
    xed_iclass_enum_t cls;

    BinaryNode(const NodePtr &node_0, const NodePtr &node_1,
        xed_iclass_enum_t cls) : Node(node_0->width), node_0(node_0), node_1(node_1), cls(cls)
    {
        expect(node_0->width == node_1->width);

        eval_const();
    }

    void eval_const()
    {
        if ((node_0->const_value.type == ConstValueType::Invalid) || (node_1->const_value.type == ConstValueType::Invalid))
            return;

        uint64_t value = 0;

        switch (cls)
        {
            case XED_ICLASS_AND:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 & node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 & node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 & node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 & node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_OR:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 | node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 | node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 | node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 | node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_XOR:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 ^ node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 ^ node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 ^ node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 ^ node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_ADD:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 + node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 + node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 + node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 + node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_SUB:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 - node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 - node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 - node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 - node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_SHL:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 << node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 << node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 << node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 << node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            case XED_ICLASS_SHR:
                switch (width)
                {
                    case 8: value = node_0->const_value.value8 >> node_1->const_value.value8; break;
                    case 16: value = node_0->const_value.value16 >> node_1->const_value.value16; break;
                    case 32: value = node_0->const_value.value32 >> node_1->const_value.value32; break;
                    case 64: value = node_0->const_value.value64 >> node_1->const_value.value64; break;
                    default:
                        expect(false);
                }
                break;

            default:
                expect(false);
        }

        ConstValueType type = pick_type(node_0->const_value.type, node_1->const_value.type);
        const_value = ConstValue(value, type);
    }

    void to_string(std::ostream &o) const override
    {
        o << cls;
    }

    NodePtr get_prev_0() const override
    {
        return node_0;
    }

    NodePtr get_prev_1() const override
    {
        return node_1;
    }

    llvm::Value *eval_impl(IrFunc &ir) override
    {
        llvm::Value *value_0 = ir(node_0);
        llvm::Value *value_1 = ir(node_1);
        expect(value_0->getType() == value_1->getType());

        switch (cls)
        {
            case XED_ICLASS_SUB:
                return ir.builder.CreateSub(value_0, value_1);

            case XED_ICLASS_ADD:
                return ir.builder.CreateAdd(value_0, value_1);

            case XED_ICLASS_OR:
                return ir.builder.CreateOr(value_0, value_1);

            case XED_ICLASS_AND:
                return ir.builder.CreateAnd(value_0, value_1);

            case XED_ICLASS_XOR:
                return ir.builder.CreateXor(value_0, value_1);

            case XED_ICLASS_SHR:
                return ir.builder.CreateLShr(value_0, value_1);

            case XED_ICLASS_SHL:
                return ir.builder.CreateShl(value_0, value_1);

            default:
                expect(false);
        }
    }
};