[mlir][llvm] Add LLVM TargetExtType

[LukasSommerTu]

Summary

Add support for the llvm::TargetExtType to the MLIR LLVM dialect.

Target extension types were introduced to represent target-specific types, which are opaque to the compiler and optimizations.

The patch also enforces some of the constraints defined for the target extension type in the LLVM language reference manual.

Signed-off-by: Lukas Sommer <[e-mail]>

[gysit]

Thanks for the revision.

I added a first set of comments. I guess it could be nice to have an explicit zero intializer operation for this use case instead of using an integer. Luckily there seem to be others that are also interested in such an operation. So maybe that is an opportunity to get this going?

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

270–272

Shouldn't this just be:

if (failed(verifyOpaquePtr(getOperation(), ptrType, getElemType()))
  return failure();

verifyOpaque pointer seems to return a LogicalResult?

748–749

supportsAlloca seems unrelated to atomic operations?

1856

nit: You can drop braces for this if statement since the body is trivial, i.e. a single statement.

Please also drop braces in quite a few places below.

1858

nit: is allowed for a global value with

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

145

Any chance this could be split in a function that parses types until it finds type and a second function that parses integer until there are no more parameters. I think that could simplify the logic somewhat.

Also are you sure there is no helper to parse comma separated lists?

mlir/lib/Target/LLVMIR/ModuleImport.cpp

1077–1080

I guess a cleaner way to model this would be the introduction of a zero initializer operation as discussed here:

https://discourse.llvm.org/t/zero-initialization-for-globals-with-common-linkage/1762

It may be worth synchronizing with the original author of the thread?

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

346

nit: Please host the casting out of the condition.

mlir/test/Target/LLVMIR/Import/target-ext-type.ll

12

I think it could be nice to have import export tests for global and constant operations as well?

[Dinistro]

Thanks for working on this. I added some nit comments and suggestions on how to improve minor parts.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

271

NIT: One usually writes this as

if(failed(verifyFunc()))
  return failure();

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

116

NIT: Even though the other functions in this file don't have it, comments should be added to these newly added functions.

123

Maybe it would be easier to clearly separate types and integers into two groups to simplify this logic.

144

NIT: Can you add this grammar rule to the function comment?
Furthermore, can you explicitly add parentheses to make it clear to what part the | separates?

145

NIT: you can use AsmParser::parseCommaSeparatedList to simplify this.

[LukasSommerTu]

Simplify parsing logic and use existing helper

Extend and add tests for import/export

[LukasSommerTu]

@Dinistro and @gysit Thanks for your fast reviews! Addressed your feedback in an updated revision and some comments inline.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

This function is used during verification of StoreOp and LoadOp, to which similar constraints regarding target extension types apply as to alloca.

Adding load and store to supportsAlloca seemed to make the name unnecessarily long, so I used this shorter name. If you prefer, I can rename it to be clearer.

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

145

parsePrettyLLVMType has no optional version, so calling it first would print an error if a target extension type only has integer parameters.

As suggested by @Dinistro, I used the existing AsmParser::parseCommaSeparatedList helper to simplify the parsing logic.

mlir/lib/Target/LLVMIR/ModuleImport.cpp

1077–1080

Yes, I agree that a LLVM dialect operation for zeroinitializer would be useful for target extension types.

I came across that discussion when initially trying to find a way to represent the zeroinitializer for target extension types. I put a comment on the discussion in Discourse.

mlir/test/Target/LLVMIR/Import/target-ext-type.ll

12

Added and extended tests to also check import/export of globals and constants.

[gysit]

Thanks for reviving the discussion upstream. Let's see if it gains traction after the holiday. I may also be ok to put TODOs in this revision and only adopt the zeropinitializer operation in a follow up revision.

I have some more questions regarding the load store operation verification and some nit comments. Otherwise, things are looking good.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

You are right this is indeed also called for LoadOp / StoreOp if it is an atomic load or store:

if (memOp.getOrdering() != AtomicOrdering::not_atomic) {
  if (!isTypeCompatibleWithAtomicOp(valueType,
                                    /*isPointerTypeAllowed=*/true))

Do you want to run the code for atomic loads and stores only? Or are you interested in all loads and stores? For the latter LLVM_LoadableType maybe something to consider. Intuitively, I would have expected that atomics do not support ext type at all?

Regarding the naming supportsMemOps or similar may be a good if it is really about loading and storing?

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

116

nit: Parses -> Parses

Usually all function doc strings should use third person singular.

mlir/test/Target/LLVMIR/Import/target-ext-type.ll

34–46

nit: usually we try to intersperse CHECK lines with the input IR to have the CHECK line as close as possible to the input ir, e.g.:

; CHECK-LABEL: llvm.func @func2()
; CHECK-SAME:      !llvm.target<"spirv.Event"> 
define target("spirv.Event") @func2() {
  ; CHECK-NEXT:    %0 = llvm.mlir.constant(1 : i32) : i32
  ; CHECK-NEXT:    %1 = llvm.mlir.poison : !llvm.target<"spirv.Event">
  ; CHECK-NEXT:    %2 = llvm.alloca %0 x !llvm.target<"spirv.Event"> {alignment = 8 : i64} : (i32) -> !llvm.ptr
  %mem = alloca target("spirv.Event")
  ; CHECK-NEXT:    %3 = llvm.load %2 {alignment = 8 : i64} : !llvm.ptr -> !llvm.target<"spirv.Event">
  %val = load target("spirv.Event"), ptr %mem
  ; CHECK-NEXT:    llvm.return %1 : !llvm.target<"spirv.Event">
  ret target("spirv.Event") poison
}

[LukasSommerTu]

Improved checking target extension type eligibility for load/store.

Fixed nits in tests and comments.

[LukasSommerTu]

Add TODOs for 'zeroinitializer'.

[LukasSommerTu]

@gysit Thanks for your review! I've changed the check for load/store operations and also added the TODOs for the zeroinitializer.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

You're right, target extension types are not allowed in atomic operations, sorry for missing this.

I changed the name of the function as suggested and extended LLVM_LoadableType to include target extension types supporting memory operations.

[gysit]

Thanks we are almost there. I think there is one more check to add for atomics if I understand correctly see my comment below.

Can you maybe also add to brief tests in invalid.mlir that check a load cannot be instantiated with a non-loadable extension type and an atomic cannot be instantiated with a loadable extension type.

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

93 ↗

(On Diff #526425)

ultra nit: I would probably use LLVM_LoadableTargetExtType to use the same naming as below.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

You're right, target extension types are not allowed in atomic operations, sorry for missing this.

Should we then maybe add a check here that ensures an atomic operation cannot work on a target extension type, i.e.:

if (isa<LLVMTargetExtType>(type))
  return false;

[LukasSommerTu]

Fix type constraint. Add tests for invalid use of target extension type.

[LukasSommerTu]

@gysit Thanks for the review!

I've added the tests as suggested. An explicit check for target extension types wasn't necessary, see my inline comment.

I also needed to change the constraint for LLVM_LoadableType a bit. As target extension types match the LLVM_PrimitiveType.predicate (as they need to return true for isCompatibleOuterType), I had to negate the predicate and renamed it similar to your suggestion (LLVM_NonLoadableTargetExtType). The load example in invalid.mlir checks the error.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

This would already be ensured, as target extension types are neither compatible floating point types nor integer types, so bitWidth would not get a value and false would be returned from:

if (!bitWidth)
    return false;

As the other incompatible types (struct, array, ...) are also not listed explicitly here (and the LLVM verifier logic works similarly), I would not add an explicit check for target extension types, if you agree.

[gysit]

Thanks LGTM!

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

748–749

Ah makes sense!

[LukasSommerTu]

@gysit Thanks for approval. Could you please land this for me, I do not have commit access?

[ftynse]

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

127–128

OptionalParseResult having a value doesn't mean parsing success. It may fail, e.g., if the parsed value would overflow the type.

782

Consider putting these strings into named constexprs.

[LukasSommerTu]

Check optional parse result. Define name constants.

[LukasSommerTu]

@ftynse Thanks for your feedback, addressed it in the latest update.

[Dinistro]

I have some final nit comments, apart from that LGTM!

I can fix them and land the commit for you, if you like.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

2327

NIT: to be consistent, drop brackets here.

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

120

Ultra nit: This grammar rule is not entirely correct. It should be something like the following:

extTypeParams ::= typeList? | intList? | (typeList "," intList)
typeList      ::= type ("," type)*
intList       ::= integer ("," integer)*

Given that this is quite complicated, it can also be dropped.

778

Ultra NIT: constant are usually prefixed with a "k".

[LukasSommerTu]

In D151446#4380739, @Dinistro wrote:

I have some final nit comments, apart from that LGTM!

I can fix them and land the commit for you, if you like.

That would be nice, thanks! If you prefer that I address the nits first, that's also fine, just let me know.

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.td

def LLVMScalableVectorType : LLVMType<"LLVMScalableVector", "vec"> {
   ];
 
   let extraClassDeclaration = [{
     /// Checks if the given type can be used in a vector type.
     static bool isValidElementType(Type type);
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// LLVMTargetExtType
+//===----------------------------------------------------------------------===//
+
+def LLVMTargetExtType : LLVMType<"LLVMTargetExt", "target"> {
+  let summary = "LLVM target-specific extension type";
+  let description = [{
+    LLVM dialect target extension type, which are generally unintrospectable
+    from target-independent optimizations.
+
+    Target extension types have a string name, and optionally have type and/or
+    integer parameters. The exact meaning of any parameters is dependent on the
+    target.
+  }];
+
+  let parameters = (ins StringRefParameter<>:$extTypeName,
+                        OptionalArrayRefParameter<"Type">:$typeParams,
+                        OptionalArrayRefParameter<"unsigned int">:$intParams);
+
+
+  let assemblyFormat = [{
+    `<` $extTypeName (`,` custom<ExtTypeParams>($typeParams, $intParams)^ )? `>`
+  }];
+
+  let extraClassDeclaration = [{
+    enum Property {
+      /// zeroinitializer is valid for this target extension type.
+      HasZeroInit = 1U << 0,
+      /// This type may be used as the value type of a global variable.
+      CanBeGlobal = 1U << 1,
+    };
+
+    bool hasProperty(Property Prop) const;
+
+    bool supportsAlloca() const;
+  }];
+}
+
 #endif // LLVMTYPES_TD

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

if (!ptrType.isOpaque() && ptrElementType.has_value()) {
     return op->emitOpError()
            << "unexpected '" << kElemTypeAttrName
            << "' attribute when non-opaque pointer type is used";
   }
   return success();
 }
 
 LogicalResult AllocaOp::verify() {
-  return verifyOpaquePtr(getOperation(), llvm::cast<LLVMPointerType>(getType()),
-                         getElemType());
+  LLVMPointerType ptrType = llvm::cast<LLVMPointerType>(getType());
+  if (auto verifyElemTy =
+          verifyOpaquePtr(getOperation(), ptrType, getElemType());
+      failed(verifyElemTy)) {
+    return verifyElemTy;
+  }
+
+  Type elemTy =
+      (ptrType.isOpaque()) ? *getElemType() : ptrType.getElementType();
+  // Only certain target extension types can be used in 'alloca'.
+  if (auto targetExtType = dyn_cast<LLVMTargetExtType>(elemTy);
+      targetExtType && !targetExtType.supportsAlloca()) {
+    return emitOpError()
+           << "this target extension type cannot be used in alloca";
+  }
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM::BrOp
 //===----------------------------------------------------------------------===//
 
 /// Check if the `loopAttr` references correct symbols.
 static LogicalResult verifyLoopAnnotationAttr(LoopAnnotationAttr loopAttr,

 
 /// Returns true if the given type is supported by atomic operations. All
 /// integer and float types with limited bit width are supported. Additionally,
 /// depending on the operation pointers may be supported as well.
 static bool isTypeCompatibleWithAtomicOp(Type type, bool isPointerTypeAllowed) {
   if (llvm::isa<LLVMPointerType>(type))
     return isPointerTypeAllowed;
 
+  if (auto targetExtType = dyn_cast<LLVMTargetExtType>(type))
+    return targetExtType.supportsAlloca();
+
   std::optional<unsigned> bitWidth;
   if (auto floatType = llvm::dyn_cast<FloatType>(type)) {
     if (!isCompatibleFloatingPointType(type))
       return false;
     bitWidth = floatType.getWidth();
   }
   if (auto integerType = llvm::dyn_cast<IntegerType>(type))
     bitWidth = integerType.getWidth();
IntegerType elementType =
         type ? llvm::dyn_cast<IntegerType>(type.getElementType()) : nullptr;
     if (!elementType || elementType.getWidth() != 8 ||
         type.getNumElements() != strAttr.getValue().size())
       return emitOpError(
           "requires an i8 array type of the length equal to that of the string "
           "attribute");
   }
 
+  if (auto targetExtType = dyn_cast<LLVMTargetExtType>(getType())) {
+    if (!targetExtType.hasProperty(LLVMTargetExtType::CanBeGlobal)) {
+      return emitOpError()
+             << "this target extension type cannot be used in a global";
+    }
+    if (Attribute value = getValueOrNull()) {
+      // Only a single, zero integer attribute (=zeroinitializer) is allowed a
+      // value for a global with TargetExtType.
+      if (!isa<IntegerAttr>(value) || !isZeroAttribute(value)) {
+        return emitOpError()
+               << "expected zero value for global with target extension type";
+      }
+    }
+  }
+
   if (getLinkage() == Linkage::Common) {
     if (Attribute value = getValueOrNull()) {
       if (!isZeroAttribute(value)) {
         return emitOpError()
                << "expected zero value for '"
                << stringifyLinkage(Linkage::Common) << "' linkage";
       }
     }
if (auto structType = llvm::dyn_cast<LLVMStructType>(getType())) {
     if (!llvm::isa<IntegerType, Float16Type, Float32Type, Float64Type>(
             elementType)) {
       return emitError()
              << "expected struct element types to be floating point type or "
                 "integer type";
     }
     return success();
   }
+  if (auto targetExtType = dyn_cast<LLVMTargetExtType>(getType())) {
+    if (!targetExtType.hasProperty(LLVM::LLVMTargetExtType::HasZeroInit)) {
+      return emitOpError()
+             << "target extension type does not support zero-initializer";
+    }
+    // Only a single, zero integer attribute (=zeroinitializer) is allowed a
+    // value for a global with TargetExtType.
+    if (!isa<IntegerAttr>(getValue()) || !isZeroAttribute(getValue())) {
+      return emitOpError()
+             << "only zero-initializer allowed for target extension types";
+    }
+    return success();
+  }
   if (!llvm::isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>(getValue()))
     return emitOpError()
            << "only supports integer, float, string or elements attributes";
   return success();
 }
 
 // Constant op constant-folds to its value.
 OpFoldResult LLVM::ConstantOp::fold(FoldAdaptor) { return getValue(); }

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

return TypeSwitch<Type, StringRef>(type)
       .Case<LLVMLabelType>([&](Type) { return "label"; })
       .Case<LLVMMetadataType>([&](Type) { return "metadata"; })
       .Case<LLVMFunctionType>([&](Type) { return "func"; })
       .Case<LLVMPointerType>([&](Type) { return "ptr"; })
       .Case<LLVMFixedVectorType, LLVMScalableVectorType>(
           [&](Type) { return "vec"; })
       .Case<LLVMArrayType>([&](Type) { return "array"; })
       .Case<LLVMStructType>([&](Type) { return "struct"; })
+      .Case<LLVMTargetExtType>([&](Type) { return "target"; })
       .Default([](Type) -> StringRef {
         llvm_unreachable("unexpected 'llvm' type kind");
       });
 }
 
 /// Prints a structure type. Keeps track of known struct names to handle self-
 /// or mutually-referring structs without falling into infinite recursion.
 static void printStructType(AsmPrinter &printer, LLVMStructType type) {
if (!type) {
     printer << "<<NULL-TYPE>>";
     return;
   }
 
   printer << getTypeKeyword(type);
 
   llvm::TypeSwitch<Type>(type)
       .Case<LLVMPointerType, LLVMArrayType, LLVMFixedVectorType,
-            LLVMScalableVectorType, LLVMFunctionType>(
+            LLVMScalableVectorType, LLVMFunctionType, LLVMTargetExtType>(
           [&](auto type) { type.print(printer); })
       .Case([&](LLVMStructType structType) {
         printStructType(printer, structType);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // Parsing.
return StringSwitch<function_ref<Type()>>(key)
       .Case("token", [&] { return LLVMTokenType::get(ctx); })
       .Case("label", [&] { return LLVMLabelType::get(ctx); })
       .Case("metadata", [&] { return LLVMMetadataType::get(ctx); })
       .Case("func", [&] { return LLVMFunctionType::parse(parser); })
       .Case("ptr", [&] { return LLVMPointerType::parse(parser); })
       .Case("vec", [&] { return parseVectorType(parser); })
       .Case("array", [&] { return LLVMArrayType::parse(parser); })
       .Case("struct", [&] { return parseStructType(parser); })
+      .Case("target", [&] { return LLVMTargetExtType::parse(parser); })
       .Default([&] {
         parser.emitError(keyLoc) << "unknown LLVM type: " << key;
         return Type();
       })();
 }
 
 /// Helper to use in parse lists.
 static ParseResult dispatchParse(AsmParser &parser, Type &type) {

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

static void printPointer(AsmPrinter &p, Type elementType,
   if (addressSpace != 0) {
     if (elementType)
       p << ", ";
     p << addressSpace;
   }
 }
 
 //===----------------------------------------------------------------------===//
+// custom<ExtTypeParams>
+//===----------------------------------------------------------------------===//
+
+static bool parseTypeOrIntParam(AsmParser &p, SmallVectorImpl<Type> &typeParams,
+                                SmallVectorImpl<unsigned int> &intParams,
+                                bool &parseType) {
+  unsigned int i;
+  if (p.parseOptionalInteger(i).has_value()) {
+    // Successfully parsed an integer.
+    intParams.push_back(i);
+    // After the first integer was successfully parsed, no more types can be
+    // parsed.
+    parseType = false;
+    return true;
+  }
+  if (parseType) {
+    Type t;
+    if (!parsePrettyLLVMType(p, t)) {
+      // Successfully parsed a type.
+      typeParams.push_back(t);
+      return true;
+    }
+  }
+  // Failed to parse a type or an integer.
+  return false;
+}
+
+static ParseResult
+parseExtTypeParams(AsmParser &p, SmallVectorImpl<Type> &typeParams,
+                   SmallVectorImpl<unsigned int> &intParams) {
+  bool parseType = true;
+  // ([type | integer ])? (, [type | integer])* | empty
+  bool keepParsing = parseTypeOrIntParam(p, typeParams, intParams, parseType);
+  while (keepParsing) {
+    keepParsing = !p.parseOptionalComma() &&
+                  parseTypeOrIntParam(p, typeParams, intParams, parseType);
+  }
+  return success();
+}
+
+static void printExtTypeParams(AsmPrinter &p, ArrayRef<Type> typeParams,
+                               ArrayRef<unsigned int> intParams) {
+  p << typeParams;
+  if (!typeParams.empty() && !intParams.empty())
+    p << ", ";
+
+  p << intParams;
+}
+
+//===----------------------------------------------------------------------===//
 // ODS-Generated Definitions
 //===----------------------------------------------------------------------===//
 
 /// These are unused for now.
 /// TODO: Move over to these once more types have been migrated to TypeDef.
 LLVM_ATTRIBUTE_UNUSED static OptionalParseResult
 generatedTypeParser(AsmParser &parser, StringRef *mnemonic, Type &value);
 LLVM_ATTRIBUTE_UNUSED static LogicalResult

 LogicalResult
 LLVMScalableVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                                Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMScalableVectorType>(
       emitError, elementType, numElements);
 }
 
 //===----------------------------------------------------------------------===//
+// LLVMTargetExtType.
+//===----------------------------------------------------------------------===//
+
+bool LLVM::LLVMTargetExtType::hasProperty(Property prop) const {
+  // See llvm/lib/IR/Type.cpp for reference.
+  uint64_t properties = 0;
+
+  if (getExtTypeName().starts_with("spirv."))
+    properties |=
+        (LLVMTargetExtType::HasZeroInit | LLVM::LLVMTargetExtType::CanBeGlobal);
+
+  return (properties & prop) == prop;
+}
+
+bool LLVM::LLVMTargetExtType::supportsAlloca() const {
+  // See llvm/lib/IR/Type.cpp for reference.
+  if (getExtTypeName().starts_with("spirv."))
+    return true;
+
+  if (getExtTypeName() == "aarch64.svcount")
+    return true;
+
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 bool mlir::LLVM::isCompatibleOuterType(Type type) {
   // clang-format off
   if (llvm::isa<
       BFloat16Type,
       Float16Type,
       Float32Type,
       Float64Type,
       Float80Type,
       Float128Type,
       Float8E4M3FNType,
       Float8E5M2Type,
       LLVMArrayType,
       LLVMFunctionType,
       LLVMLabelType,
       LLVMMetadataType,
       LLVMPPCFP128Type,
       LLVMPointerType,
       LLVMStructType,
       LLVMTokenType,
       LLVMFixedVectorType,
       LLVMScalableVectorType,
+      LLVMTargetExtType,
       LLVMVoidType,
       LLVMX86MMXType
     >(type)) {
     // clang-format on
     return true;
   }
 
   // Only signless integers are compatible.
bool result =
             return vecType.getRank() == 1 &&
                    isCompatible(vecType.getElementType());
           })
           .Case<LLVMPointerType>([&](auto pointerType) {
             if (pointerType.isOpaque())
               return true;
             return isCompatible(pointerType.getElementType());
           })
+          .Case<LLVMTargetExtType>([&](auto extType) {
+            return llvm::all_of(extType.getTypeParams(), isCompatible);
+          })
           // clang-format off
           .Case<
               LLVMFixedVectorType,
               LLVMScalableVectorType,
               LLVMArrayType
           >([&](auto containerType) {
             return isCompatible(containerType.getElementType());
           })
return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
         llvm::TypeSize elementSize =
             getPrimitiveTypeSizeInBits(t.getElementType());
         return llvm::TypeSize(elementSize.getFixedValue() * t.getNumElements(),
                               elementSize.isScalable());
       })
       .Default([](Type ty) {
         assert((llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                           LLVMTokenType, LLVMStructType, LLVMArrayType,
-                          LLVMPointerType, LLVMFunctionType>(ty)) &&
+                          LLVMPointerType, LLVMFunctionType, LLVMTargetExtType>(
+                   ty)) &&
                "unexpected missing support for primitive type");
         return llvm::TypeSize::Fixed(0);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // LLVMDialect
 //===----------------------------------------------------------------------===//

mlir/lib/Target/LLVMIR/ModuleImport.cpp

for (const auto &it : llvm::enumerate(elementValues)) {
             builder.create<ConstantOp>(loc, builder.getI32Type(), indexAttr);
         root = builder.create<InsertElementOp>(loc, rootType, root, it.value(),
                                                indexValue);
       }
     }
     return root;
   }
 
+  if (auto *constTargetNone = dyn_cast<llvm::ConstantTargetNone>(constant)) {
+    LLVMTargetExtType targetExtType =
+        cast<LLVMTargetExtType>(convertType(constTargetNone->getType()));
+    assert(targetExtType.hasProperty(LLVMTargetExtType::HasZeroInit) &&
+           "target extension type does not support zero-initialization");
+    // As the number of values needed for initialization is target-specific and
+    // opaque to the compiler, use a single i64 zero-valued attribute to
+    // represent the 'zeroinitializer', which is the only constant value allowed
+    // for target extension types (besides poison and undef).
+    return builder
+        .create<LLVM::ConstantOp>(loc, targetExtType,
+                                  builder.getI64IntegerAttr(0))
+        .getRes();
+  }
+
   StringRef error = "";
   if (isa<llvm::BlockAddress>(constant))
     error = " since blockaddress(...) is unsupported";
 
   return emitError(loc) << "unhandled constant: " << diag(*constant) << error;
 }
 
 FailureOr<Value> ModuleImport::convertConstantExpr(llvm::Constant *constant) {

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

if (auto *structType = dyn_cast<::llvm::StructType>(llvmType)) {
     if (!real)
       return nullptr;
     llvm::Constant *imag =
         getLLVMConstant(elementType, arrayAttr[1], loc, moduleTranslation);
     if (!imag)
       return nullptr;
     return llvm::ConstantStruct::get(structType, {real, imag});
   }
+  if (auto *targetExtType = dyn_cast<::llvm::TargetExtType>(llvmType)) {
+    if (auto intAttr = dyn_cast<IntegerAttr>(attr);
+        !intAttr || intAttr.getInt() != 0)
+      emitError(loc,
+                "Only zero-initialization allowed for target extension type");
+
+    return llvm::ConstantTargetNone::get(targetExtType);
+  }
   // For integer types, we allow a mismatch in sizes as the index type in
   // MLIR might have a different size than the index type in the LLVM module.
   if (auto intAttr = dyn_cast<IntegerAttr>(attr))
     return llvm::ConstantInt::get(
         llvmType,
         intAttr.getValue().sextOrTrunc(llvmType->getIntegerBitWidth()));
   if (auto floatAttr = dyn_cast<FloatAttr>(attr)) {
     if (llvmType !=

mlir/lib/Target/LLVMIR/TypeFromLLVM.cpp

public:
   Type translateType(llvm::Type *type) {
     if (knownTranslations.count(type))
       return knownTranslations.lookup(type);
 
     Type translated =
         llvm::TypeSwitch<llvm::Type *, Type>(type)
             .Case<llvm::ArrayType, llvm::FunctionType, llvm::IntegerType,
                   llvm::PointerType, llvm::StructType, llvm::FixedVectorType,
-                  llvm::ScalableVectorType>(
+                  llvm::ScalableVectorType, llvm::TargetExtType>(
                 [this](auto *type) { return this->translate(type); })
             .Default([this](llvm::Type *type) {
               return translatePrimitiveType(type);
             });
     knownTranslations.try_emplace(type, translated);
     return translated;
   }
 
private:
   }
 
   /// Translates the given scalable-vector type.
   Type translate(llvm::ScalableVectorType *type) {
     return LLVM::LLVMScalableVectorType::get(
         translateType(type->getElementType()), type->getMinNumElements());
   }
 
+  /// Translates the given target extension type.
+  Type translate(llvm::TargetExtType *type) {
+    SmallVector<Type> typeParams;
+    translateTypes(type->type_params(), typeParams);
+
+    return LLVM::LLVMTargetExtType::get(&context, type->getName(), typeParams,
+                                        type->int_params());
+  }
+
   /// Translates a list of types.
   void translateTypes(ArrayRef<llvm::Type *> types,
                       SmallVectorImpl<Type> &result) {
     result.reserve(result.size() + types.size());
     for (llvm::Type *type : types)
       result.push_back(translateType(type));
   }
 

mlir/lib/Target/LLVMIR/TypeToLLVM.cpp

llvm::Type *translated =
               return llvm::Type::getLabelTy(context);
             })
             .Case([this](LLVM::LLVMMetadataType) {
               return llvm::Type::getMetadataTy(context);
             })
             .Case<LLVM::LLVMArrayType, IntegerType, LLVM::LLVMFunctionType,
                   LLVM::LLVMPointerType, LLVM::LLVMStructType,
                   LLVM::LLVMFixedVectorType, LLVM::LLVMScalableVectorType,
-                  VectorType>(
+                  VectorType, LLVM::LLVMTargetExtType>(
                 [this](auto type) { return this->translate(type); })
             .Default([](Type t) -> llvm::Type * {
               llvm_unreachable("unknown LLVM dialect type");
             });
 
     // Cache the result of the conversion and return.
     knownTranslations.try_emplace(type, translated);
     return translated;
private:
   }
 
   /// Translates the given scalable-vector type.
   llvm::Type *translate(LLVM::LLVMScalableVectorType type) {
     return llvm::ScalableVectorType::get(translateType(type.getElementType()),
                                          type.getMinNumElements());
   }
 
+  /// Translates the given target extension type.
+  llvm::Type *translate(LLVM::LLVMTargetExtType type) {
+    SmallVector<llvm::Type *> typeParams;
+    translateTypes(type.getTypeParams(), typeParams);
+    return llvm::TargetExtType::get(context, type.getExtTypeName(), typeParams,
+                                    type.getIntParams());
+  }
+
   /// Translates a list of types.
   void translateTypes(ArrayRef<Type> types,
                       SmallVectorImpl<llvm::Type *> &result) {
     result.reserve(result.size() + types.size());
     for (auto type : types)
       result.push_back(translateType(type));
   }
 

mlir/test/Dialect/LLVMIR/global.mlir

 // -----
 
 llvm.func @dtor() {
   llvm.return
 }
 
 // CHECK: llvm.mlir.global_dtors {dtors = [@dtor], priorities = [0 : i32]}
 llvm.mlir.global_dtors { dtors = [@dtor], priorities = [0 : i32]}
+
+// -----
+
+// CHECK: llvm.mlir.global external @target_ext() {addr_space = 0 : i32} : !llvm.target<"spirv.Image", i32, 0>
+llvm.mlir.global @target_ext() : !llvm.target<"spirv.Image", i32, 0>
+
+// CHECK: llvm.mlir.global external @target_ext_init(0 : i64) {addr_space = 0 : i32} : !llvm.target<"spirv.Image", i32, 0>
+llvm.mlir.global @target_ext_init(0 : i64) : !llvm.target<"spirv.Image", i32, 0>
+
+// -----
+
+// expected-error @+1 {{expected zero value for global with target extension type}}
+llvm.mlir.global @target_fail(1 : i64) : !llvm.target<"spirv.Image", i32, 0>

mlir/test/Dialect/LLVMIR/invalid.mlir

 }
 
 // -----
 
 func.func @invalid_bitcast_addr_cast_vec(%arg : !llvm.vec<4 x ptr<1>>) {
   // expected-error@+1 {{cannot cast pointers of different address spaces, use 'llvm.addrspacecast' instead}}
   %0 = llvm.bitcast %arg : !llvm.vec<4 x ptr<1>> to !llvm.vec<4 x ptr>
 }
+
+// -----
+
+func.func @invalid_target_ext_alloca() {
+  %0 = llvm.mlir.constant(1 : i64) : i64
+  // expected-error@+1 {{this target extension type cannot be used in alloca}}
+  %1 = llvm.alloca %0 x !llvm.target<"no_alloca"> : (i64) -> !llvm.ptr
+}
+
+// -----
+
+func.func @invalid_target_ext_constant() {
+  // expected-error@+1 {{target extension type does not support zero-initializer}}
+  %0 = llvm.mlir.constant(0 : index) : !llvm.target<"invalid_constant">
+}
+
+// -----
+
+func.func @invalid_target_ext_constant() {
+  // expected-error@+1 {{only zero-initializer allowed for target extension types}}
+  %0 = llvm.mlir.constant(42 : index) : !llvm.target<"spirv.Event">
+}

mlir/test/Dialect/LLVMIR/types.mlir

 !qux = !llvm.struct<(!baz)>
 
 // CHECK: aliases
 llvm.func @aliases() {
   // CHECK: !llvm.struct<(i32, f32, struct<(i64)>)>
   "some.op"() : () -> !llvm.struct<(i32, f32, !qux)>
   llvm.return
 }
+
+// -----
+
+// CHECK-LABEL: ext_target
+llvm.func @ext_target() {
+    // CHECK: !llvm.target<"target1", i32, 1>
+    %0 = "some.op"() : () -> !llvm.target<"target1", i32, 1>
+    // CHECK: !llvm.target<"target2">
+    %1 = "some.op"() : () -> !llvm.target<"target2">
+    // CHECK: !llvm.target<"target3", i32, i64, f64>
+    %2 = "some.op"() : () -> !llvm.target<"target3", i32, i64, f64>
+    // CHECK: !llvm.target<"target4", 1, 0, 42>
+    %3 = "some.op"() : () -> !llvm.target<"target4", 1, 0, 42>
+    // CHECK: !llvm.target<"target5", i32, f64, 0, 5>
+    %4 = "some.op"() : () -> !llvm.target<"target5", i32, f64, 0, 5>
+    llvm.return
+}

mlir/test/Target/LLVMIR/Import/target-ext-type.ll

+; RUN: mlir-translate -import-llvm %s | FileCheck %s
+
+; CHECK: llvm.func spir_kernelcc @foo(%arg0: !llvm.target<"spirv.Pipe", 0>
+; CHECK-SAME: %arg1: !llvm.target<"spirv.Pipe", 1>
+; CHECK-SAME: %arg2: !llvm.target<"spirv.Image", !llvm.void, 0, 0, 0, 0, 0, 0, 0>
+; CHECK-SAME: %arg3: !llvm.target<"spirv.Image", i32, 1, 0, 0, 0, 0, 0, 0>
+; CHECK-SAME: %arg4: !llvm.target<"spirv.Image", i32, 2, 0, 0, 0, 0, 0, 0>
+; CHECK-SAME: %arg5: !llvm.target<"spirv.Image", f16, 1, 0, 1, 0, 0, 0, 0>
+; CHECK-SAME: %arg6: !llvm.target<"spirv.Image", f32, 5, 0, 0, 0, 0, 0, 0>
+; CHECK-SAME: %arg7: !llvm.target<"spirv.Image", !llvm.void, 0, 0, 0, 0, 0, 0, 1>
+; CHECK-SAME: %arg8: !llvm.target<"spirv.Image", !llvm.void, 1, 0, 0, 0, 0, 0, 2>)
+define spir_kernel void @foo(
+  target("spirv.Pipe", 0) %a,
+  target("spirv.Pipe", 1) %b,
+  target("spirv.Image", void, 0, 0, 0, 0, 0, 0, 0) %c1,
+  target("spirv.Image", i32, 1, 0, 0, 0, 0, 0, 0) %d1,
+  target("spirv.Image", i32, 2, 0, 0, 0, 0, 0, 0) %e1,
+  target("spirv.Image", half, 1, 0, 1, 0, 0, 0, 0) %f1,
+  target("spirv.Image", float, 5, 0, 0, 0, 0, 0, 0) %g1,
+  target("spirv.Image", void, 0, 0, 0, 0, 0, 0, 1) %c2,
+  target("spirv.Image", void, 1, 0, 0, 0, 0, 0, 2) %d3) {
+entry:
+  ret void
+}

mlir/test/Target/LLVMIR/llvmir-types.mlir

 // CHECK: declare <{ i32, { i32, i1 }, float }> @return_sp_i32_s_i31_1_float()
 llvm.func @return_sp_i32_s_i31_1_float() -> !llvm.struct<packed (i32, struct<(i32, i1)>, f32)>
 
 // CHECK: declare { <{ i32 }> } @return_s_sp_i32()
 llvm.func @return_s_sp_i32() -> !llvm.struct<(struct<packed (i32)>)>
 // CHECK: declare <{ { i32 } }> @return_sp_s_i32()
 llvm.func @return_sp_s_i32() -> !llvm.struct<packed (struct<(i32)>)>
 
+// CHECK: declare target("target-no-param") @return_target_ext_no_param()
+llvm.func @return_target_ext_no_param() -> !llvm.target<"target-no-param">
+
+// CHECK: declare target("target-type-param", i32, double) @return_target_ext_type_params()
+llvm.func @return_target_ext_type_params() -> !llvm.target<"target-type-param", i32, f64>
+
+// CHECK: declare target("target-int-param", 0, 42) @return_target_ext_int_params()
+llvm.func @return_target_ext_int_params() -> !llvm.target<"target-int-param", 0, 42>
+
+// CHECK: declare target("target-params", i32, double, 0, 5) @return_target_ext_params()
+llvm.func @return_target_ext_params() -> !llvm.target<"target-params", i32, f64, 0, 5>
+
 // -----
 // Put structs into a separate split so that we can match their declarations
 // locally.
 
 // CHECK: %empty = type {}
 // CHECK: %opaque = type opaque
 // CHECK: %long = type { i32, { i32, i1 }, float, ptr }
 // CHECK: %self-recursive = type { ptr }