[mlir][llvm] Support importing magic globals

[Dinistro]

Summary

This commit adds support for importing the magic globals "global_ctors"
and "global_dtors" from LLVM IR to the LLVM IR dialect. The import
fails when these globals have a non-null data pointer, as this can
currently not be represented in the corresponding MLIR operations.

[gysit]

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

61

I would probably rename to convertGlobalCtorsAndDtors since most modern functions use convert instead of process. Also let's make it a private method except there is a good reason to not do that.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

335

nit: drop newline

337–338

nit: Let's use braces for multi-line if statements.

601

nit: prio -> priority? and maybe init -> initializer?

620

After creating the GlobalCtorsOp/GlobalDtorsOp also update the globalInsertionOp (cf. line 540 in process global).

622

nit: As this is used twice I would suggest to add a getGlobalCtorVarName() or similar?

628

nit: Let's use mlirModule->getLoc() instead of UnknownLoc since we actually know at least the filename. I plan to change this for the other globals as well (the change has been discussed/suggested in https://reviews.llvm.org/D140768.

mlir/test/Target/LLVMIR/Import/import-failure.ll

41

nit: drop the newline here and below and also add "error" on the check line to make sure the code emits an error. I would probably also match at least the start of the variable.

72

nit: can you comment for the different tests why the import is supposed to fail?

[Dinistro]

address review comments

[Dinistro]

mlir/lib/Target/LLVMIR/ModuleImport.cpp

622

Added a constexpr on the top instead.

[Dinistro]

additional minor fixes

[gysit]

LGTM!

[Dinistro]

Fix error location to point to module loc

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

public:
 
   /// Converts all functions of the LLVM module to MLIR functions.
   LogicalResult convertFunctions();
 
   /// Converts all global variables of the LLVM module to MLIR global variables.
   LogicalResult convertGlobals();
 
   /// Stores the mapping between an LLVM value and its MLIR counterpart.
   void mapValue(llvm::Value *llvm, Value mlir) { mapValue(llvm) = mlir; }
 
   /// Provides write-once access to store the MLIR value corresponding to the
   /// given LLVM value.
   Value &mapValue(llvm::Value *value) {
     Value &mlir = valueMapping[value];
     assert(mlir == nullptr &&
            "attempting to map a value that is already mapped");
     return mlir;
private:
   FailureOr<Value> convertConstant(llvm::Constant *constant);
   /// Converts an LLVM constant and its transitive constant dependencies to MLIR
   /// operations by converting them in topological order using the
   /// `convertConstant` method, or returns failure if the conversion of any of
   /// them fails. All operations are inserted at the start of the current
   /// function entry block.
   FailureOr<Value> convertConstantExpr(llvm::Constant *constant);
 
+  /// Imports the magic globals "global_ctors" and "global_dtors".
+  LogicalResult convertGlobalCtorsAndDtors(llvm::GlobalVariable *globalVar);
+
   /// Builder pointing at where the next instruction should be generated.
   OpBuilder builder;
   /// Block to insert the next constant into.
   Block *constantInsertionBlock = nullptr;
   /// Operation to insert the next constant after.
   Operation *constantInsertionOp = nullptr;
   /// Operation to insert the next global after.
   Operation *globalInsertionOp = nullptr;

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 // operator << (raw_ostream&) defined.
 static std::string diag(llvm::Value &value) {
   std::string str;
   llvm::raw_string_ostream os(str);
   os << value;
   return os.str();
 }
 
+/// Returns the name of the global_ctors global variables.
+static constexpr StringRef getGlobalCtorsVarName() {
+  return "llvm.global_ctors";
+}
+
+/// Returns the name of the global_dtors global variables.
+static constexpr StringRef getGlobalDtorsVarName() {
+  return "llvm.global_dtors";
+}
+
 /// Creates an attribute containing ABI and preferred alignment numbers parsed
 /// a string. The string may be either "abi:preferred" or just "abi". In the
 /// latter case, the preferred alignment is considered equal to ABI alignment.
 static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
                                                      StringRef spec) {
   auto i32 = IntegerType::get(&ctx, 32);
 
   StringRef abiString, preferredString;
: builder(mlirModule->getContext()), context(mlirModule->getContext()),
       mlirModule(mlirModule), llvmModule(std::move(llvmModule)),
       iface(mlirModule->getContext()),
       typeTranslator(*mlirModule->getContext()),
       debugImporter(std::make_unique<DebugImporter>(mlirModule->getContext())) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
 LogicalResult ModuleImport::convertGlobals() {
-  for (llvm::GlobalVariable &globalVar : llvmModule->globals())
+  for (llvm::GlobalVariable &globalVar : llvmModule->globals()) {
+    if (globalVar.getName() == getGlobalCtorsVarName() ||
+        globalVar.getName() == getGlobalDtorsVarName()) {
+      if (failed(convertGlobalCtorsAndDtors(&globalVar))) {
+        return emitError(mlirModule.getLoc())
+               << "unhandled global variable " << diag(globalVar);
+      }
+      continue;
+    }
+
     if (!processGlobal(&globalVar))
       return failure();
+  }
   return success();
 }
 
 LogicalResult ModuleImport::convertFunctions() {
   for (llvm::Function &func : llvmModule->functions())
     if (failed(processFunction(&func)))
       return failure();
   return success();
globalOp.setUnnamedAddr(
         convertUnnamedAddrFromLLVM(globalVar->getUnnamedAddr()));
   }
   if (globalVar->hasSection())
     globalOp.setSection(globalVar->getSection());
 
   return globals[globalVar] = globalOp;
 }
 
