[mlir] LLVM import: handle constant data and array/vector aggregates

[ftynse]

Summary

Implement the handling of llvm::ConstantDataSequential and
llvm::ConstantAggregate for (nested) array and vector types when imporitng LLVM
IR to MLIR. In all cases, the result is a DenseElementsAttr that can be used in
either a llvm.mlir.global or a llvm.mlir.constant. Nested aggregates are
unpacked recursively until an element or a constant data is found. Nested
arrays with innermost scalar type are represented as DenseElementsAttr of
tensor type. Nested arrays with innermost vector type are represented as
DenseElementsAttr with (multidimensional) vector type.

Constant aggregates of struct type are not yet supported as the LLVM dialect
does not have a well-defined way of modeling struct-type constants.

[merge_guards_bot]

Unit tests: pass. 61913 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

254

How about LLVM struct?

[ftynse]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

254

We don't have a well-defined way of representing constants of struct type in the dialect. Since this code asserts (or even crashes) on unsupported inputs, I added an assert as well. The follow up (D72839) will replace all asserts including this one by graceful error handling.

I could just report an error and return nullptr here, but it would crash two steps up in the call stack...

[ftynse]

Anything else @nicolasvasilache ?

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

private:
   /// is unavailable.
   Location processDebugLoc(const llvm::DebugLoc &loc,
                            llvm::Instruction *inst = nullptr);
   /// `br` branches to `target`. Return the block arguments to attach to the
   /// generated branch op. These should be in the same order as the PHIs in
   /// `target`.
   SmallVector<Value, 4> processBranchArgs(llvm::BranchInst *br,
                                           llvm::BasicBlock *target);
+  /// Returns the standard type equivalent to be used in attributes for the
+  /// given LLVM IR dialect type.
+  Type getStdTypeForAttr(LLVMType type);
   /// Return `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
   /// Return `c` as an MLIR Value. This could either be a ConstantOp, or
   /// an expanded sequence of ops in the current function's entry block (for
   /// ConstantExprs or ConstantGEPs).
   Value processConstant(llvm::Constant *c);
 
   /// The current builder, pointing at where the next Instruction should be
default: {
     llvm::raw_string_ostream os(s);
     os << *type;
     emitError(unknownLoc) << "unhandled type: " << os.str();
     return {};
   }
   }
 }
 
+// We only need integers, floats, doubles, and vectors and tensors thereof for
+// attributes. Scalar and vector types are converted to the standard
+// equivalents. Array types are converted to ranked tensors; nested array types
+// are converted to multi-dimensional tensors or vectors, depending on the
+// innermost type being a scalar or a vector.
+Type Importer::getStdTypeForAttr(LLVMType type) {
+  if (!type)
+    return nullptr;
+
+  if (type.isIntegerTy())
+    return b.getIntegerType(type.getUnderlyingType()->getIntegerBitWidth());
+
+  if (type.getUnderlyingType()->isFloatTy())
+    return b.getF32Type();
+
+  if (type.getUnderlyingType()->isDoubleTy())
+    return b.getF64Type();
+
+  // LLVM vectors can only contain scalars.
+  if (type.isVectorTy()) {
+    auto numElements = type.getUnderlyingType()->getVectorElementCount();
+    if (numElements.Scalable)
+      emitError(unknownLoc) << "scalable vectors not supported";
+    return VectorType::get(numElements.Min,
+                           getStdTypeForAttr(type.getVectorElementType()));
+  }
+
+  // LLVM arrays can contain other arrays or vectors.
+  if (type.isArrayTy()) {
+    // Recover the nested array shape.
+    SmallVector<int64_t, 4> shape;
+    shape.push_back(type.getArrayNumElements());
+    while (type.getArrayElementType().isArrayTy()) {
+      type = type.getArrayElementType();
+      shape.push_back(type.getArrayNumElements());
+    }
+
+    // If the innermost type is a vector, use the multi-dimensional vector as
+    // attribute type.
+    if (type.getArrayElementType().isVectorTy()) {
+      LLVMType vectorType = type.getArrayElementType();
+      auto numElements =
+          vectorType.getUnderlyingType()->getVectorElementCount();
+      if (numElements.Scalable)
+        emitError(unknownLoc) << "scalable vectors not supported";
+      shape.push_back(numElements.Min);
+
+      LLVMType elementType = vectorType.getVectorElementType();
+      return VectorType::get(shape, getStdTypeForAttr(elementType));
+    }
+
+    // Otherwise use a tensor.
+    return RankedTensorType::get(shape,
+                                 getStdTypeForAttr(type.getArrayElementType()));
+  }
+
+  llvm_unreachable("no equivalent standard type for typed attributes");
+}
+
 // Get the given constant as an attribute. Not all constants can be represented
 // as attributes.
 Attribute Importer::getConstantAsAttr(llvm::Constant *value) {
   if (auto *ci = dyn_cast<llvm::ConstantInt>(value))
     return b.getIntegerAttr(
         IntegerType::get(ci->getType()->getBitWidth(), context),
         ci->getValue());
   if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
     if (c->isString())
       return b.getStringAttr(c->getAsString());
   if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
     if (c->getType()->isDoubleTy())
       return b.getFloatAttr(FloatType::getF64(context), c->getValueAPF());
     else if (c->getType()->isFloatingPointTy())
       return b.getFloatAttr(FloatType::getF32(context), c->getValueAPF());
   }
   if (auto *f = dyn_cast<llvm::Function>(value))
     return b.getSymbolRefAttr(f->getName());
