ExampleDialect.cpp.inc

// DO NOT EDIT! This file is automatically generated by llvm-dialects-tblgen.


#ifdef GET_INCLUDES
#undef GET_INCLUDES
#include "llvm-dialects/Dialect/Builder.h"
#include "llvm-dialects/Dialect/OpDescription.h"
#include "llvm-dialects/Dialect/Utils.h"
#include "llvm-dialects/Dialect/Verifier.h"
#include "llvm-dialects/Dialect/Visitor.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h"

#include "llvm/Support/ModRef.h"

#include "llvm/Support/raw_ostream.h"
#endif // GET_INCLUDES

#ifdef GET_DIALECT_DEFS
#undef GET_DIALECT_DEFS
namespace xd::cpp {

    void ExampleDialect::anchor() {}

    ::llvm_dialects::Dialect::Key& ExampleDialect::getKey() {
      static Key s_key;
      return s_key;
    }

    bool ExampleDialect::isDialectOp(::llvm::CallInst& op) {
      ::llvm::Function *calledFunc = op.getCalledFunction(); 
      if (!calledFunc)
        return false;
      
      return isDialectOp(calledFunc->getName());
    }

    bool ExampleDialect::isDialectOp(::llvm::Function& func) {
      return isDialectOp(func.getName());
    }

    bool ExampleDialect::isDialectOp(::llvm::StringRef funcName) {
      return funcName.starts_with("xd.ir.");
    }