+LogicalResult
+ModuleImport::convertGlobalCtorsAndDtors(llvm::GlobalVariable *globalVar) {
+  if (!globalVar->hasInitializer() || !globalVar->hasAppendingLinkage())
+    return failure();
+  auto *initializer =
+      dyn_cast<llvm::ConstantArray>(globalVar->getInitializer());
+  if (!initializer)
+    return failure();
+
+  SmallVector<Attribute> funcs;
+  SmallVector<int32_t> priorities;
+  for (llvm::Value *operand : initializer->operands()) {
+    auto *aggregate = dyn_cast<llvm::ConstantAggregate>(operand);
+    if (!aggregate || aggregate->getNumOperands() != 3)
+      return failure();
+
+    auto *priority = dyn_cast<llvm::ConstantInt>(aggregate->getOperand(0));
+    auto *func = dyn_cast<llvm::Function>(aggregate->getOperand(1));
+    auto *data = dyn_cast<llvm::Constant>(aggregate->getOperand(2));
+    if (!priority || !func || !data)
+      return failure();
+
+    // GlobalCtorsOps and GlobalDtorsOps do not support non-null data fields.
+    if (!data->isNullValue())
+      return failure();
+
+    funcs.push_back(FlatSymbolRefAttr::get(context, func->getName()));
+    priorities.push_back(priority->getValue().getZExtValue());
+  }
+
+  OpBuilder::InsertionGuard guard(builder);
+  if (!globalInsertionOp)
+    builder.setInsertionPointToStart(mlirModule.getBody());
+  else
+    builder.setInsertionPointAfter(globalInsertionOp);
+
+  if (globalVar->getName() == getGlobalCtorsVarName()) {
+    globalInsertionOp = builder.create<LLVM::GlobalCtorsOp>(
+        mlirModule.getLoc(), builder.getArrayAttr(funcs),
+        builder.getI32ArrayAttr(priorities));
+    return success();
+  }
+  globalInsertionOp = builder.create<LLVM::GlobalDtorsOp>(
+      mlirModule.getLoc(), builder.getArrayAttr(funcs),
+      builder.getI32ArrayAttr(priorities));
+  return success();
+}
+
 SetVector<llvm::Constant *>
 ModuleImport::getConstantsToConvert(llvm::Constant *constant) {
   // Traverse the constant dependencies in post order.
   SmallVector<llvm::Constant *> workList;
   SmallVector<llvm::Constant *> orderedList;
   workList.push_back(constant);
   while (!workList.empty()) {
     llvm::Constant *current = workList.pop_back_val();

mlir/test/Target/LLVMIR/Import/global-variables.ll

 ; CHECK-SAME:  (dense<[{{\[}}[1, 2], [3, 4]]]> : tensor<1x2x2xi32>)
 ; CHECK-SAME:  {addr_space = 0 : i32, dso_local} : !llvm.array<1 x array<2 x array<2 x i32>>>
 @nested_array_constant3 = internal constant [1 x [2 x [2 x i32]]] [[2 x [2 x i32]] [[2 x i32] [i32 1, i32 2], [2 x i32] [i32 3, i32 4]]]
 
 ; CHECK: llvm.mlir.global internal constant @nested_array_vector
 ; CHECK-SAME:  (dense<[{{\[}}[1, 2], [3, 4]]]> : vector<1x2x2xi32>)
 ; CHECK-SAME:   {addr_space = 0 : i32, dso_local} : !llvm.array<1 x array<2 x vector<2xi32>>>
 @nested_array_vector = internal constant [1 x [2 x <2 x i32>]] [[2 x <2 x i32>] [<2 x i32> <i32 1, i32 2>, <2 x i32> <i32 3, i32 4>]]
+
+; // -----
+
+; CHECK: llvm.mlir.global_ctors {ctors = [@foo, @bar], priorities = [0 : i32, 42 : i32]}
+; CHECK: llvm.mlir.global_dtors {dtors = [@foo], priorities = [0 : i32]}
[e-mail]_ctors = appending global [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }, { i32, ptr, ptr } { i32 42, ptr @bar, ptr null }]
[e-mail]_dtors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }]
+
+define void @foo() {
+  ret void
+}
+
+define void @bar() {
+  ret void
+}

