9#ifndef LLVM_CLANG_CIR_DIALECT_BUILDER_CIRBASEBUILDER_H 
   10#define LLVM_CLANG_CIR_DIALECT_BUILDER_CIRBASEBUILDER_H 
   18#include "llvm/ADT/STLForwardCompat.h" 
   19#include "llvm/Support/ErrorHandling.h" 
   21#include "mlir/IR/Builders.h" 
   22#include "mlir/IR/BuiltinAttributes.h" 
   23#include "mlir/IR/Location.h" 
   24#include "mlir/IR/Types.h" 
   37                                       llvm::to_underlying(
b));
 
 
   42                                       llvm::to_underlying(
b));
 
 
   61      : 
mlir::OpBuilder(&mlirContext) {}
 
 
   65                            const llvm::APInt &val) {
 
   66    return cir::ConstantOp::create(*
this, loc, cir::IntAttr::get(typ, val));
 
 
   69  cir::ConstantOp 
getConstant(mlir::Location loc, mlir::TypedAttr attr) {
 
   70    return cir::ConstantOp::create(*
this, loc, attr);
 
 
   75    return getConstant(loc, cir::IntAttr::get(ty, value));
 
 
   78  mlir::Value 
getSignedInt(mlir::Location loc, int64_t val, 
unsigned numBits) {
 
   79    auto type = cir::IntType::get(getContext(), numBits, 
true);
 
   81                         llvm::APInt(numBits, val, 
true));
 
 
   86    auto type = cir::IntType::get(getContext(), numBits, 
false);
 
 
   96    assert(mlir::isa<cir::PointerType>(t) && 
"expected cir.ptr");
 
 
  101    if (mlir::isa<cir::IntType>(ty))
 
  102      return cir::IntAttr::get(ty, 0);
 
  103    if (cir::isAnyFloatingPointType(ty))
 
  104      return cir::FPAttr::getZero(ty);
 
  105    if (
auto complexType = mlir::dyn_cast<cir::ComplexType>(ty))
 
  106      return cir::ZeroAttr::get(complexType);
 
  107    if (
auto arrTy = mlir::dyn_cast<cir::ArrayType>(ty))
 
  108      return cir::ZeroAttr::get(arrTy);
 
  109    if (
auto vecTy = mlir::dyn_cast<cir::VectorType>(ty))
 
  110      return cir::ZeroAttr::get(vecTy);
 
  111    if (
auto ptrTy = mlir::dyn_cast<cir::PointerType>(ty))
 
  113    if (
auto recordTy = mlir::dyn_cast<cir::RecordType>(ty))
 
  114      return cir::ZeroAttr::get(recordTy);
 
  115    if (mlir::isa<cir::BoolType>(ty)) {
 
  118    llvm_unreachable(
"Zero initializer for given type is NYI");
 
 
  121  cir::ConstantOp 
getBool(
bool state, mlir::Location loc) {
 
  122    return cir::ConstantOp::create(*
this, loc, 
getCIRBoolAttr(state));
 
 
  127  cir::BoolType 
getBoolTy() { 
return cir::BoolType::get(getContext()); }
 
  128  cir::VoidType 
getVoidTy() { 
return cir::VoidType::get(getContext()); }
 
  131    return cir::IntType::get(getContext(), n, 
false);
 
 
  135    return cir::IntType::get(getContext(), n, 
true);
 
 
  139    return cir::PointerType::get(ty);
 
 
  142  cir::PointerType 
getPointerTo(mlir::Type ty, cir::TargetAddressSpaceAttr as) {
 
  143    return cir::PointerType::get(ty, as);
 
 
  152      auto asAttr = cir::TargetAddressSpaceAttr::get(
 
  153          getContext(), getUI32IntegerAttr(addrSpace));
 
  157    llvm_unreachable(
"language-specific address spaces NYI");
 
 
  161    return getPointerTo(cir::VoidType::get(getContext()), langAS);
 
 
  165    return getPointerTo(cir::VoidType::get(getContext()), as);
 
 
  169    return cir::BoolAttr::get(getContext(), state);
 
 
  177    auto resultComplexTy = cir::ComplexType::get(real.getType());
 
  178    return cir::ComplexCreateOp::create(*
this, loc, resultComplexTy, real,
 
 
  183    auto resultType = operand.getType();
 
  184    if (
auto complexResultType = mlir::dyn_cast<cir::ComplexType>(resultType))
 
  185      resultType = complexResultType.getElementType();
 
  186    return cir::ComplexRealOp::create(*
this, loc, resultType, operand);
 
 
  190    auto resultType = operand.getType();
 
  191    if (
auto complexResultType = mlir::dyn_cast<cir::ComplexType>(resultType))
 
  192      resultType = complexResultType.getElementType();
 
  193    return cir::ComplexImagOp::create(*
this, loc, resultType, operand);
 
 
  197                         bool isVolatile = 
false, uint64_t alignment = 0) {
 
  199    return cir::LoadOp::create(*
this, loc, ptr, 
false, isVolatile,
 
  200                               alignmentAttr, cir::MemOrderAttr{});
 
 
  204                                uint64_t alignment) {
 
  205    return createLoad(loc, ptr, 
false, alignment);
 
 
  209    return cir::UnaryOp::create(*
this, value.getLoc(), value.getType(),
 
  210                                cir::UnaryOpKind::Not, value);
 
 
  216      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> condBuilder,
 
  217      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> bodyBuilder) {
 
  218    return cir::DoWhileOp::create(*
this, loc, condBuilder, bodyBuilder);
 
 
  224      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> condBuilder,
 
  225      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> bodyBuilder) {
 
  226    return cir::WhileOp::create(*
this, loc, condBuilder, bodyBuilder);
 
 
  232      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> condBuilder,
 
  233      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> bodyBuilder,
 
  234      llvm::function_ref<
void(mlir::OpBuilder &, mlir::Location)> stepBuilder) {
 
  235    return cir::ForOp::create(*
this, loc, condBuilder, bodyBuilder,
 
 
  241    return cir::BreakOp::create(*
this, loc);
 
 
  246    return cir::ContinueOp::create(*
this, loc);
 
 
  250                            mlir::Value operand) {
 
  251    return cir::UnaryOp::create(*
this, loc, kind, operand);
 
 
  255    return cir::ConstPtrAttr::get(type, getI64IntegerAttr(value));
 
 
  258  mlir::Value 
createAlloca(mlir::Location loc, cir::PointerType addrType,
 
  259                           mlir::Type type, llvm::StringRef name,
 
  260                           mlir::IntegerAttr alignment,
 
  261                           mlir::Value dynAllocSize) {
 
  262    return cir::AllocaOp::create(*
this, loc, addrType, type, name, alignment,
 
 
  266  mlir::Value 
createAlloca(mlir::Location loc, cir::PointerType addrType,
 
  267                           mlir::Type type, llvm::StringRef name,
 
  269                           mlir::Value dynAllocSize) {
 
  271    return createAlloca(loc, addrType, type, name, alignmentAttr, dynAllocSize);
 
 
  274  mlir::Value 
createAlloca(mlir::Location loc, cir::PointerType addrType,
 
  275                           mlir::Type type, llvm::StringRef name,
 
  276                           mlir::IntegerAttr alignment) {
 
  277    return cir::AllocaOp::create(*
this, loc, addrType, type, name, alignment);
 
 
  280  mlir::Value 
createAlloca(mlir::Location loc, cir::PointerType addrType,
 
  281                           mlir::Type type, llvm::StringRef name,
 
  284    return createAlloca(loc, addrType, type, name, alignmentAttr);
 
 
  290                                        mlir::ArrayAttr indices = {}) {
 
  291    cir::PointerType type = 
getPointerTo(globalOp.getSymType());
 
 
  297                                        cir::GlobalOp globalOp,
 
  298                                        mlir::ArrayAttr indices = {}) {
 
  299    auto symbol = mlir::FlatSymbolRefAttr::get(globalOp.getSymNameAttr());
 
  300    return cir::GlobalViewAttr::get(type, symbol, indices);
 
 
  305    return cir::GetGlobalOp::create(
 
  306        *
this, loc, 
getPointerTo(global.getSymType()), global.getSymName());
 
 
  315                         bool isVolatile = 
false) {
 
  316    return cir::CopyOp::create(*
this, dst.getLoc(), dst, src, isVolatile);
 
 
  319  cir::StoreOp 
createStore(mlir::Location loc, mlir::Value val, mlir::Value dst,
 
  320                           bool isVolatile = 
false,
 
  321                           mlir::IntegerAttr align = {},
 
  322                           cir::MemOrderAttr order = {}) {
 
  323    return cir::StoreOp::create(*
this, loc, val, dst, isVolatile, align, order);
 
 
  328                                           mlir::StringRef name,
 
  329                                           mlir::Type type, 
bool isConstant,
 
  330                                           cir::GlobalLinkageKind linkage) {
 
  331    mlir::OpBuilder::InsertionGuard guard(*
this);
 
  332    setInsertionPointToStart(mlirModule.getBody());
 
  333    return cir::GlobalOp::create(*
this, loc, name, type, isConstant, linkage);
 
 
  337                                   mlir::Value base, llvm::StringRef name,
 
  339    return cir::GetMemberOp::create(*
this, loc, resultTy, base, name, index);
 
 
  346    return cir::LoadOp::create(*
this, loc, addr, 
false,
 
  347                               false, alignmentAttr,
 
 
  352                                   mlir::Value stride) {
 
  353    return cir::PtrStrideOp::create(*
this, loc, base.getType(), base, stride);
 
 
  360  cir::CallOp 
createCallOp(mlir::Location loc, mlir::SymbolRefAttr callee,
 
  361                           mlir::Type returnType, mlir::ValueRange operands,
 
  363    auto op = cir::CallOp::create(*
this, loc, callee, returnType, operands);
 
 
  369                           mlir::ValueRange operands,
 
  371    return createCallOp(loc, mlir::SymbolRefAttr::get(callee),
 
  372                        callee.getFunctionType().getReturnType(), operands,
 
 
  378                       cir::FuncType funcType, mlir::ValueRange operands,
 
  381    resOperands.append(operands.begin(), operands.end());
 
  382    return createCallOp(loc, mlir::SymbolRefAttr(), funcType.getReturnType(),
 
 
  386  cir::CallOp 
createCallOp(mlir::Location loc, mlir::SymbolRefAttr callee,
 
  387                           mlir::ValueRange operands = mlir::ValueRange(),
 
  389    return createCallOp(loc, callee, cir::VoidType(), operands, attrs);
 
 
  393      mlir::Location loc, mlir::SymbolRefAttr callee = mlir::SymbolRefAttr(),
 
  394      mlir::Type returnType = cir::VoidType(),
 
  395      mlir::ValueRange operands = mlir::ValueRange(),
 
  396      [[maybe_unused]] cir::SideEffect sideEffect = cir::SideEffect::All) {
 
 
  403      mlir::Location loc, cir::FuncOp callee, mlir::ValueRange operands,
 
  404      [[maybe_unused]] cir::SideEffect sideEffect = cir::SideEffect::All) {
 
  408                           callee.getFunctionType().getReturnType(), operands);
 
 
  415  mlir::Value 
createCast(mlir::Location loc, cir::CastKind kind,
 
  416                         mlir::Value src, mlir::Type newTy) {
 
  417    if (newTy == src.getType())
 
  419    return cir::CastOp::create(*
this, loc, newTy, kind, src);
 
 
  424    if (newTy == src.getType())
 
  426    return createCast(src.getLoc(), kind, src, newTy);
 
 
  430    return createCast(cir::CastKind::integral, src, newTy);
 
 
  434    return createCast(cir::CastKind::int_to_ptr, src, newTy);
 
 
  438    return createCast(cir::CastKind::ptr_to_int, src, newTy);
 
 
  446    return createCast(cir::CastKind::bool_to_int, src, newTy);
 
 
  450    return createCast(cir::CastKind::bitcast, src, newTy);
 
 
  455    return createCast(loc, cir::CastKind::bitcast, src, newTy);
 
 
  459    assert(mlir::isa<cir::PointerType>(src.getType()) && 
"expected ptr src");
 
 
  464    mlir::Value nullPtr = 
getNullPtr(ptr.getType(), ptr.getLoc());
 
  465    return createCompare(ptr.getLoc(), cir::CmpOpKind::eq, ptr, nullPtr);
 
 
  473                          cir::BinOpKind kind, mlir::Value rhs) {
 
  474    return cir::BinOp::create(*
this, loc, lhs.getType(), kind, lhs, rhs);
 
 
  479    llvm::APInt val = llvm::APInt::getLowBitsSet(size, bits);
 
  480    auto type = cir::IntType::get(getContext(), size, 
false);
 
 
  484  mlir::Value 
createAnd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
 
  485    return createBinop(loc, lhs, cir::BinOpKind::And, rhs);
 
 
  488  mlir::Value 
createOr(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
 
  489    return createBinop(loc, lhs, cir::BinOpKind::Or, rhs);
 
 
  493                           mlir::Value trueValue, mlir::Value falseValue) {
 
  494    assert(trueValue.getType() == falseValue.getType() &&
 
  495           "trueValue and falseValue should have the same type");
 
  496    return cir::SelectOp::create(*
this, loc, trueValue.getType(), condition,
 
  497                                 trueValue, falseValue);
 
 
  510  mlir::Value 
createMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs,
 
  512    auto op = cir::BinOp::create(*
this, loc, lhs.getType(), cir::BinOpKind::Mul,
 
  514    op.setNoUnsignedWrap(
 
 
  529  mlir::Value 
createSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs,
 
  531    auto op = cir::BinOp::create(*
this, loc, lhs.getType(), cir::BinOpKind::Sub,
 
  533    op.setNoUnsignedWrap(
 
 
  551  mlir::Value 
createAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs,
 
  553    auto op = cir::BinOp::create(*
this, loc, lhs.getType(), cir::BinOpKind::Add,
 
  555    op.setNoUnsignedWrap(
 
 
  574                           mlir::Value lhs, mlir::Value rhs) {
 
  575    return cir::CmpOp::create(*
this, loc, 
getBoolTy(), kind, lhs, rhs);
 
 
  578  mlir::Value 
createIsNaN(mlir::Location loc, mlir::Value operand) {
 
  579    return createCompare(loc, cir::CmpOpKind::ne, operand, operand);
 
 
  582  mlir::Value 
createShift(mlir::Location loc, mlir::Value lhs, mlir::Value rhs,
 
  584    return cir::ShiftOp::create(*
this, loc, lhs.getType(), lhs, rhs,
 
 
  589                          const llvm::APInt &rhs, 
bool isShiftLeft) {
 
 
  594  mlir::Value 
createShift(mlir::Location loc, mlir::Value lhs, 
unsigned bits,
 
  596    auto width = mlir::dyn_cast<cir::IntType>(lhs.getType()).getWidth();
 
  597    auto shift = llvm::APInt(width, bits);
 
 
  627        std::find_if(block->rbegin(), block->rend(), [](mlir::Operation &op) {
 
  628          return mlir::isa<cir::AllocaOp, cir::LabelOp>(&op);
 
  631    if (last != block->rend())
 
  632      return OpBuilder::InsertPoint(block, ++mlir::Block::iterator(&*last));
 
  633    return OpBuilder::InsertPoint(block, block->begin());
 
 
  654    return alignment ? getI64IntegerAttr(alignment) : mlir::IntegerAttr();
 
 
  662  cir::ConstantOp 
getNullPtr(mlir::Type ty, mlir::Location loc) {
 
 
  669    return cir::ConditionOp::create(*
this, condition.getLoc(), condition);
 
 
  673  cir::YieldOp 
createYield(mlir::Location loc, mlir::ValueRange value = {}) {
 
  674    return cir::YieldOp::create(*
this, loc, value);
 
 
 
Provides definitions for the various language-specific address spaces.
mlir::Value createNSWSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::ConstantOp getBool(bool state, mlir::Location loc)
mlir::Value createShift(mlir::Location loc, mlir::Value lhs, unsigned bits, bool isShiftLeft)
cir::WhileOp createWhile(mlir::Location loc, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> condBuilder, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> bodyBuilder)
Create a while operation.
cir::BreakOp createBreak(mlir::Location loc)
Create a break operation.
mlir::TypedAttr getConstNullPtrAttr(mlir::Type t)
mlir::Value createGetGlobal(mlir::Location loc, cir::GlobalOp global)
mlir::IntegerAttr getAlignmentAttr(int64_t alignment)
mlir::Value createShift(mlir::Location loc, mlir::Value lhs, const llvm::APInt &rhs, bool isShiftLeft)
mlir::Value getConstAPInt(mlir::Location loc, mlir::Type typ, const llvm::APInt &val)
cir::GlobalViewAttr getGlobalViewAttr(cir::PointerType type, cir::GlobalOp globalOp, mlir::ArrayAttr indices={})
Get constant address of a global variable as an MLIR attribute.
mlir::Value createCast(cir::CastKind kind, mlir::Value src, mlir::Type newTy)
mlir::Value createLogicalOr(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
mlir::Value createShift(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, bool isShiftLeft)
cir::ConditionOp createCondition(mlir::Value condition)
Create a loop condition.
mlir::Value createLowBitsSet(mlir::Location loc, unsigned size, unsigned bits)
mlir::Value createNSWAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::GlobalViewAttr getGlobalViewAttr(cir::GlobalOp globalOp, mlir::ArrayAttr indices={})
Get constant address of a global variable as an MLIR attribute.
cir::VoidType getVoidTy()
cir::CallOp createCallOp(mlir::Location loc, mlir::SymbolRefAttr callee, mlir::ValueRange operands=mlir::ValueRange(), llvm::ArrayRef< mlir::NamedAttribute > attrs={})
cir::ConstantOp getNullValue(mlir::Type ty, mlir::Location loc)
cir::BoolAttr getCIRBoolAttr(bool state)
mlir::Value createBoolToInt(mlir::Value src, mlir::Type newTy)
cir::ConstantOp getConstant(mlir::Location loc, mlir::TypedAttr attr)
mlir::Value createNUWAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
mlir::Value createOr(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
mlir::Value createPtrIsNull(mlir::Value ptr)
mlir::Value createShiftLeft(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
mlir::Value createCast(mlir::Location loc, cir::CastKind kind, mlir::Value src, mlir::Type newTy)
mlir::IntegerAttr getSizeFromCharUnits(clang::CharUnits size)
cir::PtrStrideOp createPtrStride(mlir::Location loc, mlir::Value base, mlir::Value stride)
mlir::Value createIntToPtr(mlir::Value src, mlir::Type newTy)
cir::CallOp createCallOp(mlir::Location loc, cir::FuncOp callee, mlir::ValueRange operands, llvm::ArrayRef< mlir::NamedAttribute > attrs={})
cir::ForOp createFor(mlir::Location loc, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> condBuilder, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> bodyBuilder, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> stepBuilder)
Create a for operation.
static OpBuilder::InsertPoint getBestAllocaInsertPoint(mlir::Block *block)
mlir::Value createPtrToInt(mlir::Value src, mlir::Type newTy)
mlir::Value createNUWSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::ConstantOp getFalse(mlir::Location loc)
mlir::Value createAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::None)
cir::GetMemberOp createGetMember(mlir::Location loc, mlir::Type resultTy, mlir::Value base, llvm::StringRef name, unsigned index)
cir::PointerType getPointerTo(mlir::Type ty)
mlir::Value createNot(mlir::Value value)
mlir::Value createComplexImag(mlir::Location loc, mlir::Value operand)
cir::ConstantOp getTrue(mlir::Location loc)
mlir::Value createNSWMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::ConstantOp getNullPtr(mlir::Type ty, mlir::Location loc)
mlir::Value createGetGlobal(cir::GlobalOp global)
cir::IntType getUIntNTy(int n)
cir::PointerType getVoidPtrTy(cir::TargetAddressSpaceAttr as)
cir::DoWhileOp createDoWhile(mlir::Location loc, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> condBuilder, llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> bodyBuilder)
Create a do-while operation.
mlir::Value createNUWAMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::CopyOp createCopy(mlir::Value dst, mlir::Value src, bool isVolatile=false)
Create a copy with inferred length.
cir::CallOp createCallOp(mlir::Location loc, mlir::SymbolRefAttr callee, mlir::Type returnType, mlir::ValueRange operands, llvm::ArrayRef< mlir::NamedAttribute > attrs={})
mlir::Value createPtrBitcast(mlir::Value src, mlir::Type newPointeeTy)
cir::CallOp createTryCallOp(mlir::Location loc, mlir::SymbolRefAttr callee=mlir::SymbolRefAttr(), mlir::Type returnType=cir::VoidType(), mlir::ValueRange operands=mlir::ValueRange(), cir::SideEffect sideEffect=cir::SideEffect::All)
mlir::Value createShiftLeft(mlir::Location loc, mlir::Value lhs, unsigned bits)
mlir::Value createSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::Saturated)
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType, mlir::Type type, llvm::StringRef name, clang::CharUnits alignment, mlir::Value dynAllocSize)
mlir::Value getSignedInt(mlir::Location loc, int64_t val, unsigned numBits)
mlir::Value createAnd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::PointerType getPointerTo(mlir::Type ty, clang::LangAS langAS)
mlir::Value createIntCast(mlir::Value src, mlir::Type newTy)
cir::CallOp createTryCallOp(mlir::Location loc, cir::FuncOp callee, mlir::ValueRange operands, cir::SideEffect sideEffect=cir::SideEffect::All)
mlir::Value createBitcast(mlir::Value src, mlir::Type newTy)
CIRBaseBuilderTy(mlir::MLIRContext &mlirContext)
mlir::Value createBitcast(mlir::Location loc, mlir::Value src, mlir::Type newTy)
cir::GlobalOp createGlobal(mlir::ModuleOp mlirModule, mlir::Location loc, mlir::StringRef name, mlir::Type type, bool isConstant, cir::GlobalLinkageKind linkage)
cir::StoreOp createStore(mlir::Location loc, mlir::Value val, mlir::Value dst, bool isVolatile=false, mlir::IntegerAttr align={}, cir::MemOrderAttr order={})
cir::CmpOp createCompare(mlir::Location loc, cir::CmpOpKind kind, mlir::Value lhs, mlir::Value rhs)
mlir::IntegerAttr getAlignmentAttr(clang::CharUnits alignment)
mlir::Value createBinop(mlir::Location loc, mlir::Value lhs, cir::BinOpKind kind, mlir::Value rhs)
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType, mlir::Type type, llvm::StringRef name, mlir::IntegerAttr alignment)
mlir::Value createSelect(mlir::Location loc, mlir::Value condition, mlir::Value trueValue, mlir::Value falseValue)
cir::ContinueOp createContinue(mlir::Location loc)
Create a continue operation.
mlir::Value createMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::None)
mlir::TypedAttr getZeroInitAttr(mlir::Type ty)
cir::LoadOp createLoad(mlir::Location loc, mlir::Value ptr, bool isVolatile=false, uint64_t alignment=0)
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType, mlir::Type type, llvm::StringRef name, clang::CharUnits alignment)
cir::CallOp createIndirectCallOp(mlir::Location loc, mlir::Value indirectTarget, cir::FuncType funcType, mlir::ValueRange operands, llvm::ArrayRef< mlir::NamedAttribute > attrs={})
CIRBaseBuilderTy(mlir::OpBuilder &builder)
cir::ConstantOp getConstantInt(mlir::Location loc, mlir::Type ty, int64_t value)
mlir::Value createComplexCreate(mlir::Location loc, mlir::Value real, mlir::Value imag)
cir::PointerType getPointerTo(mlir::Type ty, cir::TargetAddressSpaceAttr as)
mlir::Value createPtrToBoolCast(mlir::Value v)
cir::BoolAttr getTrueAttr()
cir::PointerType getVoidPtrTy(clang::LangAS langAS=clang::LangAS::Default)
mlir::Value createShiftRight(mlir::Location loc, mlir::Value lhs, unsigned bits)
mlir::Value createIsNaN(mlir::Location loc, mlir::Value operand)
cir::IntType getSIntNTy(int n)
mlir::Value createAlignedLoad(mlir::Location loc, mlir::Value ptr, uint64_t alignment)
mlir::TypedAttr getConstPtrAttr(mlir::Type type, int64_t value)
mlir::Value createDummyValue(mlir::Location loc, mlir::Type type, clang::CharUnits alignment)
cir::BoolAttr getFalseAttr()
mlir::Value createShiftRight(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::YieldOp createYield(mlir::Location loc, mlir::ValueRange value={})
Create a yield operation.
mlir::Value createLogicalAnd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
mlir::Value createUnaryOp(mlir::Location loc, cir::UnaryOpKind kind, mlir::Value operand)
mlir::IntegerAttr getAlignmentAttr(llvm::Align alignment)
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType, mlir::Type type, llvm::StringRef name, mlir::IntegerAttr alignment, mlir::Value dynAllocSize)
cir::BoolType getBoolTy()
mlir::Value getUnsignedInt(mlir::Location loc, uint64_t val, unsigned numBits)
mlir::Value createComplexReal(mlir::Location loc, mlir::Value operand)
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
constexpr OverflowBehavior operator|(OverflowBehavior a, OverflowBehavior b)
constexpr OverflowBehavior operator&(OverflowBehavior a, OverflowBehavior b)
constexpr OverflowBehavior & operator|=(OverflowBehavior &a, OverflowBehavior b)
constexpr OverflowBehavior & operator&=(OverflowBehavior &a, OverflowBehavior b)
bool isTargetAddressSpace(LangAS AS)
unsigned toTargetAddressSpace(LangAS AS)
LangAS
Defines the address space values used by the address space qualifier of QualType.
static bool addressSpace()
static bool targetCodeGenInfoGetNullPointer()
static bool opCallSideEffect()
static bool opCallCallConv()