    ::llvm_dialects::Dialect* ExampleDialect::make(::llvm::LLVMContext& context) {
      
      auto verifierBuild = [](::llvm_dialects::VisitorBuilder<::llvm_dialects::VerifierState> &builder) {
    
        builder.add<Add32Op>([](::llvm_dialects::VerifierState &state, Add32Op &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<BufferCompareOp>([](::llvm_dialects::VerifierState &state, BufferCompareOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<CombineOp>([](::llvm_dialects::VerifierState &state, CombineOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<ExtractElementOp>([](::llvm_dialects::VerifierState &state, ExtractElementOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<FromFixedVectorOp>([](::llvm_dialects::VerifierState &state, FromFixedVectorOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<HandleGetOp>([](::llvm_dialects::VerifierState &state, HandleGetOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<IExtOp>([](::llvm_dialects::VerifierState &state, IExtOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<ITruncOp>([](::llvm_dialects::VerifierState &state, ITruncOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<ImmutableOp>([](::llvm_dialects::VerifierState &state, ImmutableOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<InsertElementOp>([](::llvm_dialects::VerifierState &state, InsertElementOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<InstNameConflictDoubleOp>([](::llvm_dialects::VerifierState &state, InstNameConflictDoubleOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<InstNameConflictOp>([](::llvm_dialects::VerifierState &state, InstNameConflictOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<InstNameConflictVarargsOp>([](::llvm_dialects::VerifierState &state, InstNameConflictVarargsOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<NoDescriptionOp>([](::llvm_dialects::VerifierState &state, NoDescriptionOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<NoSummaryOp>([](::llvm_dialects::VerifierState &state, NoSummaryOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<ReadOp>([](::llvm_dialects::VerifierState &state, ReadOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<SetReadOp>([](::llvm_dialects::VerifierState &state, SetReadOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<SetWriteOp>([](::llvm_dialects::VerifierState &state, SetWriteOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<SizeOfOp>([](::llvm_dialects::VerifierState &state, SizeOfOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<StreamAddOp>([](::llvm_dialects::VerifierState &state, StreamAddOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<StreamMaxOp>([](::llvm_dialects::VerifierState &state, StreamMaxOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<StreamMinOp>([](::llvm_dialects::VerifierState &state, StreamMinOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<StringAttrOp>([](::llvm_dialects::VerifierState &state, StringAttrOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<WriteOp>([](::llvm_dialects::VerifierState &state, WriteOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
        builder.add<WriteVarArgOp>([](::llvm_dialects::VerifierState &state, WriteVarArgOp &op) {
          if (!op.verifier(state.out()))
            state.setError();
        });
      
      };
      static const ::llvm_dialects::VerifierExtension verifierExtension = {
        verifierBuild,
      };
      static ::llvm_dialects::DialectExtensionRegistration<::llvm_dialects::VerifierExtension, ExampleDialect>
          verifierExtensionRegistration(::llvm_dialects::getVerifierExtensionPoint(), &verifierExtension);
    
      return new ExampleDialect(context);
    }

    ExampleDialect::ExampleDialect(::llvm::LLVMContext& context) : DialectImpl(context) {
  {
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
argAttrList = argAttrList.addParamAttribute(context, 0, ::llvm::Attribute::getWithCaptureInfo(context, llvm::CaptureInfo::none()));
argAttrList = argAttrList.addParamAttribute(context, 1, ::llvm::Attribute::getWithCaptureInfo(context, llvm::CaptureInfo::none()));
argAttrList = argAttrList.addParamAttribute(context, 0, ::llvm::Attribute::NoUndef);
argAttrList = argAttrList.addRetAttribute(context, ::llvm::Attribute::NoUndef);
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
m_attributeLists[0] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
argAttrList = argAttrList.addParamAttribute(context, 0, ::llvm::Attribute::getWithCaptureInfo(context, llvm::CaptureInfo::none()));
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
attrBuilder.addMemoryAttr(::llvm::MemoryEffects::none());
m_attributeLists[1] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
argAttrList = argAttrList.addParamAttribute(context, 0, ::llvm::Attribute::getWithCaptureInfo(context, llvm::CaptureInfo::none()));
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
attrBuilder.addMemoryAttr(::llvm::MemoryEffects(::llvm::ModRefInfo::Ref));
m_attributeLists[2] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
attrBuilder.addMemoryAttr(::llvm::MemoryEffects::none());
m_attributeLists[3] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
attrBuilder.addMemoryAttr(::llvm::MemoryEffects(::llvm::MemoryEffects::Location::InaccessibleMem, ::llvm::ModRefInfo::Mod));
m_attributeLists[4] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
attrBuilder.addAttribute(::llvm::Attribute::NoUnwind);
attrBuilder.addMemoryAttr(::llvm::MemoryEffects(::llvm::MemoryEffects::Location::InaccessibleMem, ::llvm::ModRefInfo::ModRef));
m_attributeLists[5] = argAttrList.addFnAttributes(context, attrBuilder);
}
{
  ::llvm::AttrBuilder attrBuilder{context};
 ::llvm::AttributeList argAttrList;
attrBuilder.addAttribute(::llvm::Attribute::WillReturn);
m_attributeLists[6] = argAttrList.addFnAttributes(context, attrBuilder);
}
}

XdHandleType* XdHandleType::get(::llvm::LLVMContext & ctx) {
::std::array<::llvm::Type *, 0> types = {

    };
    ::std::array<unsigned, 0> ints = {
  
      };

      auto *type = ::llvm::cast<XdHandleType>(::llvm::TargetExtType::get(ctx, s_name, types, ints));
      assert(::llvm_dialects::runTypeVerifier([type](llvm::raw_ostream &errs) {
        return type->verifier(errs);
      }, type));
      return type;
    }
  
    bool XdHandleType::verifier(::llvm::raw_ostream &errs) const {
      ::llvm::LLVMContext &ctx = getContext();
      (void)ctx;

      using ::llvm_dialects::printable;

      if (getNumTypeParameters() != 0) {
        errs << "  wrong number of type parameters\n";
        errs << "    expected: 0\n";
        errs << "      actual: " << getNumTypeParameters() << '\n';
        return false;
      }

      if (getNumIntParameters() != 0) {
        errs << "  wrong number of int parameters\n";
        errs << "    expected: 0\n";
        errs << "      actual: " << getNumIntParameters() << '\n';
        return false;
      }
  return true;
}


      VectorKind XdVectorType::getKind() const {
        return static_cast<VectorKind>(int_params()[0]);
      }

    
      ::llvm::Type * XdVectorType::getElementType() const {
        return type_params()[0];
      }

    
      uint32_t XdVectorType::getNumElements() const {
        return int_params()[1];
      }

    XdVectorType* XdVectorType::get(VectorKind kind, ::llvm::Type * elementType, uint32_t numElements) {
::llvm::LLVMContext &ctx = elementType->getContext();
static_assert(sizeof(kind) <= sizeof(unsigned));

::std::array<::llvm::Type *, 1> types = {
elementType,

    };
    ::std::array<unsigned, 2> ints = {
  static_cast<unsigned>(kind),
numElements,

      };

      auto *type = ::llvm::cast<XdVectorType>(::llvm::TargetExtType::get(ctx, s_name, types, ints));
      assert(::llvm_dialects::runTypeVerifier([type](llvm::raw_ostream &errs) {
        return type->verifier(errs);
      }, type));
      return type;
    }
  
    bool XdVectorType::verifier(::llvm::raw_ostream &errs) const {
      ::llvm::LLVMContext &ctx = getContext();
      (void)ctx;

      using ::llvm_dialects::printable;

      if (getNumTypeParameters() != 1) {
        errs << "  wrong number of type parameters\n";
        errs << "    expected: 1\n";
        errs << "      actual: " << getNumTypeParameters() << '\n';
        return false;
      }

      if (getNumIntParameters() != 2) {
        errs << "  wrong number of int parameters\n";
        errs << "    expected: 2\n";
        errs << "      actual: " << getNumIntParameters() << '\n';
        return false;
      }
  auto kind = getKind();
(void)kind;
auto elementType = getElementType();
(void)elementType;
auto numElements = getNumElements();
(void)numElements;
return true;
}


      bool StreamReduceOp::classof(const ::llvm::CallInst* i) {
    
        if (StreamAddOp::classof(i)) return true;
      
        if (StreamMaxOp::classof(i)) return true;
      
        if (StreamMinOp::classof(i)) return true;
      
        return false;
      }

    
      ::llvm::Value * StreamReduceOp::getPtr() const {
        return getArgOperand(ArgumentIndex::Ptr);
      }

      void StreamReduceOp::setPtr(::llvm::Value * ptr) {
        setArgOperand(ArgumentIndex::Ptr, ptr);
      }
      ::llvm::Value * StreamReduceOp::getCount() const {
        return getArgOperand(ArgumentIndex::Count);
      }

      void StreamReduceOp::setCount(::llvm::Value * count) {
        setArgOperand(ArgumentIndex::Count, count);
      }
      ::llvm::Value * StreamReduceOp::getInitial() const {
        return getArgOperand(ArgumentIndex::Initial);
      }

      void StreamReduceOp::setInitial(::llvm::Value * initial) {
        setArgOperand(ArgumentIndex::Initial, initial);
      }

      const ::llvm::StringLiteral Add32Op::s_name{"xd.ir.add32"};

    Add32Op* Add32Op::create(llvm_dialects::Builder& b, ::llvm::Value * lhs, ::llvm::Value * rhs, uint32_t extra, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 32), {
lhs->getType(),
rhs->getType(),
::llvm::IntegerType::get(context, 32),
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  
::llvm::SmallVector<::llvm::Value*, 3> args = {
lhs,
rhs,
 ::llvm::ConstantInt::get(::llvm::IntegerType::get(context, 32), extra) 
      };
      
      return ::llvm::cast<Add32Op>(b.CreateCall(fn, args, instName));
    }


    bool Add32Op::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 3) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 3\n";
        return false;
      }
  
        if (getArgOperand(2)->getType() != ::llvm::IntegerType::get(context, 32)) {
          errs << "  argument 2 (extra) has type: "
                 << *getArgOperand(2)->getType() << '\n';
          errs << "  expected: " << *::llvm::IntegerType::get(context, 32) << '\n';
          return false;
        }
      ::llvm::Type * const lhsType = getLhs()->getType();
(void)lhsType;
::llvm::Type * const rhsType = getRhs()->getType();
(void)rhsType;
uint32_t const extra = getExtra();
(void)extra;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != lhsType) {
          errs << "  unexpected value of $lhs:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(lhsType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 32) != rhsType) {
          errs << "  unexpected value of $rhs:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(rhsType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 32) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * Add32Op::getLhs() const {
        return getArgOperand(ArgumentIndex::Lhs);
      }

      void Add32Op::setLhs(::llvm::Value * lhs) {
        setArgOperand(ArgumentIndex::Lhs, lhs);
      }
      ::llvm::Value * Add32Op::getRhs() const {
        return getArgOperand(ArgumentIndex::Rhs);
      }

      void Add32Op::setRhs(::llvm::Value * rhs) {
        setArgOperand(ArgumentIndex::Rhs, rhs);
      }
      uint32_t Add32Op::getExtra() const {
        return  ::llvm::cast<::llvm::ConstantInt>(getArgOperand(ArgumentIndex::Extra))->getZExtValue() ;
      }

      void Add32Op::setExtra(uint32_t extra) {
        setArgOperand(ArgumentIndex::Extra,  ::llvm::ConstantInt::get(::llvm::IntegerType::get(getContext(), 32), extra) );
      }
::llvm::Value *Add32Op::getResult() {return this;}



      const ::llvm::StringLiteral BufferCompareOp::s_name{"xd.ir.buffer.compare.op"};

    BufferCompareOp* BufferCompareOp::create(llvm_dialects::Builder& b, ::llvm::Value * lhs, ::llvm::Value * rhs, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(0);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 32), {
lhs->getType(),
rhs->getType(),
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 2> args = {
lhs,
rhs
      };
      
      return ::llvm::cast<BufferCompareOp>(b.CreateCall(fn, args, instName));
    }


    bool BufferCompareOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 2) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 2\n";
        return false;
      }
  ::llvm::Type * const lhsType = getLhs()->getType();
(void)lhsType;
::llvm::Type * const rhsType = getRhs()->getType();
(void)rhsType;
::llvm::Type * const retType = getRet()->getType();
(void)retType;

        if (::llvm::PointerType::get(context, 0) != lhsType) {
          errs << "  unexpected value of $lhs:\n";
          errs << "    expected:  " << printable(::llvm::PointerType::get(context, 0)) << '\n';
          errs << "    actual:    " << printable(lhsType) << '\n';
        
          return false;
        }
      
        if (::llvm::PointerType::get(context, 0) != rhsType) {
          errs << "  unexpected value of $rhs:\n";
          errs << "    expected:  " << printable(::llvm::PointerType::get(context, 0)) << '\n';
          errs << "    actual:    " << printable(rhsType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 32) != retType) {
          errs << "  unexpected value of $ret:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(retType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * BufferCompareOp::getLhs() const {
        return getArgOperand(ArgumentIndex::Lhs);
      }

      void BufferCompareOp::setLhs(::llvm::Value * lhs) {
        setArgOperand(ArgumentIndex::Lhs, lhs);
      }
      ::llvm::Value * BufferCompareOp::getRhs() const {
        return getArgOperand(ArgumentIndex::Rhs);
      }

      void BufferCompareOp::setRhs(::llvm::Value * rhs) {
        setArgOperand(ArgumentIndex::Rhs, rhs);
      }
::llvm::Value *BufferCompareOp::getRet() {return this;}



      const ::llvm::StringLiteral CombineOp::s_name{"xd.ir.combine"};

    CombineOp* CombineOp::create(llvm_dialects::Builder& b, ::llvm::Value * lhs, ::llvm::Value * rhs, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {lhs->getType()});
    auto fnType = ::llvm::FunctionType::get(lhs->getType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 2> args = {
lhs,
rhs
      };
      
      return ::llvm::cast<CombineOp>(b.CreateCall(fn, args, instName));
    }


    bool CombineOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 2) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 2\n";
        return false;
      }
  ::llvm::Type * const lhsType = getLhs()->getType();
(void)lhsType;
::llvm::Type * const rhsType = getRhs()->getType();
(void)rhsType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (resultType != lhsType) {
          errs << "  unexpected value of $lhs:\n";
          errs << "    expected:  " << printable(resultType) << '\n';
          errs << "    actual:    " << printable(lhsType) << '\n';
        
          return false;
        }
      
        if (resultType != rhsType) {
          errs << "  unexpected value of $rhs:\n";
          errs << "    expected:  " << printable(resultType) << '\n';
          errs << "    actual:    " << printable(rhsType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * CombineOp::getLhs() const {
        return getArgOperand(ArgumentIndex::Lhs);
      }

      void CombineOp::setLhs(::llvm::Value * lhs) {
        setArgOperand(ArgumentIndex::Lhs, lhs);
      }
      ::llvm::Value * CombineOp::getRhs() const {
        return getArgOperand(ArgumentIndex::Rhs);
      }

      void CombineOp::setRhs(::llvm::Value * rhs) {
        setArgOperand(ArgumentIndex::Rhs, rhs);
      }
::llvm::Value *CombineOp::getResult() {return this;}



      const ::llvm::StringLiteral ExtractElementOp::s_name{"xd.ir.extractelement"};

    ExtractElementOp* ExtractElementOp::create(llvm_dialects::Builder& b, ::llvm::Value * vector, ::llvm::Value * index, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {::llvm::cast<XdVectorType>(vector->getType())->getElementType()});
    auto fnType = ::llvm::FunctionType::get(::llvm::cast<XdVectorType>(vector->getType())->getElementType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 2> args = {
vector,
index
      };
      
      return ::llvm::cast<ExtractElementOp>(b.CreateCall(fn, args, instName));
    }


    bool ExtractElementOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 2) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 2\n";
        return false;
      }
  ::llvm::Type * const vectorType = getVector()->getType();
(void)vectorType;
::llvm::Type * const indexType = getIndex()->getType();
(void)indexType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != indexType) {
          errs << "  unexpected value of $index:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(indexType) << '\n';
        
          return false;
        }
      
        if (!(::llvm::isa<XdVectorType>(vectorType))) {
          errs << "  failed check for (XdVectorType any, ?:$result, any):$vector\n";
          
      errs << "  with $vector = " << printable(vectorType) << '\n';
    
        
          return false;
        }
      
        if (::llvm::cast<XdVectorType>(vectorType)->getElementType() != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::cast<XdVectorType>(vectorType)->getElementType()) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * ExtractElementOp::getVector() const {
        return getArgOperand(ArgumentIndex::Vector);
      }

      void ExtractElementOp::setVector(::llvm::Value * vector) {
        setArgOperand(ArgumentIndex::Vector, vector);
      }
      ::llvm::Value * ExtractElementOp::getIndex() const {
        return getArgOperand(ArgumentIndex::Index);
      }

      void ExtractElementOp::setIndex(::llvm::Value * index) {
        setArgOperand(ArgumentIndex::Index, index);
      }
::llvm::Value *ExtractElementOp::getResult() {return this;}



      const ::llvm::StringLiteral FromFixedVectorOp::s_name{"xd.ir.fromfixedvector"};

    FromFixedVectorOp* FromFixedVectorOp::create(llvm_dialects::Builder& b, ::llvm::Type* resultType, ::llvm::Value * source, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {resultType});
    auto fnType = ::llvm::FunctionType::get(resultType, true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
source
      };
      
      return ::llvm::cast<FromFixedVectorOp>(b.CreateCall(fn, args, instName));
    }


    bool FromFixedVectorOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const sourceType = getSource()->getType();
(void)sourceType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (!(::llvm::isa<::llvm::FixedVectorType>(sourceType))) {
          errs << "  failed check for (FixedVectorType ?:$scalar_type, ?:$num_elements):$source\n";
          
      errs << "  with $source = " << printable(sourceType) << '\n';
    
        
          return false;
        }
      
        if (!(::llvm::isa<XdVectorType>(resultType))) {
          errs << "  failed check for (XdVectorType ?:$kind, ?:$scalar_type, ?:$num_elements):$result\n";
          
      errs << "  with $result = " << printable(resultType) << '\n';
    
        
          return false;
        }
      
        if (::llvm::cast<XdVectorType>(resultType)->getElementType() != ::llvm::cast<::llvm::FixedVectorType>(sourceType)->getElementType()) {
          errs << "  unexpected value of $scalar_type:\n";
          errs << "    expected:  " << printable(::llvm::cast<XdVectorType>(resultType)->getElementType()) << '\n';
          errs << "    actual:    " << printable(::llvm::cast<::llvm::FixedVectorType>(sourceType)->getElementType()) << '\n';
        
          return false;
        }
      
        if (::llvm::cast<XdVectorType>(resultType)->getNumElements() != ::llvm::cast<::llvm::FixedVectorType>(sourceType)->getNumElements()) {
          errs << "  unexpected value of $num_elements:\n";
          errs << "    expected:  " << printable(::llvm::cast<XdVectorType>(resultType)->getNumElements()) << '\n';
          errs << "    actual:    " << printable(::llvm::cast<::llvm::FixedVectorType>(sourceType)->getNumElements()) << '\n';
        
          return false;
        }
      if (![&]() {

      {
        if (true
    
      && !([&]() {
    
        if (xd::cpp::VectorKind::LittleEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
          return false;
        }
      return true;
}())

      && !([&]() {
    
        if (xd::cpp::VectorKind::BigEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
          return false;
        }
      return true;
}())
) {

        errs << "  eq:$rhs (" << printable(::llvm::cast<XdVectorType>(resultType)->getKind())
               << ") does not match any available option\n";
      
        errs << "  failed option 0 (VectorKindLittleEndian):\n";
        ([&]() {
      
        if (xd::cpp::VectorKind::LittleEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
          errs << "  inconsistent value of eq:$rhs found\n";
          errs << "  while checking VectorKindLittleEndian:\n";
          errs << "    here:       " << printable(xd::cpp::VectorKind::LittleEndian) << '\n';
          errs << "    previously: " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
        
          return false;
        }
      
          return true;
        })();
      
        errs << "  failed option 1 (VectorKindBigEndian):\n";
        ([&]() {
      
        if (xd::cpp::VectorKind::BigEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
          errs << "  inconsistent value of eq:$rhs found\n";
          errs << "  while checking VectorKindBigEndian:\n";
          errs << "    here:       " << printable(xd::cpp::VectorKind::BigEndian) << '\n';
          errs << "    previously: " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
        
          return false;
        }
      
          return true;
        })();
      return false;
}
}

          return true;
        }()) {
          errs << "  while checking (isReasonableVectorKind ?:$kind)\n";
          
      errs << "  with $kind = " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
    
        
          return false;
        }
        return true;
}


      ::llvm::Value * FromFixedVectorOp::getSource() const {
        return getArgOperand(ArgumentIndex::Source);
      }

      void FromFixedVectorOp::setSource(::llvm::Value * source) {
        setArgOperand(ArgumentIndex::Source, source);
      }
::llvm::Value *FromFixedVectorOp::getResult() {return this;}



      const ::llvm::StringLiteral HandleGetOp::s_name{"xd.ir.handle.get"};

    HandleGetOp* HandleGetOp::create(llvm_dialects::Builder& b, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    auto fnType = ::llvm::FunctionType::get(XdHandleType::get(context), {
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  return ::llvm::cast<HandleGetOp>(b.CreateCall(fn, {}, instName));
}


    bool HandleGetOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 0) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 0\n";
        return false;
      }
  ::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (XdHandleType::get(context) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(XdHandleType::get(context)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


::llvm::Value *HandleGetOp::getResult() {return this;}



      const ::llvm::StringLiteral IExtOp::s_name{"xd.ir.iext"};

    IExtOp* IExtOp::create(llvm_dialects::Builder& b, ::llvm::Type* resultType, ::llvm::Value * source, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {resultType});
    auto fnType = ::llvm::FunctionType::get(resultType, true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
source
      };
      
      return ::llvm::cast<IExtOp>(b.CreateCall(fn, args, instName));
    }


    bool IExtOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const sourceType = getSource()->getType();
(void)sourceType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (!(sourceType->isIntegerTy())) {
          errs << "  failed check for (IntegerType (le ?:$result_width)):$source\n";
          
      errs << "  with $source = " << printable(sourceType) << '\n';
    
        
          return false;
        }
      
        if (!(resultType->isIntegerTy())) {
          errs << "  failed check for (IntegerType ?:$result_width):$result\n";
          
      errs << "  with $result = " << printable(resultType) << '\n';
    
        
          return false;
        }
      
        if (!(sourceType->getIntegerBitWidth() <= resultType->getIntegerBitWidth())) {
          errs << "  failed check for (le ?:$result_width):IntegerType:$num_bits\n";
          
      errs << "  with IntegerType:$num_bits = " << printable(sourceType->getIntegerBitWidth()) << '\n';
    
          errs << "  with $result_width = " << printable(resultType->getIntegerBitWidth()) << '\n';
        
        
          return false;
        }
        return true;
}


      ::llvm::Value * IExtOp::getSource() const {
        return getArgOperand(ArgumentIndex::Source);
      }

      void IExtOp::setSource(::llvm::Value * source) {
        setArgOperand(ArgumentIndex::Source, source);
      }
::llvm::Value *IExtOp::getResult() {return this;}



      const ::llvm::StringLiteral ITruncOp::s_name{"xd.ir.itrunc"};

    ITruncOp* ITruncOp::create(llvm_dialects::Builder& b, ::llvm::Type* resultType, ::llvm::Value * source, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {resultType});
    auto fnType = ::llvm::FunctionType::get(resultType, true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
source
      };
      
      return ::llvm::cast<ITruncOp>(b.CreateCall(fn, args, instName));
    }


    bool ITruncOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const sourceType = getSource()->getType();
(void)sourceType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (!(sourceType->isIntegerTy())) {
          errs << "  failed check for (IntegerType ?:$source_width):$source\n";
          
      errs << "  with $source = " << printable(sourceType) << '\n';
    
        
          return false;
        }
      
        if (!(resultType->isIntegerTy())) {
          errs << "  failed check for (IntegerType ?:$result_width):$result\n";
          
      errs << "  with $result = " << printable(resultType) << '\n';
    
        
          return false;
        }
      
        if (!(resultType->getIntegerBitWidth() <= sourceType->getIntegerBitWidth())) {
          errs << "  failed check for (le ?:$result_width, ?:$source_width)\n";
          
      errs << "  with $result_width = " << printable(resultType->getIntegerBitWidth()) << '\n';
    
          errs << "  with $source_width = " << printable(sourceType->getIntegerBitWidth()) << '\n';
        
        
          return false;
        }
        return true;
}


      ::llvm::Value * ITruncOp::getSource() const {
        return getArgOperand(ArgumentIndex::Source);
      }

      void ITruncOp::setSource(::llvm::Value * source) {
        setArgOperand(ArgumentIndex::Source, source);
      }
::llvm::Value *ITruncOp::getResult() {return this;}



      const ::llvm::StringLiteral ImmutableOp::s_name{"xd.ir.immutable.op"};

    ImmutableOp* ImmutableOp::create(llvm_dialects::Builder& b, bool val, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), {
::llvm::IntegerType::get(context, 1),
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  
::llvm::SmallVector<::llvm::Value*, 1> args = {
 ::llvm::ConstantInt::get(::llvm::IntegerType::get(context, 1), val) 
      };
      
      return ::llvm::cast<ImmutableOp>(b.CreateCall(fn, args, instName));
    }


    bool ImmutableOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  
        if (getArgOperand(0)->getType() != ::llvm::IntegerType::get(context, 1)) {
          errs << "  argument 0 (val) has type: "
                 << *getArgOperand(0)->getType() << '\n';
          errs << "  expected: " << *::llvm::IntegerType::get(context, 1) << '\n';
          return false;
        }
      bool const val = getVal();
(void)val;
  return true;
}


      bool ImmutableOp::getVal() const {
        return  ::llvm::cast<::llvm::ConstantInt>(getArgOperand(ArgumentIndex::Val))->getZExtValue() ;
      }



      const ::llvm::StringLiteral InsertElementOp::s_name{"xd.ir.insertelement"};

    InsertElementOp* InsertElementOp::create(llvm_dialects::Builder& b, ::llvm::Value * vector, ::llvm::Value * value, ::llvm::Value * index, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(3);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {vector->getType()});
    auto fnType = ::llvm::FunctionType::get(vector->getType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 3> args = {
vector,
value,
index
      };
      
      return ::llvm::cast<InsertElementOp>(b.CreateCall(fn, args, instName));
    }


    bool InsertElementOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 3) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 3\n";
        return false;
      }
  ::llvm::Type * const vectorType = getVector()->getType();
(void)vectorType;
::llvm::Type * const valueType = getValue()->getType();
(void)valueType;
::llvm::Type * const indexType = getIndex()->getType();
(void)indexType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != indexType) {
          errs << "  unexpected value of $index:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(indexType) << '\n';
        
          return false;
        }
      
        if (vectorType != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(vectorType) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
      
        if (!(::llvm::isa<XdVectorType>(resultType))) {
          errs << "  failed check for (XdVectorType ?:$result, any, ?:$value, any)\n";
          
      errs << "  with $result = " << printable(resultType) << '\n';
    
        
          return false;
        }
      
        if (::llvm::cast<XdVectorType>(resultType)->getElementType() != valueType) {
          errs << "  unexpected value of $value:\n";
          errs << "    expected:  " << printable(::llvm::cast<XdVectorType>(resultType)->getElementType()) << '\n';
          errs << "    actual:    " << printable(valueType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * InsertElementOp::getVector() const {
        return getArgOperand(ArgumentIndex::Vector);
      }

      void InsertElementOp::setVector(::llvm::Value * vector) {
        setArgOperand(ArgumentIndex::Vector, vector);
      }
      ::llvm::Value * InsertElementOp::getValue() const {
        return getArgOperand(ArgumentIndex::Value);
      }

      void InsertElementOp::setValue(::llvm::Value * value) {
        setArgOperand(ArgumentIndex::Value, value);
      }
      ::llvm::Value * InsertElementOp::getIndex() const {
        return getArgOperand(ArgumentIndex::Index);
      }

      void InsertElementOp::setIndex(::llvm::Value * index) {
        setArgOperand(ArgumentIndex::Index, index);
      }
::llvm::Value *InsertElementOp::getResult() {return this;}



      const ::llvm::StringLiteral InstNameConflictDoubleOp::s_name{"xd.ir.inst.name.conflict.double"};

    InstNameConflictDoubleOp* InstNameConflictDoubleOp::create(llvm_dialects::Builder& b, ::llvm::Value * instName, ::llvm::Value * instName_0, const llvm::Twine &instName_1) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 32), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 2> args = {
instName,
instName_0
      };
      
      return ::llvm::cast<InstNameConflictDoubleOp>(b.CreateCall(fn, args, instName_1));
    }


    bool InstNameConflictDoubleOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 2) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 2\n";
        return false;
      }
  ::llvm::Type * const instNameType = getInstName()->getType();
(void)instNameType;
::llvm::Type * const instName_0Type = getInstName_0()->getType();
(void)instName_0Type;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * InstNameConflictDoubleOp::getInstName() const {
        return getArgOperand(ArgumentIndex::InstName);
      }

      void InstNameConflictDoubleOp::setInstName(::llvm::Value * instName) {
        setArgOperand(ArgumentIndex::InstName, instName);
      }
      ::llvm::Value * InstNameConflictDoubleOp::getInstName_0() const {
        return getArgOperand(ArgumentIndex::InstName_0);
      }

      void InstNameConflictDoubleOp::setInstName_0(::llvm::Value * instName_0) {
        setArgOperand(ArgumentIndex::InstName_0, instName_0);
      }
::llvm::Value *InstNameConflictDoubleOp::getResult() {return this;}



      const ::llvm::StringLiteral InstNameConflictOp::s_name{"xd.ir.inst.name.conflict"};

    InstNameConflictOp* InstNameConflictOp::create(llvm_dialects::Builder& b, ::llvm::Value * instName, const llvm::Twine &instName_0) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 32), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
instName
      };
      
      return ::llvm::cast<InstNameConflictOp>(b.CreateCall(fn, args, instName_0));
    }


    bool InstNameConflictOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const instNameType = getInstName()->getType();
(void)instNameType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Value * InstNameConflictOp::getInstName() const {
        return getArgOperand(ArgumentIndex::InstName);
      }

      void InstNameConflictOp::setInstName(::llvm::Value * instName) {
        setArgOperand(ArgumentIndex::InstName, instName);
      }
::llvm::Value *InstNameConflictOp::getResult() {return this;}



      const ::llvm::StringLiteral InstNameConflictVarargsOp::s_name{"xd.ir.inst.name.conflict.varargs"};

    InstNameConflictVarargsOp* InstNameConflictVarargsOp::create(llvm_dialects::Builder& b, ::llvm::ArrayRef<::llvm::Value *> instName_0, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 32), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 0> args = {

      };
      
        args.append(instName_0.begin(), instName_0.end());
      
      return ::llvm::cast<InstNameConflictVarargsOp>(b.CreateCall(fn, args, instName));
    }


    bool InstNameConflictVarargsOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  ::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 32) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 32)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::iterator_range<::llvm::User::value_op_iterator> InstNameConflictVarargsOp::getInstName_0()  {
        return ::llvm::make_range(
            value_op_iterator(arg_begin() + ArgumentIndex::InstName_0Start),
            value_op_iterator(arg_end()));
      }

      InstNameConflictVarargsOp *InstNameConflictVarargsOp::replaceInstName_0(::llvm::ArrayRef<Value *> instName_0) {
        ::llvm::SmallVector<Value *> newArgs;
        if (ArgumentIndex::InstName_0Start > 0)
          newArgs.append(arg_begin(), arg_begin() + ArgumentIndex::InstName_0Start);
        newArgs.append(instName_0.begin(), instName_0.end());
        InstNameConflictVarargsOp *newOp = ::llvm::cast<InstNameConflictVarargsOp>(::llvm::CallInst::Create(getCalledFunction(), newArgs, this->getName(), this->getIterator()));
        newOp->copyMetadata(*this);
        this->replaceAllUsesWith(newOp);
        this->eraseFromParent();
        return newOp;
      }
::llvm::Value *InstNameConflictVarargsOp::getResult() {return this;}



      const ::llvm::StringLiteral NoDescriptionOp::s_name{"xd.ir.no.description.op"};

    NoDescriptionOp* NoDescriptionOp::create(llvm_dialects::Builder& b, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), {
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  return ::llvm::cast<NoDescriptionOp>(b.CreateCall(fn, {}, instName));
}


    bool NoDescriptionOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 0) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 0\n";
        return false;
      }
    return true;
}





      const ::llvm::StringLiteral NoSummaryOp::s_name{"xd.ir.no.summary.op"};

    NoSummaryOp* NoSummaryOp::create(llvm_dialects::Builder& b, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), {
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  return ::llvm::cast<NoSummaryOp>(b.CreateCall(fn, {}, instName));
}


    bool NoSummaryOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 0) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 0\n";
        return false;
      }
    return true;
}





      const ::llvm::StringLiteral ReadOp::s_name{"xd.ir.read"};

    ReadOp* ReadOp::create(llvm_dialects::Builder& b, ::llvm::Type* dataType, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(5);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {dataType});
    auto fnType = ::llvm::FunctionType::get(dataType, {
}, false);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  return ::llvm::cast<ReadOp>(b.CreateCall(fn, {}, instName));
}


    bool ReadOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 0) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 0\n";
        return false;
      }
  ::llvm::Type * const dataType = getData()->getType();
(void)dataType;
  return true;
}


::llvm::Value *ReadOp::getData() {return this;}



      const ::llvm::StringLiteral SetReadOp::s_name{"xd.ir.set.read"};

    SetReadOp* SetReadOp::create(llvm_dialects::Builder& b, ::llvm::Type* dataType, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(5);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {dataType});
    auto fnType = ::llvm::FunctionType::get(dataType, {
}, false);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  return ::llvm::cast<SetReadOp>(b.CreateCall(fn, {}, instName));
}


    bool SetReadOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 0) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 0\n";
        return false;
      }
  ::llvm::Type * const dataType = getData()->getType();
(void)dataType;
  return true;
}


::llvm::Value *SetReadOp::getData() {return this;}



      const ::llvm::StringLiteral SetWriteOp::s_name{"xd.ir.set.write"};

    SetWriteOp* SetWriteOp::create(llvm_dialects::Builder& b, ::llvm::Value * data, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(4);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
data
      };
      
      return ::llvm::cast<SetWriteOp>(b.CreateCall(fn, args, instName));
    }


    bool SetWriteOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const dataType = getData()->getType();
(void)dataType;
  return true;
}


      ::llvm::Value * SetWriteOp::getData() const {
        return getArgOperand(ArgumentIndex::Data);
      }

      void SetWriteOp::setData(::llvm::Value * data) {
        setArgOperand(ArgumentIndex::Data, data);
      }



      const ::llvm::StringLiteral SizeOfOp::s_name{"xd.ir.sizeof"};

    SizeOfOp* SizeOfOp::create(llvm_dialects::Builder& b, ::llvm::Type * sizeofType, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(1);
    auto fnType = ::llvm::FunctionType::get(::llvm::IntegerType::get(context, 64), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
::llvm::PoisonValue::get(sizeofType)
      };
      
      return ::llvm::cast<SizeOfOp>(b.CreateCall(fn, args, instName));
    }


    bool SizeOfOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const sizeofType = getSizeofType();
(void)sizeofType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::IntegerType::get(context, 64) != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 64)) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


      ::llvm::Type * SizeOfOp::getSizeofType() const {
        return getArgOperand(ArgumentIndex::SizeofType)->getType();
      }

      void SizeOfOp::setSizeofType(::llvm::Type * sizeof_type) {
        setArgOperand(ArgumentIndex::SizeofType, llvm::PoisonValue::get(sizeof_type));
      }
::llvm::Value *SizeOfOp::getResult() {return this;}



      const ::llvm::StringLiteral StreamAddOp::s_name{"xd.ir.stream.add"};

    StreamAddOp* StreamAddOp::create(llvm_dialects::Builder& b, ::llvm::Value * ptr, ::llvm::Value * count, ::llvm::Value * initial, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(2);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {initial->getType()});
    auto fnType = ::llvm::FunctionType::get(initial->getType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 3> args = {
ptr,
count,
initial
      };
      
      return ::llvm::cast<StreamAddOp>(b.CreateCall(fn, args, instName));
    }


    bool StreamAddOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 3) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 3\n";
        return false;
      }
  ::llvm::Type * const ptrType = getPtr()->getType();
(void)ptrType;
::llvm::Type * const countType = getCount()->getType();
(void)countType;
::llvm::Type * const initialType = getInitial()->getType();
(void)initialType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::PointerType::get(context, 0) != ptrType) {
          errs << "  unexpected value of $ptr:\n";
          errs << "    expected:  " << printable(::llvm::PointerType::get(context, 0)) << '\n';
          errs << "    actual:    " << printable(ptrType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 64) != countType) {
          errs << "  unexpected value of $count:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 64)) << '\n';
          errs << "    actual:    " << printable(countType) << '\n';
        
          return false;
        }
      
        if (initialType != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(initialType) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


::llvm::Value *StreamAddOp::getResult() {return this;}



      const ::llvm::StringLiteral StreamMaxOp::s_name{"xd.ir.stream.max"};

    StreamMaxOp* StreamMaxOp::create(llvm_dialects::Builder& b, ::llvm::Value * ptr, ::llvm::Value * count, ::llvm::Value * initial, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(2);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {initial->getType()});
    auto fnType = ::llvm::FunctionType::get(initial->getType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 3> args = {
ptr,
count,
initial
      };
      
      return ::llvm::cast<StreamMaxOp>(b.CreateCall(fn, args, instName));
    }


    bool StreamMaxOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 3) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 3\n";
        return false;
      }
  ::llvm::Type * const ptrType = getPtr()->getType();
(void)ptrType;
::llvm::Type * const countType = getCount()->getType();
(void)countType;
::llvm::Type * const initialType = getInitial()->getType();
(void)initialType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::PointerType::get(context, 0) != ptrType) {
          errs << "  unexpected value of $ptr:\n";
          errs << "    expected:  " << printable(::llvm::PointerType::get(context, 0)) << '\n';
          errs << "    actual:    " << printable(ptrType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 64) != countType) {
          errs << "  unexpected value of $count:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 64)) << '\n';
          errs << "    actual:    " << printable(countType) << '\n';
        
          return false;
        }
      
        if (initialType != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(initialType) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


::llvm::Value *StreamMaxOp::getResult() {return this;}



      const ::llvm::StringLiteral StreamMinOp::s_name{"xd.ir.stream.min"};

    StreamMinOp* StreamMinOp::create(llvm_dialects::Builder& b, ::llvm::Value * ptr, ::llvm::Value * count, ::llvm::Value * initial, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(2);
    
      std::string mangledName =
          ::llvm_dialects::getMangledName(s_name, {initial->getType()});
    auto fnType = ::llvm::FunctionType::get(initial->getType(), true);

    auto fn = module.getOrInsertFunction(mangledName, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << mangledName << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 3> args = {
ptr,
count,
initial
      };
      
      return ::llvm::cast<StreamMinOp>(b.CreateCall(fn, args, instName));
    }


    bool StreamMinOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 3) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 3\n";
        return false;
      }
  ::llvm::Type * const ptrType = getPtr()->getType();
(void)ptrType;
::llvm::Type * const countType = getCount()->getType();
(void)countType;
::llvm::Type * const initialType = getInitial()->getType();
(void)initialType;
::llvm::Type * const resultType = getResult()->getType();
(void)resultType;

        if (::llvm::PointerType::get(context, 0) != ptrType) {
          errs << "  unexpected value of $ptr:\n";
          errs << "    expected:  " << printable(::llvm::PointerType::get(context, 0)) << '\n';
          errs << "    actual:    " << printable(ptrType) << '\n';
        
          return false;
        }
      
        if (::llvm::IntegerType::get(context, 64) != countType) {
          errs << "  unexpected value of $count:\n";
          errs << "    expected:  " << printable(::llvm::IntegerType::get(context, 64)) << '\n';
          errs << "    actual:    " << printable(countType) << '\n';
        
          return false;
        }
      
        if (initialType != resultType) {
          errs << "  unexpected value of $result:\n";
          errs << "    expected:  " << printable(initialType) << '\n';
          errs << "    actual:    " << printable(resultType) << '\n';
        
          return false;
        }
        return true;
}


::llvm::Value *StreamMinOp::getResult() {return this;}



      const ::llvm::StringLiteral StringAttrOp::s_name{"xd.ir.string.attr.op"};

    StringAttrOp* StringAttrOp::create(llvm_dialects::Builder& b, ::llvm::StringRef val, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(6);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), {
::llvm::PointerType::get(context, 0),
}, false);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  
::llvm::SmallVector<::llvm::Value*, 1> args = {
 b.CreateGlobalString(val, "str") 
      };
      