mlir/test/Target/LLVMIR/Import/import-failure.ll

 define void @unhandled_intrinsic(ptr %arg0, ptr %arg1) {
   call void @llvm.gcroot(ptr %arg0, ptr %arg1)
   ret void
 }
 
 ; // -----
 
 ; CHECK: warning: unhandled metadata (2)   br i1 %arg1, label %bb1, label %bb2, !prof !0
 define i64 @cond_br(i1 %arg1, i64 %arg2) {
 entry:
   br i1 %arg1, label %bb1, label %bb2, !prof !0
 bb1:
   ret i64 %arg2
 bb2:
   ret i64 %arg2
 }
 

 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
 !2 = !DIFile(filename: "debug-info.ll", directory: "/")
 !3 = !DILocalVariable(scope: !4, name: "arg", file: !2, line: 1, arg: 1, align: 32);
 !4 = distinct !DISubprogram(name: "intrinsic", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
 !5 = !DILocation(line: 1, column: 2, scope: !4)
+
+; // -----
+
+; global_ctors requires the appending linkage type.
+; CHECK: error: unhandled global variable @llvm.global_ctors
[e-mail]_ctors = global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }]
+
+define void @foo() {
+  ret void
+}
+
+; // -----
+
+; global_dtors with non-null data fields cannot be represented in MLIR.
+; CHECK: error: unhandled global variable @llvm.global_dtors
[e-mail]_dtors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr @foo }]
+
+define void @foo() {
+  ret void
+}
+
+; // -----
+
+; global_ctors without a data field should not be imported.
+; CHECK: error: unhandled global variable @llvm.global_ctors
[e-mail]_ctors = appending global [1 x { i32, ptr }] [{ i32, ptr } { i32 0, ptr @foo }]
+
+define void @foo() {
+  ret void
+}
+
+; // -----
+
+; global_dtors with a wrong argument order should not be imported.
+; CHECK: error: unhandled global variable @llvm.global_dtors
[e-mail]_dtors = appending global [1 x { ptr, i32, ptr }] [{ ptr, i32, ptr } { ptr @foo, i32 0, ptr null }]
+
+define void @foo() {
+  ret void
+}