#include "mlir/IR/Attributes.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/DialectResourceBlobManager.h"
#include "mlir/IR/RegionGraphTraits.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h"
return buildSequentialConstant(constantsRef, outerShape, llvmType, loc);
}
+/// Convert a dense resource elements attribute to an LLVM IR constant using its
+/// raw data storage if possible. This supports elements attributes of tensor or
+/// vector type and avoids constructing separate objects for individual values
+/// of the innermost dimension. Constants for other dimensions are still
+/// constructed recursively. Returns nullptr on failure and emits errors at
+/// `loc`.
+static llvm::Constant *convertDenseResourceElementsAttr(
+ Location loc, DenseResourceElementsAttr denseResourceAttr,
+ llvm::Type *llvmType, const ModuleTranslation &moduleTranslation) {
+ assert(denseResourceAttr && "expected non-null attribute");
+
+ llvm::Type *innermostLLVMType = getInnermostElementType(llvmType);
+ if (!llvm::ConstantDataSequential::isElementTypeCompatible(
+ innermostLLVMType)) {
+ emitError(loc, "no known conversion for innermost element type");
+ return nullptr;
+ }
+
+ ShapedType type = denseResourceAttr.getType();
+ assert(type.getNumElements() > 0 && "Expected non-empty elements attribute");
+
+ AsmResourceBlob *blob = denseResourceAttr.getRawHandle().getBlob();
+ if (!blob) {
+ emitError(loc, "resource does not exist");
+ return nullptr;
+ }
+
+ ArrayRef<char> rawData = blob->getData();
+
+ // Check that the raw data size matches what is expected for the scalar size.
+ // TODO: in theory, we could repack the data here to keep constructing from
+ // raw data.
+ // TODO: we may also need to consider endianness when cross-compiling to an
+ // architecture where it is different.
+ int64_t numElements = denseResourceAttr.getType().getNumElements();
+ int64_t elementByteSize = rawData.size() / numElements;
+ if (8 * elementByteSize != innermostLLVMType->getScalarSizeInBits()) {
+ emitError(loc, "raw data size does not match element type size");
+ return nullptr;
+ }
+
+ // Compute the shape of all dimensions but the innermost. Note that the
+ // innermost dimension may be that of the vector element type.
+ bool hasVectorElementType = isa<VectorType>(type.getElementType());
+ int64_t numAggregates =
+ numElements / (hasVectorElementType
+ ? 1
+ : denseResourceAttr.getType().getShape().back());
+ ArrayRef<int64_t> outerShape = type.getShape();
+ if (!hasVectorElementType)
+ outerShape = outerShape.drop_back();
+
+ // Create a constructor for the innermost constant from a piece of raw data.
+ std::function<llvm::Constant *(StringRef)> buildCstData;
+ if (isa<TensorType>(type)) {
+ auto vectorElementType = dyn_cast<VectorType>(type.getElementType());
+ if (vectorElementType && vectorElementType.getRank() == 1) {
+ buildCstData = [&](StringRef data) {
+ return llvm::ConstantDataVector::getRaw(
+ data, vectorElementType.getShape().back(), innermostLLVMType);
+ };
+ } else if (!vectorElementType) {
+ buildCstData = [&](StringRef data) {
+ return llvm::ConstantDataArray::getRaw(data, type.getShape().back(),
+ innermostLLVMType);
+ };
+ }
+ } else if (isa<VectorType>(type)) {
+ buildCstData = [&](StringRef data) {
+ return llvm::ConstantDataVector::getRaw(data, type.getShape().back(),
+ innermostLLVMType);
+ };
+ }
+ if (!buildCstData) {
+ emitError(loc, "unsupported dense_resource type");
+ return nullptr;
+ }
+
+ // Create innermost constants and defer to the default constant creation
+ // mechanism for other dimensions.
+ SmallVector<llvm::Constant *> constants;
+ int64_t aggregateSize = denseResourceAttr.getType().getShape().back() *
+ (innermostLLVMType->getScalarSizeInBits() / 8);
+ constants.reserve(numAggregates);
+ for (unsigned i = 0; i < numAggregates; ++i) {
+ StringRef data(rawData.data() + i * aggregateSize, aggregateSize);
+ constants.push_back(buildCstData(data));
+ }
+
+ ArrayRef<llvm::Constant *> constantsRef = constants;
+ return buildSequentialConstant(constantsRef, outerShape, llvmType, loc);
+}
+
/// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`.
/// This currently supports integer, floating point, splat and dense element
/// attributes and combinations thereof. Also, an array attribute with two
return result;
}
+ if (auto denseResourceAttr = dyn_cast<DenseResourceElementsAttr>(attr)) {
+ return convertDenseResourceElementsAttr(loc, denseResourceAttr, llvmType,
+ moduleTranslation);
+ }
+
// Fall back to element-by-element construction otherwise.
if (auto elementsAttr = dyn_cast<ElementsAttr>(attr)) {
assert(elementsAttr.getShapedType().hasStaticShape());
// expected-error @below{{must appear at the module level}}
llvm.linker_options ["test"]
}
+
+// -----
+
+module @does_not_exist {
+ // expected-error @below{{resource does not exist}}
+ llvm.mlir.global internal constant @constant(dense_resource<test0> : tensor<4xf32>) : !llvm.array<4 x f32>
+}
+
+// -----
+
+module @raw_data_does_not_match_element_type_size {
+ // expected-error @below{{raw data size does not match element type size}}
+ llvm.mlir.global internal constant @constant(dense_resource<test1> : tensor<5xf32>) : !llvm.array<4 x f32>
+}
+
+{-#
+ dialect_resources: {
+ builtin: {
+ test1: "0x0800000054A3B53ED6C0B33E55D1A2BDE5D2BB3E"
+ }
+ }
+#-}
+
+// -----
+
+module @does_not_exist {
+ // expected-error @below{{unsupported dense_resource type}}
+ llvm.mlir.global internal constant @constant(dense_resource<test1> : memref<4xf32>) : !llvm.array<4 x f32>
+}
+
+{-#
+ dialect_resources: {
+ builtin: {
+ test1: "0x0800000054A3B53ED6C0B33E55D1A2BDE5D2BB3E"
+ }
+ }
+#-}
+
+// -----
+
+module @no_known_conversion_innermost_eltype {
+ // expected-error @below{{no known conversion for innermost element type}}
+ llvm.mlir.global internal constant @constant(dense_resource<test0> : tensor<4xi4>) : !llvm.array<4 x i4>
+}
+
+{-#
+ dialect_resources: {
+ builtin: {
+ test1: "0x0800000054A3B53ED6C0B33E55D1A2BDE5D2BB3E"
+ }
+ }
+#-}
// CHECK{LITERAL}: @splat_float_vector_3d = internal global [2 x [2 x <2 x float>]] [[2 x <2 x float>] [<2 x float> <float 4.200000e+01, float 4.200000e+01>, <2 x float> <float 4.200000e+01, float 4.200000e+01>], [2 x <2 x float>] [<2 x float> <float 4.200000e+01, float 4.200000e+01>, <2 x float> <float 4.200000e+01, float 4.200000e+01>]]
llvm.mlir.global internal @splat_float_vector_3d(dense<42.0> : vector<2x2x2xf32>) : !llvm.array<2 x !llvm.array<2 x vector<2xf32>>>
+// CHECK{LITERAL}: @dense_resource_tensor_constant = internal constant [5 x float] [float 0x3FCA034080000000, float 0xBFD0466300000000, float 0xBFD75DDF80000000, float 0xBFDE074F40000000, float 0x3FDDD3A1C0000000]
+llvm.mlir.global internal constant @dense_resource_tensor_constant(dense_resource<dense_resource_test_5xf32> : tensor<5xf32>) : !llvm.array<5 x f32>
+
+// CHECK{LITERAL}: @dense_resource_vector_constant = internal constant <5 x float> <float 0x3FCA034080000000, float 0xBFD0466300000000, float 0xBFD75DDF80000000, float 0xBFDE074F40000000, float 0x3FDDD3A1C0000000>
+llvm.mlir.global internal constant @dense_resource_vector_constant(dense_resource<dense_resource_test_5xf32> : vector<5xf32>) : vector<5xf32>
+
+
+// CHECK{LITERAL}: @dense_resource_multidim_tensor_constant = internal constant [1 x [2 x [2 x float]]] [[2 x [2 x float]] [[2 x float] [float 0x3FD6B46A80000000, float 0x3FD6781AC0000000], [2 x float] [float 0xBFB45A2AA0000000, float 0x3FD77A5CA0000000]]]
+llvm.mlir.global internal constant @dense_resource_multidim_tensor_constant(dense_resource<dense_resource_test_2x2xf32> : tensor<1x2x2xf32>) : !llvm.array<1 x !llvm.array<2 x !llvm.array<2 x f32>>>
+
+// CHECK{LITERAL}: @dense_resource_multidim_vector_constant = internal constant [1 x [2 x <2 x float>]] [[2 x <2 x float>] [<2 x float> <float 0x3FD6B46A80000000, float 0x3FD6781AC0000000>, <2 x float> <float 0xBFB45A2AA0000000, float 0x3FD77A5CA0000000>]]
+llvm.mlir.global internal constant @dense_resource_multidim_vector_constant(dense_resource<dense_resource_test_2x2xf32> : vector<1x2x2xf32>) : !llvm.array<1 x !llvm.array<2 x vector<2 x f32>>>
+
//
// Linkage attribute.
//
llvm.invoke %9(%6, %0) to ^bb2 unwind ^bb1 vararg(!llvm.func<void (ptr, ...)>) : !llvm.ptr, (!llvm.ptr, i32) -> ()
}
+// Resources are kept at end of file. New tests should be added above this.
+{-#
+ dialect_resources: {
+ builtin: {
+ dense_resource_test_5xf32: "0x08000000041A503E183382BEFCEEBABE7A3AF0BE0E9DEE3E",
+ dense_resource_test_2x2xf32: "0x0800000054A3B53ED6C0B33E55D1A2BDE5D2BB3E"
+ }
+ }
+#-}
+
// -----
llvm.func @foo() -> i8
projects / platform / upstream / llvm.git / commitdiff