ModuleImport.cpp | Explore in Territory

//===- ModuleImport.cpp - LLVM to MLIR conversion ---------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the import of an LLVM IR module into an LLVM dialect
// module.
//
//===----------------------------------------------------------------------===//

#include "mlir/Target/LLVMIR/ModuleImport.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/Target/LLVMIR/Import.h"

#include "AttrKindDetail.h"
#include "DataLayoutImporter.h"
#include "DebugImporter.h"
#include "LoopAnnotationImporter.h"

#include "mlir/Dialect/DLTI/DLTI.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/Matchers.h"
#include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "mlir/Tools/mlir-translate/Translation.h"

#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/IR/Comdat.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Operator.h"
#include "llvm/Support/ModRef.h"

usingnamespacemlir;
usingnamespacemlir::LLVM;
usingnamespacemlir::LLVM::detail;

#include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"

// Utility to print an LLVM value as a string for passing to emitError().
// FIXME: Diagnostic should be able to natively handle types that have
// operator << (raw_ostream&) defined.
static std::string diag(const llvm::Value &value) { … }

// Utility to print an LLVM metadata node as a string for passing
// to emitError(). The module argument is needed to print the nodes
// canonically numbered.
static std::string diagMD(const llvm::Metadata *node,
                          const llvm::Module *module) { … }

/// Returns the name of the global_ctors global variables.
static constexpr StringRef getGlobalCtorsVarName() { … }

/// Prefix used for symbols of nameless llvm globals.
static constexpr StringRef getNamelessGlobalPrefix() { … }

/// Returns the name of the global_dtors global variables.
static constexpr StringRef getGlobalDtorsVarName() { … }

/// Returns the symbol name for the module-level comdat operation. It must not
/// conflict with the user namespace.
static constexpr StringRef getGlobalComdatOpName() { … }

/// Converts the sync scope identifier of `inst` to the string representation
/// necessary to build an atomic LLVM dialect operation. Returns the empty
/// string if the operation has either no sync scope or the default system-level
/// sync scope attached. The atomic operations only set their sync scope
/// attribute if they have a non-default sync scope attached.
static StringRef getLLVMSyncScope(llvm::Instruction *inst) { … }

/// Converts an array of unsigned indices to a signed integer position array.
static SmallVector<int64_t> getPositionFromIndices(ArrayRef<unsigned> indices) { … }

/// Converts the LLVM instructions that have a generated MLIR builder. Using a
/// static implementation method called from the module import ensures the
/// builders have to use the `moduleImport` argument and cannot directly call
/// import methods. As a result, both the intrinsic and the instruction MLIR
/// builders have to use the `moduleImport` argument and none of them has direct
/// access to the private module import methods.
static LogicalResult convertInstructionImpl(OpBuilder &odsBuilder,
                                            llvm::Instruction *inst,
                                            ModuleImport &moduleImport,
                                            LLVMImportInterface &iface) { … }

/// Get a topologically sorted list of blocks for the given basic blocks.
static SetVector<llvm::BasicBlock *>
getTopologicallySortedBlocks(ArrayRef<llvm::BasicBlock *> basicBlocks) { … }

ModuleImport::ModuleImport(ModuleOp mlirModule,
                           std::unique_ptr<llvm::Module> llvmModule,
                           bool emitExpensiveWarnings,
                           bool importEmptyDICompositeTypes)
    : … { … }

ComdatOp ModuleImport::getGlobalComdatOp() { … }

LogicalResult ModuleImport::processTBAAMetadata(const llvm::MDNode *node) { … }

LogicalResult
ModuleImport::processAccessGroupMetadata(const llvm::MDNode *node) { … }

LogicalResult
ModuleImport::processAliasScopeMetadata(const llvm::MDNode *node) { … }

FailureOr<SmallVector<AliasScopeAttr>>
ModuleImport::lookupAliasScopeAttrs(const llvm::MDNode *node) const { … }

void ModuleImport::addDebugIntrinsic(llvm::CallInst *intrinsic) { … }

LogicalResult ModuleImport::convertLinkerOptionsMetadata() { … }

LogicalResult ModuleImport::convertIdentMetadata() { … }

LogicalResult ModuleImport::convertMetadata() { … }

void ModuleImport::processComdat(const llvm::Comdat *comdat) { … }

LogicalResult ModuleImport::convertComdats() { … }

LogicalResult ModuleImport::convertGlobals() { … }

LogicalResult ModuleImport::convertDataLayout() { … }

LogicalResult ModuleImport::convertFunctions() { … }

void ModuleImport::setNonDebugMetadataAttrs(llvm::Instruction *inst,
                                            Operation *op) { … }

void ModuleImport::setIntegerOverflowFlags(llvm::Instruction *inst,
                                           Operation *op) const { … }

void ModuleImport::setFastmathFlagsAttr(llvm::Instruction *inst,
                                        Operation *op) const { … }

/// Returns if `type` is a scalar integer or floating-point type.
static bool isScalarType(Type type) { … }

