| 1 | //===- ModuleTranslation.h - MLIR to LLVM conversion ------------*- C++ -*-===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file implements the translation between an MLIR LLVM dialect module and |
| 10 | // the corresponding LLVMIR module. It only handles core LLVM IR operations. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #ifndef MLIR_TARGET_LLVMIR_MODULETRANSLATION_H |
| 15 | #define MLIR_TARGET_LLVMIR_MODULETRANSLATION_H |
| 16 | |
| 17 | #include "mlir/Dialect/LLVMIR/LLVMAttrs.h" |
| 18 | #include "mlir/Dialect/LLVMIR/LLVMConstantOps.h" |
| 19 | #include "mlir/Dialect/LLVMIR/LLVMInterfaces.h" |
| 20 | #include "mlir/Dialect/LLVMIR/LLVMModuleOps.h" |
| 21 | #include "mlir/IR/Operation.h" |
| 22 | #include "mlir/IR/SymbolTable.h" |
| 23 | #include "mlir/IR/Value.h" |
| 24 | #include "mlir/Interfaces/ControlFlowInterfaces.h" |
| 25 | #include "mlir/Support/LLVM.h" |
| 26 | #include "mlir/Support/StateStack.h" |
| 27 | #include "mlir/Support/TypeID.h" |
| 28 | #include "mlir/Target/LLVMIR/Export.h" |
| 29 | #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h" |
| 30 | #include "mlir/Target/LLVMIR/TypeToLLVM.h" |
| 31 | |
| 32 | #include "llvm/ADT/MapVector.h" |
| 33 | #include "llvm/ADT/SetVector.h" |
| 34 | #include "llvm/IR/FPEnv.h" |
| 35 | #include "llvm/IR/Module.h" |
| 36 | #include "llvm/Support/VirtualFileSystemFwd.h" |
| 37 | |
| 38 | namespace llvm { |
| 39 | class BasicBlock; |
| 40 | class CallBase; |
| 41 | class Function; |
| 42 | class IRBuilderBase; |
| 43 | class Metadata; |
| 44 | class Value; |
| 45 | } // namespace llvm |
| 46 | |
| 47 | namespace mlir { |
| 48 | class Attribute; |
| 49 | class Block; |
| 50 | class Location; |
| 51 | |
| 52 | namespace LLVM { |
| 53 | |
| 54 | namespace detail { |
| 55 | class DebugTranslation; |
| 56 | class LoopAnnotationTranslation; |
| 57 | } // namespace detail |
| 58 | |
| 59 | class AliasScopeAttr; |
| 60 | class AliasScopeDomainAttr; |
| 61 | class DINodeAttr; |
| 62 | class LLVMFuncOp; |
| 63 | class ComdatSelectorOp; |
| 64 | |
| 65 | /// Implementation class for module translation. Holds a reference to the module |
| 66 | /// being translated, and the mappings between the original and the translated |
| 67 | /// functions, basic blocks and values. It is practically easier to hold these |
| 68 | /// mappings in one class since the conversion of control flow operations |
| 69 | /// needs to look up block and function mappings. |
| 70 | class ModuleTranslation { |
| 71 | friend std::unique_ptr<llvm::Module> |
| 72 | mlir::translateModuleToLLVMIR(Operation *, llvm::LLVMContext &, StringRef, |
| 73 | bool, llvm::vfs::FileSystem *); |
| 74 | |
| 75 | public: |
| 76 | /// Stores the mapping between a function name and its LLVM IR representation. |
| 77 | void mapFunction(StringRef name, llvm::Function *func) { |
| 78 | auto result = functionMapping.try_emplace(Key: name, Args&: func); |
| 79 | (void)result; |
| 80 | assert(result.second && |
| 81 | "attempting to map a function that is already mapped" ); |
| 82 | } |
| 83 | |
| 84 | /// Finds an LLVM IR function by its name. |
| 85 | llvm::Function *lookupFunction(StringRef name) const { |
| 86 | return functionMapping.lookup(Key: name); |
| 87 | } |
| 88 | |
| 89 | /// Stores the mapping between an MLIR value and its LLVM IR counterpart. |
| 90 | void mapValue(Value mlir, llvm::Value *llvm) { mapValue(value: mlir) = llvm; } |
| 91 | |
| 92 | /// Provides write-once access to store the LLVM IR value corresponding to the |
| 93 | /// given MLIR value. |
| 94 | llvm::Value *&mapValue(Value value) { |
| 95 | llvm::Value *&llvm = valueMapping[value]; |
| 96 | assert(llvm == nullptr && |
| 97 | "attempting to map a value that is already mapped" ); |
| 98 | return llvm; |
| 99 | } |
| 100 | |
| 101 | /// Finds an LLVM IR value corresponding to the given MLIR value. |
| 102 | llvm::Value *lookupValue(Value value) const { |
| 103 | return valueMapping.lookup(Val: value); |
| 104 | } |
| 105 | |
| 106 | /// Remap old value with new value in the MLIR-to-LLVM value map so later |
| 107 | /// translations use the replacement. Existing LLVM instructions are not |
| 108 | /// rewritten. |
| 109 | void remapAllValuesWith(llvm::Value *oldValue, llvm::Value *newValue); |
| 110 | |
| 111 | /// Looks up remapped a list of remapped values. |
| 112 | SmallVector<llvm::Value *> lookupValues(ValueRange values); |
| 113 | |
| 114 | /// Stores the mapping between an MLIR block and LLVM IR basic block. |
| 115 | void mapBlock(Block *mlir, llvm::BasicBlock *llvm) { |
| 116 | auto result = blockMapping.try_emplace(Key: mlir, Args&: llvm); |
| 117 | (void)result; |
| 118 | assert(result.second && "attempting to map a block that is already mapped" ); |
| 119 | } |
| 120 | |
| 121 | /// Finds an LLVM IR basic block that corresponds to the given MLIR block. |
| 122 | llvm::BasicBlock *lookupBlock(Block *block) const { |
| 123 | return blockMapping.lookup(Val: block); |
| 124 | } |
| 125 | |
| 126 | /// Stores the mapping between an MLIR operation with successors and a |
| 127 | /// corresponding LLVM IR instruction. |
| 128 | void mapBranch(Operation *mlir, llvm::Instruction *llvm) { |
| 129 | auto result = branchMapping.try_emplace(Key: mlir, Args&: llvm); |
| 130 | (void)result; |
| 131 | assert(result.second && |
| 132 | "attempting to map a branch that is already mapped" ); |
| 133 | } |
| 134 | |
| 135 | /// Finds an LLVM IR instruction that corresponds to the given MLIR operation |
| 136 | /// with successors. |
| 137 | llvm::Instruction *lookupBranch(Operation *op) const { |
| 138 | return branchMapping.lookup(Val: op); |
| 139 | } |
| 140 | |
| 141 | /// Stores a mapping between an MLIR call operation and a corresponding LLVM |
| 142 | /// call instruction. |
| 143 | void mapCall(Operation *mlir, llvm::CallInst *llvm) { |
| 144 | auto result = callMapping.try_emplace(Key: mlir, Args&: llvm); |
| 145 | (void)result; |
| 146 | assert(result.second && "attempting to map a call that is already mapped" ); |
| 147 | } |
| 148 | |
| 149 | /// Finds an LLVM call instruction that corresponds to the given MLIR call |
| 150 | /// operation. |
| 151 | llvm::CallInst *lookupCall(Operation *op) const { |
| 152 | return callMapping.lookup(Val: op); |
| 153 | } |
| 154 | |
| 155 | /// Maps a blockaddress operation to its corresponding placeholder LLVM |
| 156 | /// value. |
| 157 | void mapUnresolvedBlockAddress(BlockAddressOp op, llvm::Value *cst) { |
| 158 | auto result = unresolvedBlockAddressMapping.try_emplace(Key: op, Args&: cst); |
| 159 | (void)result; |
| 160 | assert(result.second && |
| 161 | "attempting to map a blockaddress operation that is already mapped" ); |
| 162 | } |
| 163 | |
| 164 | /// Maps a BlockAddressAttr to its corresponding LLVM basic block. |
| 165 | void mapBlockAddress(BlockAddressAttr attr, llvm::BasicBlock *block) { |
| 166 | auto result = blockAddressToLLVMMapping.try_emplace(Key: attr, Args&: block); |
| 167 | (void)result; |
| 168 | assert(result.second && |
| 169 | "attempting to map a blockaddress attribute that is already mapped" ); |
| 170 | } |
| 171 | |
| 172 | /// Finds the LLVM basic block that corresponds to the given BlockAddressAttr. |
| 173 | llvm::BasicBlock *lookupBlockAddress(BlockAddressAttr attr) const { |
| 174 | return blockAddressToLLVMMapping.lookup(Val: attr); |
| 175 | } |
| 176 | |
| 177 | /// Removes the mapping for blocks contained in the region and values defined |
| 178 | /// in these blocks. |
| 179 | void forgetMapping(Region ®ion); |
| 180 | |
| 181 | /// Removes the mapping for the given value. |
| 182 | void forgetMapping(Value value) { valueMapping.erase(Val: value); } |
| 183 | |
| 184 | /// Returns the LLVM metadata corresponding to a mlir LLVM dialect alias scope |
| 185 | /// attribute. Creates the metadata node if it has not been converted before. |
| 186 | llvm::MDNode *getOrCreateAliasScope(AliasScopeAttr aliasScopeAttr); |
| 187 | |
| 188 | /// Returns the LLVM metadata corresponding to an array of mlir LLVM dialect |
| 189 | /// alias scope attributes. Creates the metadata nodes if they have not been |
| 190 | /// converted before. |
| 191 | llvm::MDNode * |
| 192 | getOrCreateAliasScopes(ArrayRef<AliasScopeAttr> aliasScopeAttrs); |
| 193 | |
| 194 | // Sets LLVM metadata for memory operations that are in a parallel loop. |
| 195 | void setAccessGroupsMetadata(AccessGroupOpInterface op, |
| 196 | llvm::Instruction *inst); |
| 197 | |
| 198 | // Sets LLVM metadata for memory operations that have alias scope information. |
| 199 | void setAliasScopeMetadata(AliasAnalysisOpInterface op, |
| 200 | llvm::Instruction *inst); |
| 201 | |
| 202 | /// Sets LLVM TBAA metadata for memory operations that have TBAA attributes. |
| 203 | void setTBAAMetadata(AliasAnalysisOpInterface op, llvm::Instruction *inst); |
| 204 | |
| 205 | /// Sets LLVM tbaa.struct metadata on an aggregate copy, describing which |
| 206 | /// fields of the aggregate the copy touches. |
| 207 | void setTBAAStructMetadata(ArrayAttr fields, llvm::Instruction *inst); |
| 208 | |
| 209 | /// Sets LLVM dereferenceable metadata for operations that have |
| 210 | /// dereferenceable attributes. |
| 211 | void setDereferenceableMetadata(DereferenceableOpInterface op, |
| 212 | llvm::Instruction *inst); |
| 213 | |
| 214 | /// Sets LLVM profiling metadata for operations that have branch weights. |
| 215 | void setBranchWeightsMetadata(WeightedBranchOpInterface op); |
| 216 | |
| 217 | /// Sets LLVM loop metadata for branch operations that have a loop annotation |
| 218 | /// attribute. |
| 219 | void setLoopMetadata(Operation *op, llvm::Instruction *inst); |
| 220 | |
| 221 | /// Sets the disjoint flag attribute for the exported instruction `value` |
| 222 | /// given the original operation `op`. Asserts if the operation does |
| 223 | /// not implement the disjoint flag interface, and asserts if the value |
| 224 | /// is an instruction that implements the disjoint flag. |
| 225 | void setDisjointFlag(Operation *op, llvm::Value *value); |
| 226 | |
| 227 | /// Converts the type from MLIR LLVM dialect to LLVM. |
| 228 | llvm::Type *convertType(Type type); |
| 229 | |
| 230 | /// Returns the MLIR context of the module being translated. |
| 231 | MLIRContext &getContext() { return *mlirModule->getContext(); } |
| 232 | |
| 233 | /// Returns the LLVM context in which the IR is being constructed. |
| 234 | llvm::LLVMContext &getLLVMContext() const { return llvmModule->getContext(); } |
| 235 | |
| 236 | /// Finds an LLVM IR global value that corresponds to the given MLIR operation |
| 237 | /// defining a global value. |
| 238 | llvm::GlobalValue *lookupGlobal(Operation *op) { |
| 239 | return globalsMapping.lookup(Val: op); |
| 240 | } |
| 241 | |
| 242 | /// Finds an LLVM IR global value by the mlir.global symbol name. |
| 243 | llvm::GlobalValue *lookupGlobal(StringRef name) const { |
| 244 | return globalsByNameMapping.lookup(Key: name); |
| 245 | } |
| 246 | |
| 247 | /// Finds an LLVM IR global value that corresponds to the given MLIR operation |
| 248 | /// defining a global alias value. |
| 249 | llvm::GlobalValue *lookupAlias(Operation *op) { |
| 250 | return aliasesMapping.lookup(Val: op); |
| 251 | } |
| 252 | |
| 253 | /// Finds an LLVM IR global value that corresponds to the given MLIR operation |
| 254 | /// defining an IFunc. |
| 255 | llvm::GlobalValue *lookupIFunc(Operation *op) { |
| 256 | return ifuncMapping.lookup(Val: op); |
| 257 | } |
| 258 | |
| 259 | /// Returns the virtual filesystem to use for file operations. Falls back to |
| 260 | /// the real filesystem if none was provided. |
| 261 | llvm::vfs::FileSystem &getFileSystem(); |
| 262 | |
| 263 | /// Returns the LLVM module in which the IR is being constructed. |
| 264 | llvm::Module *getLLVMModule() { return llvmModule.get(); } |
| 265 | |
| 266 | /// Translates the given location. |
| 267 | llvm::DILocation *translateLoc(Location loc, llvm::DILocalScope *scope); |
| 268 | |
| 269 | /// Translates the given LLVM DWARF expression metadata. |
| 270 | llvm::DIExpression *translateExpression(LLVM::DIExpressionAttr attr); |
| 271 | |
| 272 | /// Translates the given LLVM global variable expression metadata. |
| 273 | llvm::DIGlobalVariableExpression * |
| 274 | translateGlobalVariableExpression(LLVM::DIGlobalVariableExpressionAttr attr); |
| 275 | |
| 276 | /// Translates the given LLVM debug info metadata. |
| 277 | llvm::Metadata *translateDebugInfo(LLVM::DINodeAttr attr); |
| 278 | |
| 279 | /// Translates the given LLVM rounding mode metadata. |
| 280 | llvm::RoundingMode translateRoundingMode(LLVM::RoundingMode rounding); |
| 281 | |
| 282 | /// Translates the given LLVM FP exception behavior metadata. |
| 283 | llvm::fp::ExceptionBehavior |
| 284 | translateFPExceptionBehavior(LLVM::FPExceptionBehavior exceptionBehavior); |
| 285 | |
| 286 | /// Translates the contents of the given block to LLVM IR using this |
| 287 | /// translator. The LLVM IR basic block corresponding to the given block is |
| 288 | /// expected to exist in the mapping of this translator. Uses `builder` to |
| 289 | /// translate the IR, leaving it at the end of the block. If `ignoreArguments` |
| 290 | /// is set, does not produce PHI nodes for the block arguments. Otherwise, the |
| 291 | /// PHI nodes are constructed for block arguments but are _not_ connected to |
| 292 | /// the predecessors that may not exist yet. |
| 293 | LogicalResult convertBlock(Block &bb, bool ignoreArguments, |
| 294 | llvm::IRBuilderBase &builder) { |
| 295 | return convertBlockImpl(bb, ignoreArguments, builder, |
| 296 | /*recordInsertions=*/recordInsertions: false); |
| 297 | } |
| 298 | |
| 299 | /// Converts the given MLIR operation into LLVM IR using this translator. It |
| 300 | /// is up to the caller to ensure that all operands have been mapped before |
| 301 | /// calling this function. |
| 302 | LogicalResult convertOperation(Operation &op, llvm::IRBuilderBase &builder) { |
| 303 | return convertOperationImpl(op, builder, /*recordInsertions=*/recordInsertions: false); |
| 304 | } |
| 305 | |
| 306 | /// Converts argument and result attributes from `attrsOp` to LLVM IR |
| 307 | /// attributes on the `call` instruction. Returns failure if conversion fails. |
| 308 | /// The `immArgPositions` parameter is only relevant for intrinsics. It |
| 309 | /// specifies the positions of immediate arguments, which do not have |
| 310 | /// associated argument attributes in MLIR and should be skipped during |
| 311 | /// attribute mapping. |
| 312 | LogicalResult |
| 313 | convertArgAndResultAttrs(ArgAndResultAttrsOpInterface attrsOp, |
| 314 | llvm::CallBase *call, |
| 315 | ArrayRef<unsigned> immArgPositions = {}); |
| 316 | |
| 317 | /// Gets the named metadata in the LLVM IR module being constructed, creating |
| 318 | /// it if it does not exist. |
| 319 | llvm::NamedMDNode *getOrInsertNamedModuleMetadata(StringRef name); |
| 320 | |
| 321 | /// Converts an LLVM dialect metadata attribute to LLVM IR metadata. |
| 322 | /// Returns failure and emits a diagnostic using `emitError` if the attribute |
| 323 | /// cannot be converted. |
| 324 | FailureOr<llvm::Metadata *> |
| 325 | convertMetadataAttr(Attribute attr, |
| 326 | function_ref<InFlightDiagnostic()> emitError); |
| 327 | |
| 328 | /// Creates a stack frame of type `T` on ModuleTranslation stack. `T` must |
| 329 | /// be derived from `StackFrameBase<T>` and constructible from the provided |
| 330 | /// arguments. Doing this before entering the region of the op being |
| 331 | /// translated makes the frame available when translating ops within that |
| 332 | /// region. |
| 333 | template <typename T, typename... Args> |
| 334 | void stackPush(Args &&...args) { |
| 335 | stack.stackPush<T>(std::forward<Args>(args)...); |
| 336 | } |
| 337 | |
| 338 | /// Pops the last element from the ModuleTranslation stack. |
| 339 | void stackPop() { stack.stackPop(); } |
| 340 | |
| 341 | /// Calls `callback` for every ModuleTranslation stack frame of type `T` |
| 342 | /// starting from the top of the stack. |
| 343 | template <typename T> |
| 344 | WalkResult stackWalk(llvm::function_ref<WalkResult(T &)> callback) { |
| 345 | return stack.stackWalk(callback); |
| 346 | } |
| 347 | |
| 348 | /// RAII object calling stackPush/stackPop on construction/destruction. |
| 349 | template <typename T> |
| 350 | using SaveStack = SaveStateStack<T, ModuleTranslation>; |
| 351 | |
| 352 | /// Base class for state that lives as long as the module translation. |
| 353 | /// Dialect translations use extensions to keep state shared across the |
| 354 | /// translation of several operations (e.g. IR builders or handle mappings) |
| 355 | /// without the core translation depending on those dialects. Derived classes |
| 356 | /// must provide an explicit TypeID. |
| 357 | class Extension { |
| 358 | public: |
| 359 | virtual ~Extension(); |
| 360 | |
| 361 | /// Called once after all operations have been translated and before the |
| 362 | /// LLVM module is verified. Extensions are finalized in creation order. |
| 363 | virtual LogicalResult finalize() { return success(); } |
| 364 | }; |
| 365 | |
| 366 | /// Returns the extension of type `T`, constructing it from `args` on first |
| 367 | /// use. `T` must derive from `Extension`. |
| 368 | template <typename T, typename... Args> |
| 369 | T &getOrCreateExtension(Args &&...args) { |
| 370 | static_assert(std::is_base_of<Extension, T>::value, |
| 371 | "expected T derived from ModuleTranslation::Extension" ); |
| 372 | TypeID id = TypeID::get<T>(); |
| 373 | auto it = extensions.find(Key: id); |
| 374 | if (it != extensions.end()) |
| 375 | return static_cast<T &>(*it->second); |
| 376 | // Construct before inserting: the constructor may create other extensions. |
| 377 | auto extension = std::make_unique<T>(std::forward<Args>(args)...); |
| 378 | T &result = *extension; |
| 379 | extensions.insert({id, std::move(extension)}); |
| 380 | return result; |
| 381 | } |
| 382 | |
| 383 | SymbolTableCollection &symbolTable() { return symbolTableCollection; } |
| 384 | |
| 385 | // A helper callback that takes an attribute, and if it is a StringAttr, |
| 386 | // properly converts it to the 'no-builtin-VALUE' form. |
| 387 | static std::optional<llvm::Attribute> convertNoBuiltin(llvm::LLVMContext &ctx, |
| 388 | mlir::Attribute a); |
| 389 | |
| 390 | static std::optional<llvm::Attribute> |
| 391 | convertDefaultFuncAttr(llvm::LLVMContext &ctx, |
| 392 | mlir::NamedAttribute namedAttr); |
| 393 | |
| 394 | /// A template that takes a collection-like attribute, and converts it via a |
| 395 | /// user provided callback, then adds each element as function attributes to |
| 396 | /// the provided operation. |
| 397 | template <typename AttrsTy, typename Operation, typename Converter> |
| 398 | void convertFunctionAttrCollection(AttrsTy attrs, Operation *op, |
| 399 | const Converter &conv) { |
| 400 | if (!attrs) |
| 401 | return; |
| 402 | for (auto elt : attrs) { |
| 403 | std::optional<llvm::Attribute> result = conv(getLLVMContext(), elt); |
| 404 | if (result) |
| 405 | op->addFnAttr(*result); |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | llvm::Attribute convertAllocsizeAttr(DenseI32ArrayAttr allocsizeAttr); |
| 410 | |
| 411 | private: |
| 412 | ModuleTranslation(Operation *module, std::unique_ptr<llvm::Module> llvmModule, |
| 413 | llvm::vfs::FileSystem *fs = nullptr); |
| 414 | ~ModuleTranslation(); |
| 415 | |
| 416 | /// Converts individual components. |
| 417 | LogicalResult convertOperationImpl(Operation &op, |
| 418 | llvm::IRBuilderBase &builder, |
| 419 | bool recordInsertions = false); |
| 420 | LogicalResult convertFunctionSignatures(); |
| 421 | LogicalResult convertFunctionMetadata(); |
| 422 | LogicalResult convertFunctions(); |
| 423 | LogicalResult convertIFuncs(); |
| 424 | LogicalResult convertComdats(); |
| 425 | |
| 426 | LogicalResult convertUnresolvedBlockAddress(); |
| 427 | |
| 428 | /// Handle conversion for both globals and global aliases. |
| 429 | /// |
| 430 | /// - Create named global variables that correspond to llvm.mlir.global |
| 431 | /// definitions, similarly Convert llvm.global_ctors and global_dtors ops. |
| 432 | /// - Create global alias that correspond to llvm.mlir.alias. |
| 433 | /// Global metadata that can reference other global objects (including |
| 434 | /// ifuncs) is converted later by `convertGlobalMetadata`. |
| 435 | LogicalResult convertGlobalsAndAliases(); |
| 436 | |
| 437 | /// Attach metadata on LLVM globals after all global objects exist so that |
| 438 | /// symbol references (globals, aliases, functions, and ifuncs) can be |
| 439 | /// resolved. |
| 440 | LogicalResult convertGlobalMetadata(); |
| 441 | /// Converts a symbol ref to LLVM IR metadata, or fails if unresolved. |
| 442 | FailureOr<llvm::Metadata *> |
| 443 | convertSymbolRefToMetadata(FlatSymbolRefAttr name, |
| 444 | function_ref<InFlightDiagnostic()> emitError); |
| 445 | LogicalResult convertOneFunction(LLVMFuncOp func); |
| 446 | LogicalResult convertBlockImpl(Block &bb, bool ignoreArguments, |
| 447 | llvm::IRBuilderBase &builder, |
| 448 | bool recordInsertions); |
| 449 | |
| 450 | /// Returns the LLVM metadata corresponding to the given mlir LLVM dialect |
| 451 | /// TBAATagAttr. |
| 452 | llvm::MDNode *getTBAANode(TBAATagAttr tbaaAttr) const; |
| 453 | |
| 454 | /// Process tbaa LLVM Metadata operations and create LLVM |
| 455 | /// metadata nodes for them. |
| 456 | LogicalResult createTBAAMetadata(); |
| 457 | |
| 458 | /// Process the ident LLVM Metadata, if it exists. |
| 459 | LogicalResult createIdentMetadata(); |
| 460 | |
| 461 | /// Process the llvm.commandline LLVM Metadata, if it exists. |
| 462 | LogicalResult createCommandlineMetadata(); |
| 463 | |
| 464 | /// Process the llvm.dependent_libraries LLVM Metadata, if it exists. |
| 465 | LogicalResult createDependentLibrariesMetadata(); |
| 466 | |
| 467 | /// Translates dialect attributes attached to the given operation. |
| 468 | LogicalResult |
| 469 | convertDialectAttributes(Operation *op, |
| 470 | ArrayRef<llvm::Instruction *> instructions); |
| 471 | |
| 472 | /// Translates parameter attributes of a call and adds them to the returned |
| 473 | /// AttrBuilder. Returns failure if any of the translations failed. |
| 474 | FailureOr<llvm::AttrBuilder> convertParameterAttrs(mlir::Location loc, |
| 475 | DictionaryAttr paramAttrs); |
| 476 | |
| 477 | /// Translates parameter attributes of a function and adds them to the |
| 478 | /// returned AttrBuilder. Returns failure if any of the translations failed. |
| 479 | FailureOr<llvm::AttrBuilder> |
| 480 | convertParameterAttrs(LLVMFuncOp func, int argIdx, DictionaryAttr paramAttrs); |
| 481 | |
| 482 | /// Original and translated module. |
| 483 | Operation *mlirModule; |
| 484 | std::unique_ptr<llvm::Module> llvmModule; |
| 485 | /// A converter for translating debug information. |
| 486 | std::unique_ptr<detail::DebugTranslation> debugTranslation; |
| 487 | |
| 488 | /// A converter for translating loop annotations. |
| 489 | std::unique_ptr<detail::LoopAnnotationTranslation> loopAnnotationTranslation; |
| 490 | |
| 491 | /// Translation-scoped state owned by dialect translations. |
| 492 | llvm::MapVector<TypeID, std::unique_ptr<Extension>> extensions; |
| 493 | |
| 494 | /// Optional virtual filesystem for file operations. When null, the real |
| 495 | /// filesystem is used (via getFileSystem()). Not owned. |
| 496 | llvm::vfs::FileSystem *fileSystem = nullptr; |
| 497 | |
| 498 | /// Mappings between llvm.mlir.global definitions and corresponding globals. |
| 499 | DenseMap<Operation *, llvm::GlobalValue *> globalsMapping; |
| 500 | |
| 501 | /// Name-keyed mirror of `globalsMapping`, populated alongside it during |
| 502 | /// `convertGlobalsAndAliases`. Lets `getLLVMConstant` resolve |
| 503 | /// `FlatSymbolRefAttr` leaves of aggregate constants that name a global |
| 504 | /// (mirroring how `functionMapping` resolves function names). |
| 505 | llvm::StringMap<llvm::GlobalValue *> globalsByNameMapping; |
| 506 | |
| 507 | /// Mappings between llvm.mlir.alias definitions and corresponding global |
| 508 | /// aliases. |
| 509 | DenseMap<Operation *, llvm::GlobalValue *> aliasesMapping; |
| 510 | |
| 511 | /// Mappings between llvm.mlir.ifunc definitions and corresponding global |
| 512 | /// ifuncs. |
| 513 | DenseMap<Operation *, llvm::GlobalValue *> ifuncMapping; |
| 514 | |
| 515 | /// A stateful object used to translate types. |
| 516 | TypeToLLVMIRTranslator typeTranslator; |
| 517 | |
| 518 | /// A dialect interface collection used for dispatching the translation to |
| 519 | /// specific dialects. |
| 520 | LLVMTranslationInterface iface; |
| 521 | |
| 522 | /// Mappings between original and translated values, used for lookups. |
| 523 | llvm::StringMap<llvm::Function *> functionMapping; |
| 524 | DenseMap<Value, llvm::Value *> valueMapping; |
| 525 | DenseMap<Block *, llvm::BasicBlock *> blockMapping; |
| 526 | |
| 527 | /// A mapping between MLIR LLVM dialect terminators and LLVM IR terminators |
| 528 | /// they are converted to. This allows for connecting PHI nodes to the source |
| 529 | /// values after all operations are converted. |
| 530 | DenseMap<Operation *, llvm::Instruction *> branchMapping; |
| 531 | |
| 532 | /// A mapping between MLIR LLVM dialect call operations and LLVM IR call |
| 533 | /// instructions. This allows for adding branch weights after the operations |
| 534 | /// have been converted. |
| 535 | DenseMap<Operation *, llvm::CallInst *> callMapping; |
| 536 | |
| 537 | /// Mapping from an alias scope attribute to its LLVM metadata. |
| 538 | /// This map is populated lazily. |
| 539 | DenseMap<AliasScopeAttr, llvm::MDNode *> aliasScopeMetadataMapping; |
| 540 | |
| 541 | /// Mapping from an alias scope domain attribute to its LLVM metadata. |
| 542 | /// This map is populated lazily. |
| 543 | DenseMap<AliasScopeDomainAttr, llvm::MDNode *> aliasDomainMetadataMapping; |
| 544 | |
| 545 | /// Mapping from a tbaa attribute to its LLVM metadata. |
| 546 | /// This map is populated on module entry. |
| 547 | DenseMap<Attribute, llvm::MDNode *> tbaaMetadataMapping; |
| 548 | |
| 549 | /// Mapping from a comdat selector operation to its LLVM comdat struct. |
| 550 | /// This map is populated on module entry. |
| 551 | DenseMap<ComdatSelectorOp, llvm::Comdat *> comdatMapping; |
| 552 | |
| 553 | /// Mapping from llvm.blockaddress operations to their corresponding LLVM |
| 554 | /// constant placeholders. After all basic blocks are translated, this |
| 555 | /// mapping is used to replace the placeholders with the LLVM block addresses. |
| 556 | DenseMap<BlockAddressOp, llvm::Value *> unresolvedBlockAddressMapping; |
| 557 | |
| 558 | /// Mapping from a BlockAddressAttr attribute to it's matching LLVM basic |
| 559 | /// block. |
| 560 | DenseMap<BlockAddressAttr, llvm::BasicBlock *> blockAddressToLLVMMapping; |
| 561 | |
| 562 | /// Stack of user-specified state elements, useful when translating operations |
| 563 | /// with regions. |
| 564 | StateStack stack; |
| 565 | |
| 566 | /// A cache for the symbol tables constructed during symbols lookup. |
| 567 | SymbolTableCollection symbolTableCollection; |
| 568 | }; |
| 569 | |
| 570 | namespace detail { |
| 571 | /// For all blocks in the region that were converted to LLVM IR using the given |
| 572 | /// ModuleTranslation, connect the PHI nodes of the corresponding LLVM IR blocks |
| 573 | /// to the results of preceding blocks. |
| 574 | void connectPHINodes(Region ®ion, const ModuleTranslation &state); |
| 575 | |
| 576 | /// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`. |
| 577 | /// This currently supports integer, floating point, splat and dense element |
| 578 | /// attributes and combinations thereof. Also, an array attribute with two |
| 579 | /// elements is supported to represent a complex constant. In case of error, |
| 580 | /// report it to `loc` and return nullptr. |
| 581 | llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr, |
| 582 | Location loc, |
| 583 | const ModuleTranslation &moduleTranslation); |
| 584 | |
| 585 | /// Creates a call to an LLVM IR intrinsic function with the given arguments. |
| 586 | llvm::CallInst *createIntrinsicCall(llvm::IRBuilderBase &builder, |
| 587 | llvm::Intrinsic::ID intrinsic, |
| 588 | ArrayRef<llvm::Value *> args = {}, |
| 589 | ArrayRef<llvm::Type *> tys = {}); |
| 590 | |
| 591 | /// Creates a call to an LLVM IR intrinsic function with the given return type |
| 592 | /// and arguments. If the intrinsic is overloaded, the function signature will |
| 593 | /// be automatically resolved based on the provided return type and argument |
| 594 | /// types. |
| 595 | llvm::CallInst *createIntrinsicCall(llvm::IRBuilderBase &builder, |
| 596 | llvm::Intrinsic::ID intrinsic, |
| 597 | llvm::Type *retTy, |
| 598 | ArrayRef<llvm::Value *> args); |
| 599 | |
| 600 | /// Creates a call to a LLVM IR intrinsic defined by LLVM_IntrOpBase. This |
| 601 | /// resolves the overloads, and maps mixed MLIR value and attribute arguments to |
| 602 | /// LLVM values. |
| 603 | llvm::CallInst *createIntrinsicCall( |
| 604 | llvm::IRBuilderBase &builder, ModuleTranslation &moduleTranslation, |
| 605 | Operation *intrOp, llvm::Intrinsic::ID intrinsic, unsigned numResults, |
| 606 | ArrayRef<unsigned> overloadedResults, ArrayRef<unsigned> overloadedOperands, |
| 607 | ArrayRef<unsigned> immArgPositions, |
| 608 | ArrayRef<StringLiteral> immArgAttrNames); |
| 609 | |
| 610 | } // namespace detail |
| 611 | |
| 612 | } // namespace LLVM |
| 613 | } // namespace mlir |
| 614 | |
| 615 | #endif // MLIR_TARGET_LLVMIR_MODULETRANSLATION_H |
| 616 | |