      return ::llvm::cast<StringAttrOp>(b.CreateCall(fn, args, instName));
    }


    bool StringAttrOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  
        if (getArgOperand(0)->getType() != ::llvm::PointerType::get(context, 0)) {
          errs << "  argument 0 (val) has type: "
                 << *getArgOperand(0)->getType() << '\n';
          errs << "  expected: " << *::llvm::PointerType::get(context, 0) << '\n';
          return false;
        }
      ::llvm::StringRef const val = getVal();
(void)val;
  return true;
}


      ::llvm::StringRef StringAttrOp::getVal() const {
        return  ::llvm::cast<::llvm::ConstantDataArray>(::llvm::cast<::llvm::GlobalVariable>(getArgOperand(ArgumentIndex::Val))->getInitializer())->getAsString() ;
      }



      const ::llvm::StringLiteral WriteOp::s_name{"xd.ir.write"};

    WriteOp* WriteOp::create(llvm_dialects::Builder& b, ::llvm::Value * data, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(4);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> args = {
data
      };
      
      return ::llvm::cast<WriteOp>(b.CreateCall(fn, args, instName));
    }


    bool WriteOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() != 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected 1\n";
        return false;
      }
  ::llvm::Type * const dataType = getData()->getType();
(void)dataType;
  return true;
}


      ::llvm::Value * WriteOp::getData() const {
        return getArgOperand(ArgumentIndex::Data);
      }

      void WriteOp::setData(::llvm::Value * data) {
        setArgOperand(ArgumentIndex::Data, data);
      }



      const ::llvm::StringLiteral WriteVarArgOp::s_name{"xd.ir.write.vararg"};

    WriteVarArgOp* WriteVarArgOp::create(llvm_dialects::Builder& b, ::llvm::Value * data, ::llvm::ArrayRef<::llvm::Value *> args, const llvm::Twine &instName) {
    ::llvm::LLVMContext& context = b.getContext();
    (void)context;
    ::llvm::Module& module = *b.GetInsertBlock()->getModule();
  
  
      const ::llvm::AttributeList attrs
          = ExampleDialect::get(context).getAttributeList(4);
    auto fnType = ::llvm::FunctionType::get(::llvm::Type::getVoidTy(context), true);

    auto fn = module.getOrInsertFunction(s_name, fnType, attrs);
    ::llvm::SmallString<32> newName;
    for (unsigned i = 0; !::llvm::isa<::llvm::Function>(fn.getCallee()) ||
                         ::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() != fn.getFunctionType(); i++) {
      // If a function with the same name but a different types already exists,
      // we get a bitcast of a function or a function with the wrong type.
      // Try new names until we get one with the correct type.
      newName = "";
      ::llvm::raw_svector_ostream newNameStream(newName);
      newNameStream << s_name << "_" << i;
      fn = module.getOrInsertFunction(newNameStream.str(), fnType, attrs);
    }
    assert(::llvm::isa<::llvm::Function>(fn.getCallee()));
    assert(fn.getFunctionType() == fnType);
    assert(::llvm::cast<::llvm::Function>(fn.getCallee())->getFunctionType() == fn.getFunctionType());

  ::llvm::SmallVector<::llvm::Value*, 1> arguments = {
data
      };
      
        arguments.append(args.begin(), args.end());
      
      return ::llvm::cast<WriteVarArgOp>(b.CreateCall(fn, arguments, instName));
    }


    bool WriteVarArgOp::verifier(::llvm::raw_ostream &errs) {
      ::llvm::LLVMContext &context = getModule()->getContext();
      (void)context;

      using ::llvm_dialects::printable;
  
      if (arg_size() < 1) {
        errs << "  wrong number of arguments: " << arg_size()
               << ", expected at least 1\n";
        return false;
      }
  ::llvm::Type * const dataType = getData()->getType();
(void)dataType;
  return true;
}


      ::llvm::Value * WriteVarArgOp::getData() const {
        return getArgOperand(ArgumentIndex::Data);
      }

      void WriteVarArgOp::setData(::llvm::Value * data) {
        setArgOperand(ArgumentIndex::Data, data);
      }
      ::llvm::iterator_range<::llvm::User::value_op_iterator> WriteVarArgOp::getArgs()  {
        return ::llvm::make_range(
            value_op_iterator(arg_begin() + ArgumentIndex::ArgsStart),
            value_op_iterator(arg_end()));
      }

      WriteVarArgOp *WriteVarArgOp::replaceArgs(::llvm::ArrayRef<Value *> args) {
        ::llvm::SmallVector<Value *> newArgs;
        if (ArgumentIndex::ArgsStart > 0)
          newArgs.append(arg_begin(), arg_begin() + ArgumentIndex::ArgsStart);
        newArgs.append(args.begin(), args.end());
        WriteVarArgOp *newOp = ::llvm::cast<WriteVarArgOp>(::llvm::CallInst::Create(getCalledFunction(), newArgs, this->getName(), this->getIterator()));
        newOp->copyMetadata(*this);
        this->replaceAllUsesWith(newOp);
        this->eraseFromParent();
        return newOp;
      }


} // namespace xd::cpp

      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::Add32Op>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.add32"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::BufferCompareOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.buffer.compare.op"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::CombineOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.combine"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::ExtractElementOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.extractelement"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::FromFixedVectorOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.fromfixedvector"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::HandleGetOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.handle.get"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::IExtOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.iext"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::ITruncOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.itrunc"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::ImmutableOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.immutable.op"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::InsertElementOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.insertelement"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::InstNameConflictDoubleOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.inst.name.conflict.double"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::InstNameConflictOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.inst.name.conflict"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::InstNameConflictVarargsOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.inst.name.conflict.varargs"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::NoDescriptionOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.no.description.op"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::NoSummaryOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.no.summary.op"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::ReadOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.read"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::SetReadOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.set.read"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::SetWriteOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.set.write"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::SizeOfOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.sizeof"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::StreamAddOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.stream.add"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::StreamMaxOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.stream.max"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::StreamMinOp>() {
        static const ::llvm_dialects::OpDescription desc{true, "xd.ir.stream.min"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::StringAttrOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.string.attr.op"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::WriteOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.write"};
        return desc;
      }

    
      template <>
      const ::llvm_dialects::OpDescription &
      ::llvm_dialects::OpDescription::get<xd::cpp::WriteVarArgOp>() {
        static const ::llvm_dialects::OpDescription desc{false, "xd.ir.write.vararg"};
        return desc;
      }

    
#endif // GET_DIALECT_DEFS