/// Returns `type` if it is a builtin integer or floating-point vector type that
/// can be used to create an attribute or nullptr otherwise. If provided,
/// `arrayShape` is added to the shape of the vector to create an attribute that
/// matches an array of vectors.
static Type getVectorTypeForAttr(Type type, ArrayRef<int64_t> arrayShape = { … }

Type ModuleImport::getBuiltinTypeForAttr(Type type) { … }

/// Returns an integer or float attribute for the provided scalar constant
/// `constScalar` or nullptr if the conversion fails.
static TypedAttr getScalarConstantAsAttr(OpBuilder &builder,
                                         llvm::Constant *constScalar) { … }

/// Returns an integer or float attribute array for the provided constant
/// sequence `constSequence` or nullptr if the conversion fails.
static SmallVector<Attribute>
getSequenceConstantAsAttrs(OpBuilder &builder,
                           llvm::ConstantDataSequential *constSequence) { … }

Attribute ModuleImport::getConstantAsAttr(llvm::Constant *constant) { … }

LogicalResult ModuleImport::convertGlobal(llvm::GlobalVariable *globalVar) { … }

LogicalResult
ModuleImport::convertGlobalCtorsAndDtors(llvm::GlobalVariable *globalVar) { … }

SetVector<llvm::Constant *>
ModuleImport::getConstantsToConvert(llvm::Constant *constant) { … }

FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) { … }

FailureOr<Value> ModuleImport::convertConstantExpr(llvm::Constant *constant) { … }

FailureOr<Value> ModuleImport::convertValue(llvm::Value *value) { … }

FailureOr<Value> ModuleImport::convertMetadataValue(llvm::Value *value) { … }

FailureOr<SmallVector<Value>>
ModuleImport::convertValues(ArrayRef<llvm::Value *> values) { … }

LogicalResult ModuleImport::convertIntrinsicArguments(
    ArrayRef<llvm::Value *> values, ArrayRef<unsigned> immArgPositions,
    ArrayRef<StringLiteral> immArgAttrNames, SmallVectorImpl<Value> &valuesOut,
    SmallVectorImpl<NamedAttribute> &attrsOut) { … }

IntegerAttr ModuleImport::matchIntegerAttr(llvm::Value *value) { … }

FloatAttr ModuleImport::matchFloatAttr(llvm::Value *value) { … }

DILocalVariableAttr ModuleImport::matchLocalVariableAttr(llvm::Value *value) { … }

DILabelAttr ModuleImport::matchLabelAttr(llvm::Value *value) { … }

FPExceptionBehaviorAttr
ModuleImport::matchFPExceptionBehaviorAttr(llvm::Value *value) { … }

RoundingModeAttr ModuleImport::matchRoundingModeAttr(llvm::Value *value) { … }

FailureOr<SmallVector<AliasScopeAttr>>
ModuleImport::matchAliasScopeAttrs(llvm::Value *value) { … }

Location ModuleImport::translateLoc(llvm::DILocation *loc) { … }

LogicalResult
ModuleImport::convertBranchArgs(llvm::Instruction *branch,
                                llvm::BasicBlock *target,
                                SmallVectorImpl<Value> &blockArguments) { … }

LogicalResult
ModuleImport::convertCallTypeAndOperands(llvm::CallBase *callInst,
                                         SmallVectorImpl<Type> &types,
                                         SmallVectorImpl<Value> &operands) { … }

LogicalResult ModuleImport::convertIntrinsic(llvm::CallInst *inst) { … }

LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) { … }

LogicalResult ModuleImport::processInstruction(llvm::Instruction *inst) { … }

FlatSymbolRefAttr ModuleImport::getPersonalityAsAttr(llvm::Function *f) { … }

static void processMemoryEffects(llvm::Function *func, LLVMFuncOp funcOp) { … }

// List of LLVM IR attributes that map to an explicit attribute on the MLIR
// LLVMFuncOp.
static constexpr std::array kExplicitAttributes{ … };

static void processPassthroughAttrs(llvm::Function *func, LLVMFuncOp funcOp) { … }

void ModuleImport::processFunctionAttributes(llvm::Function *func,
                                             LLVMFuncOp funcOp) { … }

DictionaryAttr
ModuleImport::convertParameterAttribute(llvm::AttributeSet llvmParamAttrs,
                                        OpBuilder &builder) { … }

void ModuleImport::convertParameterAttributes(llvm::Function *func,
                                              LLVMFuncOp funcOp,
                                              OpBuilder &builder) { … }

LogicalResult ModuleImport::processFunction(llvm::Function *func) { … }

/// Checks if `dbgIntr` is a kill location that holds metadata instead of an SSA
/// value.
static bool isMetadataKillLocation(llvm::DbgVariableIntrinsic *dbgIntr) { … }

LogicalResult
ModuleImport::processDebugIntrinsic(llvm::DbgVariableIntrinsic *dbgIntr,
                                    DominanceInfo &domInfo) { … }

LogicalResult ModuleImport::processDebugIntrinsics() { … }

LogicalResult ModuleImport::processBasicBlock(llvm::BasicBlock *bb,
                                              Block *block) { … }

FailureOr<SmallVector<AccessGroupAttr>>
ModuleImport::lookupAccessGroupAttrs(const llvm::MDNode *node) const { … }

LoopAnnotationAttr
ModuleImport::translateLoopAnnotationAttr(const llvm::MDNode *node,
                                          Location loc) const { … }

OwningOpRef<ModuleOp>
mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                              MLIRContext *context, bool emitExpensiveWarnings,
                              bool dropDICompositeTypeElements) { … }
llvm/mlir/lib/Target/LLVMIR/ModuleImport.cpp
