17 #include "llvm/ADT/SmallVectorExtras.h"
18 #include "llvm/ADT/StringSet.h"
19 #include "llvm/Support/FormatVariadic.h"
26 LLVM::LLVMFunctionType type) {
28 if (!(ret = moduleOp.template lookupSymbol<LLVM::LLVMFuncOp>(name))) {
31 ret = b.
create<LLVM::LLVMFuncOp>(loc, name, type, LLVM::Linkage::External);
39 unsigned stringNumber = 0;
42 stringConstName.clear();
43 (prefix + Twine(stringNumber++)).toStringRef(stringConstName);
44 }
while (moduleOp.lookupSymbol(stringConstName));
45 return stringConstName;
50 gpu::GPUModuleOp moduleOp,
Type llvmI8,
51 StringRef namePrefix, StringRef str,
52 uint64_t alignment,
unsigned addrSpace) {
54 nullTermStr.push_back(
'\0');
60 for (
auto globalOp : moduleOp.getOps<LLVM::GlobalOp>())
61 if (globalOp.getGlobalType() == globalType && globalOp.getConstant() &&
62 globalOp.getValueAttr() == attr &&
63 globalOp.getAlignment().value_or(0) == alignment &&
64 globalOp.getAddrSpace() == addrSpace)
71 return b.
create<LLVM::GlobalOp>(loc, globalType,
72 true, LLVM::Linkage::Internal,
73 name, attr, alignment, addrSpace);
82 if (encodeWorkgroupAttributionsAsArguments) {
87 gpuFuncOp.getWorkgroupAttributions();
88 size_t numAttributions = workgroupAttributions.size();
91 unsigned index = gpuFuncOp.getNumArguments();
95 Type workgroupPtrType =
96 rewriter.
getType<LLVM::LLVMPointerType>(workgroupAddrSpace);
101 rewriter.
getNamedAttr(LLVM::LLVMDialect::getNoAliasAttrName(),
104 getDialect().getWorkgroupAttributionAttrHelper().getName(),
109 auto attributionType = cast<MemRefType>(attribution.getType());
110 IntegerAttr numElements =
112 Type llvmElementType =
114 if (!llvmElementType)
117 attrs.back().setValue(
118 rewriter.
getAttr<LLVM::WorkgroupAttributionAttr>(numElements, type));
127 gpuFuncOp, [gpuFuncOp, &argIndices, &argTypes, &argAttrs, &argLocs]() {
128 LogicalResult inserted =
129 static_cast<FunctionOpInterface
>(gpuFuncOp).insertArguments(
130 argIndices, argTypes, argAttrs, argLocs);
132 assert(succeeded(inserted) &&
133 "expected GPU funcs to support inserting any argument");
136 workgroupBuffers.reserve(gpuFuncOp.getNumWorkgroupAttributions());
137 for (
auto [idx, attribution] :
139 auto type = dyn_cast<MemRefType>(attribution.getType());
140 assert(type && type.hasStaticShape() &&
"unexpected type in attribution");
142 uint64_t numElements = type.getNumElements();
148 std::string(llvm::formatv(
"__wg_{0}_{1}", gpuFuncOp.getName(), idx));
149 uint64_t alignment = 0;
150 if (
auto alignAttr = dyn_cast_or_null<IntegerAttr>(
151 gpuFuncOp.getWorkgroupAttributionAttr(
152 idx, LLVM::LLVMDialect::getAlignAttrName())))
153 alignment = alignAttr.getInt();
154 auto globalOp = rewriter.
create<LLVM::GlobalOp>(
155 gpuFuncOp.getLoc(), arrayType,
false,
156 LLVM::Linkage::Internal, name,
Attribute(), alignment,
158 workgroupBuffers.push_back(globalOp);
164 gpuFuncOp.front().getNumArguments());
167 gpuFuncOp.getFunctionType(),
false,
171 diag <<
"failed to convert function signature type for: "
172 << gpuFuncOp.getFunctionType();
180 for (
const auto &attr : gpuFuncOp->getAttrs()) {
182 attr.getName() == gpuFuncOp.getFunctionTypeAttrName() ||
184 gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName() ||
185 attr.getName() == gpuFuncOp.getWorkgroupAttribAttrsAttrName() ||
186 attr.getName() == gpuFuncOp.getPrivateAttribAttrsAttrName() ||
187 attr.getName() == gpuFuncOp.getKnownBlockSizeAttrName() ||
188 attr.getName() == gpuFuncOp.getKnownGridSizeAttrName())
190 if (attr.getName() == gpuFuncOp.getArgAttrsAttrName()) {
191 argAttrs = gpuFuncOp.getArgAttrsAttr();
194 attributes.push_back(attr);
201 auto *gpuDialect = cast<gpu::GPUDialect>(gpuFuncOp->getDialect());
203 attributes.emplace_back(gpuDialect->getKnownBlockSizeAttrHelper().getName(),
206 attributes.emplace_back(gpuDialect->getKnownGridSizeAttrHelper().getName(),
212 if (gpuFuncOp.isKernel()) {
213 if (kernelAttributeName)
214 attributes.emplace_back(kernelAttributeName, rewriter.
getUnitAttr());
216 if (kernelBlockSizeAttributeName && knownBlockSize) {
217 attributes.emplace_back(kernelBlockSizeAttributeName, knownBlockSize);
220 LLVM::CConv callingConvention = gpuFuncOp.isKernel()
221 ? kernelCallingConvention
222 : nonKernelCallingConvention;
223 auto llvmFuncOp = rewriter.
create<LLVM::LLVMFuncOp>(
224 gpuFuncOp.getLoc(), gpuFuncOp.getName(), funcType,
225 LLVM::Linkage::External,
false, callingConvention,
226 nullptr, attributes);
238 unsigned numProperArguments = gpuFuncOp.getNumArguments();
240 if (encodeWorkgroupAttributionsAsArguments) {
243 unsigned numAttributions = gpuFuncOp.getNumWorkgroupAttributions();
244 assert(numProperArguments >= numAttributions &&
245 "Expecting attributions to be encoded as arguments already");
250 gpuFuncOp.getArguments().slice(numProperArguments - numAttributions,
253 gpuFuncOp.getWorkgroupAttributions(), attributionArguments))) {
254 auto [attribution, arg] = vals;
255 auto type = cast<MemRefType>(attribution.getType());
263 signatureConversion.
remapInput(numProperArguments + idx, descr);
268 global.getAddrSpace());
269 Value address = rewriter.
create<LLVM::AddressOfOp>(
270 loc, ptrType, global.getSymNameAttr());
272 rewriter.
create<LLVM::GEPOp>(loc, ptrType, global.getType(),
279 Value attribution = gpuFuncOp.getWorkgroupAttributions()[idx];
280 auto type = cast<MemRefType>(attribution.getType());
283 signatureConversion.
remapInput(numProperArguments + idx, descr);
288 unsigned numWorkgroupAttributions = gpuFuncOp.getNumWorkgroupAttributions();
290 for (
const auto [idx, attribution] :
292 auto type = cast<MemRefType>(attribution.getType());
293 assert(type && type.hasStaticShape() &&
"unexpected type in attribution");
301 Value numElements = rewriter.
create<LLVM::ConstantOp>(
302 gpuFuncOp.getLoc(), int64Ty, type.getNumElements());
303 uint64_t alignment = 0;
305 dyn_cast_or_null<IntegerAttr>(gpuFuncOp.getPrivateAttributionAttr(
306 idx, LLVM::LLVMDialect::getAlignAttrName())))
307 alignment = alignAttr.getInt();
309 gpuFuncOp.getLoc(), ptrType, elementType, numElements, alignment);
313 numProperArguments + numWorkgroupAttributions + idx, descr);
321 &signatureConversion)))
326 for (
const auto [idx, argTy] :
330 argAttrs ? cast<DictionaryAttr>(argAttrs[idx]) :
NamedAttrList();
331 auto copyAttribute = [&](StringRef attrName) {
335 for (
size_t i = 0, e = remapping->size; i < e; ++i)
336 llvmFuncOp.setArgAttr(remapping->inputNo + i, attrName, attr);
338 auto copyPointerAttribute = [&](StringRef attrName) {
343 if (remapping->size > 1 &&
344 attrName == LLVM::LLVMDialect::getNoAliasAttrName()) {
346 "Cannot copy noalias with non-bare pointers.\n");
349 for (
size_t i = 0, e = remapping->size; i < e; ++i) {
350 if (isa<LLVM::LLVMPointerType>(
351 llvmFuncOp.getArgument(remapping->inputNo + i).getType())) {
352 llvmFuncOp.setArgAttr(remapping->inputNo + i, attrName, attr);
360 copyAttribute(LLVM::LLVMDialect::getReturnedAttrName());
361 copyAttribute(LLVM::LLVMDialect::getNoUndefAttrName());
362 copyAttribute(LLVM::LLVMDialect::getInRegAttrName());
363 bool lowersToPointer =
false;
364 for (
size_t i = 0, e = remapping->size; i < e; ++i) {
365 lowersToPointer |= isa<LLVM::LLVMPointerType>(
366 llvmFuncOp.getArgument(remapping->inputNo + i).getType());
369 if (lowersToPointer) {
370 copyPointerAttribute(LLVM::LLVMDialect::getNoAliasAttrName());
371 copyPointerAttribute(LLVM::LLVMDialect::getNoCaptureAttrName());
372 copyPointerAttribute(LLVM::LLVMDialect::getNoFreeAttrName());
373 copyPointerAttribute(LLVM::LLVMDialect::getAlignAttrName());
374 copyPointerAttribute(LLVM::LLVMDialect::getReadonlyAttrName());
375 copyPointerAttribute(LLVM::LLVMDialect::getWriteOnlyAttrName());
376 copyPointerAttribute(LLVM::LLVMDialect::getReadnoneAttrName());
377 copyPointerAttribute(LLVM::LLVMDialect::getNonNullAttrName());
378 copyPointerAttribute(LLVM::LLVMDialect::getDereferenceableAttrName());
379 copyPointerAttribute(
380 LLVM::LLVMDialect::getDereferenceableOrNullAttrName());
381 copyPointerAttribute(
382 LLVM::LLVMDialect::WorkgroupAttributionAttrHelper::getNameStr());
390 gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor,
392 Location loc = gpuPrintfOp->getLoc();
401 auto moduleOp = gpuPrintfOp->getParentOfType<gpu::GPUModuleOp>();
406 LLVM::LLVMFuncOp ocklAppendArgs;
407 if (!adaptor.getArgs().empty()) {
409 moduleOp, loc, rewriter,
"__ockl_printf_append_args",
411 llvmI64, {llvmI64, llvmI32, llvmI64, llvmI64, llvmI64,
412 llvmI64, llvmI64, llvmI64, llvmI64, llvmI32}));
415 moduleOp, loc, rewriter,
"__ockl_printf_append_string_n",
418 {llvmI64, ptrType, llvmI64, llvmI32}));
421 Value zeroI64 = rewriter.
create<LLVM::ConstantOp>(loc, llvmI64, 0);
422 auto printfBeginCall = rewriter.
create<LLVM::CallOp>(loc, ocklBegin, zeroI64);
423 Value printfDesc = printfBeginCall.getResult();
427 rewriter, loc, moduleOp, llvmI8,
"printfFormat_", adaptor.getFormat());
430 Value globalPtr = rewriter.
create<LLVM::AddressOfOp>(
433 global.getSymNameAttr());
435 rewriter.
create<LLVM::GEPOp>(loc, ptrType, global.getGlobalType(),
437 Value stringLen = rewriter.
create<LLVM::ConstantOp>(
438 loc, llvmI64, cast<StringAttr>(global.getValueAttr()).size());
440 Value oneI32 = rewriter.
create<LLVM::ConstantOp>(loc, llvmI32, 1);
441 Value zeroI32 = rewriter.
create<LLVM::ConstantOp>(loc, llvmI32, 0);
443 auto appendFormatCall = rewriter.
create<LLVM::CallOp>(
444 loc, ocklAppendStringN,
445 ValueRange{printfDesc, stringStart, stringLen,
446 adaptor.getArgs().empty() ? oneI32 : zeroI32});
447 printfDesc = appendFormatCall.
getResult();
450 constexpr
size_t argsPerAppend = 7;
451 size_t nArgs = adaptor.getArgs().size();
452 for (
size_t group = 0; group < nArgs; group += argsPerAppend) {
453 size_t bound =
std::min(group + argsPerAppend, nArgs);
454 size_t numArgsThisCall = bound - group;
457 arguments.push_back(printfDesc);
459 rewriter.
create<LLVM::ConstantOp>(loc, llvmI32, numArgsThisCall));
460 for (
size_t i = group; i < bound; ++i) {
461 Value arg = adaptor.getArgs()[i];
462 if (
auto floatType = dyn_cast<FloatType>(arg.
getType())) {
463 if (!floatType.isF64())
464 arg = rewriter.
create<LLVM::FPExtOp>(
466 arg = rewriter.
create<LLVM::BitcastOp>(loc, llvmI64, arg);
469 arg = rewriter.
create<LLVM::ZExtOp>(loc, llvmI64, arg);
471 arguments.push_back(arg);
474 for (
size_t extra = numArgsThisCall; extra < argsPerAppend; ++extra) {
475 arguments.push_back(zeroI64);
478 auto isLast = (bound == nArgs) ? oneI32 : zeroI32;
479 arguments.push_back(isLast);
480 auto call = rewriter.
create<LLVM::CallOp>(loc, ocklAppendArgs, arguments);
488 gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor,
490 Location loc = gpuPrintfOp->getLoc();
499 auto moduleOp = gpuPrintfOp->getParentOfType<gpu::GPUModuleOp>();
504 LLVM::LLVMFuncOp printfDecl =
509 rewriter, loc, moduleOp, llvmI8,
"printfFormat_", adaptor.getFormat(),
513 Value globalPtr = rewriter.
create<LLVM::AddressOfOp>(
516 global.getSymNameAttr());
518 rewriter.
create<LLVM::GEPOp>(loc, ptrType, global.getGlobalType(),
522 auto argsRange = adaptor.getArgs();
524 printfArgs.reserve(argsRange.size() + 1);
525 printfArgs.push_back(stringStart);
526 printfArgs.append(argsRange.begin(), argsRange.end());
528 rewriter.
create<LLVM::CallOp>(loc, printfDecl, printfArgs);
534 gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor,
536 Location loc = gpuPrintfOp->getLoc();
544 auto moduleOp = gpuPrintfOp->getParentOfType<gpu::GPUModuleOp>();
548 LLVM::LLVMFuncOp vprintfDecl =
553 rewriter, loc, moduleOp, llvmI8,
"printfFormat_", adaptor.getFormat());
556 Value globalPtr = rewriter.
create<LLVM::AddressOfOp>(loc, global);
558 rewriter.
create<LLVM::GEPOp>(loc, ptrType, global.getGlobalType(),
563 for (
Value arg : adaptor.getArgs()) {
564 Type type = arg.getType();
565 Value promotedArg = arg;
567 if (isa<FloatType>(type)) {
569 promotedArg = rewriter.
create<LLVM::FPExtOp>(loc, type, arg);
571 types.push_back(type);
572 args.push_back(promotedArg);
575 LLVM::LLVMStructType::getLiteral(gpuPrintfOp.getContext(), types);
579 rewriter.
create<LLVM::AllocaOp>(loc, ptrType, structType, one,
583 loc, ptrType, structType, tempAlloc,
585 rewriter.
create<LLVM::StoreOp>(loc, arg, ptr);
587 std::array<Value, 2> printfArgs = {stringStart, tempAlloc};
589 rewriter.
create<LLVM::CallOp>(loc, vprintfDecl, printfArgs);
602 VectorType vectorType = cast<VectorType>(llvm1DVectorTy);
604 Value result = rewriter.
create<LLVM::PoisonOp>(loc, vectorType);
607 Type elementType = vectorType.getElementType();
609 for (int64_t i = 0; i < vectorType.getNumElements(); ++i) {
610 Value index = rewriter.
create<LLVM::ConstantOp>(loc, indexType, i);
611 auto extractElement = [&](
Value operand) ->
Value {
612 if (!isa<VectorType>(operand.getType()))
614 return rewriter.
create<LLVM::ExtractElementOp>(loc, operand, index);
616 auto scalarOperands = llvm::map_to_vector(operands, extractElement);
618 rewriter.
create(loc, name, scalarOperands, elementType, op->
getAttrs());
619 result = rewriter.
create<LLVM::InsertElementOp>(
620 loc, result, scalarOp->
getResult(0), index);
630 if (llvm::any_of(operandTypes, llvm::IsaPred<VectorType>)) {
631 VectorType vectorType =
634 rewriter, converter));
638 if (llvm::any_of(operandTypes, llvm::IsaPred<LLVM::LLVMArrayType>)) {
640 op, operands, converter,
660 MemRefType memrefType,
unsigned alignmentBit) {
661 uint64_t alignmentByte = alignmentBit / memrefType.getElementTypeBitWidth();
663 FailureOr<unsigned> addressSpace =
665 if (failed(addressSpace)) {
666 op->emitError() <<
"conversion of memref memory space "
667 << memrefType.getMemorySpace()
668 <<
" to integer address space "
669 "failed. Consider adding memory space conversions.";
675 for (
auto globalOp : moduleOp.getBody()->getOps<LLVM::GlobalOp>()) {
676 existingGlobalNames.insert(globalOp.getSymName());
677 if (
auto arrayType = dyn_cast<LLVM::LLVMArrayType>(globalOp.getType())) {
678 if (globalOp.getAddrSpace() == addressSpace.value() &&
679 arrayType.getNumElements() == 0 &&
680 globalOp.getAlignment().value_or(0) == alignmentByte) {
687 unsigned uniquingCounter = 0;
690 [&](StringRef candidate) {
691 return existingGlobalNames.contains(candidate);
700 typeConverter->
convertType(memrefType.getElementType()), 0);
702 return rewriter.
create<LLVM::GlobalOp>(
703 op->getLoc(), zeroSizedArrayType,
false,
704 LLVM::Linkage::Internal, symName,
Attribute(), alignmentByte,
705 addressSpace.value());
709 gpu::DynamicSharedMemoryOp op,
OpAdaptor adaptor,
712 MemRefType memrefType = op.getResultMemref().getType();
716 MemRefLayoutAttrInterface layout = {};
718 MemRefType::get({0}, elementType, layout, memrefType.getMemorySpace());
722 auto moduleOp = op->getParentOfType<gpu::GPUModuleOp>();
729 auto basePtr = rewriter.
create<LLVM::AddressOfOp>(loc, shmemOp);
730 Type baseType = basePtr->getResultTypes().front();
734 Value shmemPtr = rewriter.
create<LLVM::GEPOp>(loc, baseType, elementType,
742 loc, memrefType0sz, shmemPtr, shmemPtr, shape, strides, rewriter);
745 rewriter.
replaceOp(op, {memRefDescriptor});
753 unsigned numArguments = op.getNumOperands();
757 if (useBarePtrCallConv) {
760 for (
auto it : llvm::zip(op->getOperands(), adaptor.getOperands())) {
761 Type oldTy = std::get<0>(it).getType();
762 Value newOperand = std::get<1>(it);
764 cast<BaseMemRefType>(oldTy))) {
767 }
else if (isa<UnrankedMemRefType>(oldTy)) {
772 updatedOperands.push_back(newOperand);
775 updatedOperands = llvm::to_vector<4>(adaptor.getOperands());
782 if (numArguments <= 1) {
784 op,
TypeRange(), updatedOperands, op->getAttrs());
791 op.getOperandTypes(), useBarePtrCallConv);
796 Value packed = rewriter.
create<LLVM::PoisonOp>(loc, packedType);
798 packed = rewriter.
create<LLVM::InsertValueOp>(loc, packed, operand, idx);
808 [mapping](
BaseMemRefType type, gpu::AddressSpaceAttr memorySpaceAttr) {
809 gpu::AddressSpace memorySpace = memorySpaceAttr.getValue();
810 unsigned addressSpace = mapping(memorySpace);
static IntegerAttr wrapNumericMemorySpace(MLIRContext *ctx, unsigned space)
static SmallString< 16 > getUniqueSymbolName(gpu::GPUModuleOp moduleOp, StringRef prefix)
static Value scalarizeVectorOpHelper(Operation *op, ValueRange operands, Type llvm1DVectorTy, ConversionPatternRewriter &rewriter, const LLVMTypeConverter &converter)
Helper for impl::scalarizeVectorOp.
LLVM::GlobalOp getDynamicSharedMemorySymbol(ConversionPatternRewriter &rewriter, gpu::GPUModuleOp moduleOp, gpu::DynamicSharedMemoryOp op, const LLVMTypeConverter *typeConverter, MemRefType memrefType, unsigned alignmentBit)
Generates a symbol with 0-sized array type for dynamic shared memory usage, or uses existing symbol.
static std::string diag(const llvm::Value &value)
static Value min(ImplicitLocOpBuilder &builder, Value value, Value bound)
Attributes are known-constant values of operations.
This class provides a shared interface for ranked and unranked memref types.
This class represents an argument of a Block.
IntegerAttr getIndexAttr(int64_t value)
IntegerAttr getI64IntegerAttr(int64_t value)
IntegerType getIntegerType(unsigned width)
Ty getType(Args &&...args)
Get or construct an instance of the type Ty with provided arguments.
StringAttr getStringAttr(const Twine &bytes)
MLIRContext * getContext() const
DictionaryAttr getDictionaryAttr(ArrayRef< NamedAttribute > value)
NamedAttribute getNamedAttr(StringRef name, Attribute val)
Attr getAttr(Args &&...args)
Get or construct an instance of the attribute Attr with provided arguments.
This class implements a pattern rewriter for use with ConversionPatterns.
void replaceOp(Operation *op, ValueRange newValues) override
Replace the given operation with the new values.
FailureOr< Block * > convertRegionTypes(Region *region, const TypeConverter &converter, TypeConverter::SignatureConversion *entryConversion=nullptr)
Apply a signature conversion to each block in the given region.
void eraseOp(Operation *op) override
PatternRewriter hook for erasing a dead operation.
const TypeConverter * typeConverter
An optional type converter for use by this pattern.
MemRefDescriptor createMemRefDescriptor(Location loc, MemRefType memRefType, Value allocatedPtr, Value alignedPtr, ArrayRef< Value > sizes, ArrayRef< Value > strides, ConversionPatternRewriter &rewriter) const
Creates and populates a canonical memref descriptor struct.
void getMemRefDescriptorSizes(Location loc, MemRefType memRefType, ValueRange dynamicSizes, ConversionPatternRewriter &rewriter, SmallVectorImpl< Value > &sizes, SmallVectorImpl< Value > &strides, Value &size, bool sizeInBytes=true) const
Computes sizes, strides and buffer size of memRefType with identity layout.
const LLVMTypeConverter * getTypeConverter() const
LLVM::LLVMDialect & getDialect() const
Returns the LLVM dialect.
LogicalResult copyUnrankedDescriptors(OpBuilder &builder, Location loc, TypeRange origTypes, SmallVectorImpl< Value > &operands, bool toDynamic) const
Copies the memory descriptor for any operands that were unranked descriptors originally to heap-alloc...
This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine.
Conversion from types to the LLVM IR dialect.
Type packFunctionResults(TypeRange types, bool useBarePointerCallConv=false) const
Convert a non-empty list of types to be returned from a function into an LLVM-compatible type.
const LowerToLLVMOptions & getOptions() const
Type convertFunctionSignature(FunctionType funcTy, bool isVariadic, bool useBarePtrCallConv, SignatureConversion &result) const
Convert a function type.
LogicalResult convertType(Type t, SmallVectorImpl< Type > &results) const
Convert the given type.
FailureOr< unsigned > getMemRefAddressSpace(BaseMemRefType type) const
Return the LLVM address space corresponding to the memory space of the memref type type or failure if...
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
Helper class to produce LLVM dialect operations extracting or inserting elements of a MemRef descript...
static MemRefDescriptor fromStaticShape(OpBuilder &builder, Location loc, const LLVMTypeConverter &typeConverter, MemRefType type, Value memory)
Builds IR creating a MemRef descriptor that represents type and populates it with static shape and st...
Value allocatedPtr(OpBuilder &builder, Location loc)
Builds IR extracting the allocated pointer from the descriptor.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
Attribute erase(StringAttr name)
Erase the attribute with the given name from the list.
RAII guard to reset the insertion point of the builder when destroyed.
This class helps build Operations.
void setInsertionPointToStart(Block *block)
Sets the insertion point to the start of the specified block.
void setInsertionPoint(Block *block, Block::iterator insertPoint)
Set the insertion point to the specified location.
Operation * create(const OperationState &state)
Creates an operation given the fields represented as an OperationState.
StringAttr getIdentifier() const
Return the name of this operation as a StringAttr.
Operation is the basic unit of execution within MLIR.
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
Location getLoc()
The source location the operation was defined or derived from.
ArrayRef< NamedAttribute > getAttrs()
Return all of the attributes on this operation.
OperationName getName()
The name of an operation is the key identifier for it.
result_type_range getResultTypes()
std::enable_if_t<!std::is_convertible< CallbackT, Twine >::value, LogicalResult > notifyMatchFailure(Location loc, CallbackT &&reasonCallback)
Used to notify the listener that the IR failed to be rewritten because of a match failure,...
void modifyOpInPlace(Operation *root, CallableT &&callable)
This method is a utility wrapper around an in-place modification of an operation.
void inlineRegionBefore(Region ®ion, Region &parent, Region::iterator before)
Move the blocks that belong to "region" before the given position in another region "parent".
OpTy replaceOpWithNewOp(Operation *op, Args &&...args)
Replace the results of the given (original) op with a new op that is created without verification (re...
static StringRef getSymbolAttrName()
Return the name of the attribute used for symbol names.
This class provides all of the information necessary to convert a type signature.
std::optional< InputMapping > getInputMapping(unsigned input) const
Get the input mapping for the given argument.
void remapInput(unsigned origInputNo, ArrayRef< Value > replacements)
Remap an input of the original signature to replacements values.
LogicalResult convertType(Type t, SmallVectorImpl< Type > &results) const
Convert the given type.
void addTypeAttributeConversion(FnT &&callback)
Register a conversion function for attributes within types.
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
bool isIntOrFloat() const
Return true if this is an integer (of any signedness) or a float type.
unsigned getIntOrFloatBitWidth() const
Return the bit width of an integer or a float type, assert failure on other types.
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Type getType() const
Return the type of this value.
LogicalResult handleMultidimensionalVectors(Operation *op, ValueRange operands, const LLVMTypeConverter &typeConverter, std::function< Value(Type, ValueRange)> createOperand, ConversionPatternRewriter &rewriter)
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
LogicalResult scalarizeVectorOp(Operation *op, ValueRange operands, ConversionPatternRewriter &rewriter, const LLVMTypeConverter &converter)
Unrolls op to array/vector elements.
Include the generated interface declarations.
InFlightDiagnostic emitWarning(Location loc)
Utility method to emit a warning message using this location.
std::function< unsigned(gpu::AddressSpace)> MemorySpaceMapping
A function that maps a MemorySpace enum to a target-specific integer value.
void populateGpuMemorySpaceAttributeConversions(TypeConverter &typeConverter, const MemorySpaceMapping &mapping)
Populates memory space attribute conversion rules for lowering gpu.address_space to integer values.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LLVM::LLVMFuncOp getOrDefineFunction(gpu::GPUModuleOp moduleOp, Location loc, OpBuilder &b, StringRef name, LLVM::LLVMFunctionType type)
Find or create an external function declaration in the given module.
LLVM::GlobalOp getOrCreateStringConstant(OpBuilder &b, Location loc, gpu::GPUModuleOp moduleOp, Type llvmI8, StringRef namePrefix, StringRef str, uint64_t alignment=0, unsigned addrSpace=0)
Create a global that contains the given string.
LogicalResult matchAndRewrite(gpu::DynamicSharedMemoryOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
Methods that operate on the SourceOp type.
LogicalResult matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
Methods that operate on the SourceOp type.
LogicalResult matchAndRewrite(gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
LogicalResult matchAndRewrite(gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
LogicalResult matchAndRewrite(gpu::PrintfOp gpuPrintfOp, gpu::PrintfOpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
LogicalResult matchAndRewrite(gpu::ReturnOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override
Methods that operate on the SourceOp type.