-  return Attribute();
+
+  // Convert constant data to a dense elements attribute.
+  if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
+    LLVMType type = processType(cd->getElementType());
+    auto attrType = getStdTypeForAttr(processType(cd->getType()))
+                        .dyn_cast_or_null<ShapedType>();
+    assert(attrType);
+    if (!attrType)
+      return nullptr;
+
+    if (type.isIntegerTy()) {
+      SmallVector<APInt, 8> values;
+      values.reserve(cd->getNumElements());
+      for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
+        values.push_back(cd->getElementAsAPInt(i));
+      return DenseElementsAttr::get(attrType, values);
+    }
+
+    if (type.isFloatTy() || type.isDoubleTy()) {
+      SmallVector<APFloat, 8> values;
+      values.reserve(cd->getNumElements());
+      for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
+        values.push_back(cd->getElementAsAPFloat(i));
+      return DenseElementsAttr::get(attrType, values);
+    }
+
+    return nullptr;
+  }
+
+  // Unpack constant aggregates to create dense elements attribute whenever
+  // possible. Return nullptr (failure) otherwise.
+  if (auto *ca = dyn_cast<llvm::ConstantAggregate>(value)) {
+    auto outerType = getStdTypeForAttr(processType(value->getType()))
+                         .dyn_cast_or_null<ShapedType>();
+    if (!outerType)
+      return nullptr;
+
+    SmallVector<Attribute, 8> values;
+    SmallVector<int64_t, 8> shape;
+
+    for (unsigned i = 0, e = value->getNumOperands(); i < e; ++i) {
+      auto nested = getConstantAsAttr(value->getAggregateElement(i))
+                        .dyn_cast_or_null<DenseElementsAttr>();
+      if (!nested)
+        return nullptr;
+
+      values.append(nested.attr_value_begin(), nested.attr_value_end());
+    }
+
+    return DenseElementsAttr::get(outerType, values);
+  }
+
+  return nullptr;
 }
 
 /// Converts LLVM global variable linkage type into the LLVM dialect predicate.
 static LLVM::Linkage
 processLinkage(llvm::GlobalVariable::LinkageTypes linkage) {
   switch (linkage) {
   case llvm::GlobalValue::PrivateLinkage:
     return LLVM::Linkage::Private;

mlir/test/Target/import.ll

 @extern_weak = extern_weak global i32
 ; CHECK: llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : !llvm.i32
 @linkonce_odr = linkonce_odr global i32 42
 ; CHECK: llvm.mlir.global weak_odr @weak_odr(42 : i32) : !llvm.i32
 @weak_odr = weak_odr global i32 42
 ; CHECK: llvm.mlir.global external @external() : !llvm.i32
 @external = external global i32
 
+;
+; Sequential constants.
+;
+
+; CHECK: llvm.mlir.global internal constant @vector_constant(dense<[1, 2]> : vector<2xi32>) : !llvm<"<2 x i32>">
+@vector_constant = internal constant <2 x i32> <i32 1, i32 2>
+; CHECK: llvm.mlir.global internal constant @array_constant(dense<[1.000000e+00, 2.000000e+00]> : tensor<2xf32>) : !llvm<"[2 x float]">
+@array_constant = internal constant [2 x float] [float 1., float 2.]
+; CHECK: llvm.mlir.global internal constant @nested_array_constant(dense<[{{\[}}1, 2], [3, 4]]> : tensor<2x2xi32>) : !llvm<"[2 x [2 x i32]]">
+@nested_array_constant = internal constant [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_constant3(dense<[{{\[}}[1, 2], [3, 4]]]> : tensor<1x2x2xi32>) : !llvm<"[1 x [2 x [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(dense<[{{\[}}[1, 2], [3, 4]]]> : vector<1x2x2xi32>) : !llvm<"[1 x [2 x <2 x i32>]]">
+@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.func @fe(!llvm.i32) -> !llvm.float
 declare float @fe(i32)
 
 ; FIXME: function attributes.
 ; CHECK-LABEL: llvm.func @f1(%arg0: !llvm.i64) -> !llvm.i32 {
 ; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : !llvm.i32
 ; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : !llvm.i32
 ; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(1 : i1) : !llvm.i1