[mlir] initial support for opaque pointers in the LLVM dialect

[ftynse]

Summary

LLVM IR has introduced and is moving forward with the concept of opaque
pointers, i.e. pointer types that are not carrying around the pointee type.
Instead, memory-related operations indicate the type of the data being accessed
through the opaque pointer. Introduce the initial support for opaque pointers
in the LLVM dialect:

• LLVMPointerType to support omitting the element type;
• alloca/load/store/gep to support opaque pointers in their operands and results; this requires alloca and gep to store the element type as an attribute;
• memory-related intrinsics to support opaque pointers in their operands;
• translation to LLVM IR for the ops above is no longer using methods deprecated in LLVM API due to the introduction of opaque pointers.

Unlike LLVM IR, MLIR can afford to support both opaque and non-opaque pointers
at the same time and simplify the transition. Translation to LLVM IR of MLIR
that involves opaque pointers requires the LLVMContext to be configured to
always use opaque pointers.

[ftynse]

git add tests

[nikic]

Thanks for working on this! Not really familiar with MLIR, so can't do much useful review here.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

327

$ptr_type seems a bit confusing here, maybe $elem_type?

348

Do we need to look through vectors here?

Or actually, should this be using the new getSourceElementType() method?

mlir/test/Dialect/LLVMIR/opaque-ptr.mlir

5

Unnecessary %arg1 argument.

[ftynse]

Address review.

[ftynse]

In D123310#3445610, @nikic wrote:

Thanks for working on this! Not really familiar with MLIR, so can't do much useful review here.

If the use of opaque pointers looks reasonable to you, this is all I need.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

348

Good catch, thanks! Forgot that I added it.

[wsmoses]

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

303

Perhaps it's better to do the ternary before the getElementType? While this works for now, if for some reason opaque pointers mean LLVMPointerType isn't guaranteed to have an element type, this may error?

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

792

Should this not also check that the pointertype is not opaque?

Edit: Ah nevermind, I see that the convention is that the first argument is the value type, if there are two types.

I do think there's a bug here though -- namely what if the value you're storing is itself a pointertype. You can never hit the else.

[ftynse]

Address review.

[ftynse]

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

792

Very nice catch, thanks!

mlir/docs/Dialects/LLVM.md

 LLVM dialect uses built-in types whenever possible and defines a set of
 complementary types, which correspond to the LLVM IR types that cannot be
 directly represented with built-in types. Similarly to other MLIR context-owned
 objects, the creation and manipulation of LLVM dialect types is thread-safe.
 
 MLIR does not support module-scoped named type declarations, e.g. `%s = type
 {i32, i32}` in LLVM IR. Instead, types must be fully specified at each use,
 except for recursive types where only the first reference to a named type needs
-to be fully specified. MLIR [type aliases](../LangRef.md/#type-aliases) can be used
-to achieve more compact syntax.
+to be fully specified. MLIR [type aliases](../LangRef.md/#type-aliases) can be
+used to achieve more compact syntax.
 
 The general syntax of LLVM dialect types is `!llvm.`, followed by a type kind
 identifier (e.g., `ptr` for pointer or `struct` for structure) and by an
 optional list of type parameters in angle brackets. The dialect follows MLIR
 style for types with nested angle brackets and keyword specifiers rather than
 using different bracket styles to differentiate types. Types inside the angle
 brackets may omit the `!llvm.` prefix for brevity: the parser first attempts to
 find a type (starting with `!` or a built-in type) and falls back to accepting a

 
 These types are parameterized by the types they contain, e.g., the pointee or
 the element type, which can be either compatible built-in or LLVM dialect types.
 
 #### Pointer Types
 
 Pointer types specify an address in memory.
 
-Pointer types are parametric types parameterized by the element type and the
-address space. The address space is an integer, but this choice may be
-reconsidered if MLIR implements named address spaces. Their syntax is as
-follows:
-
-```
-  llvm-ptr-type ::= `!llvm.ptr<` type (`,` integer-literal)? `>`
-```
-
-where the optional integer literal corresponds to the memory space. Both cases
-are represented by `LLVMPointerType` internally.
+Both opaque and type-parameterized pointer types are supported.
+[Opaque pointers](https://llvm.org/docs/OpaquePointers.html) do not indicate the
+type of the data pointed to, and are intended to simplify LLVM IR by encoding
+behavior relevant to the pointee type into operations rather than into types.
+Non-opaque pointer types carry the pointee type as a type parameter. Both kinds
+of pointers may be additionally parameterized by an address space. The address
+space is an integer, but this choice may be reconsidered if MLIR implements
+named address spaces. The syntax of pointer types is as follows:
+
+```
+  llvm-ptr-type ::= `!llvm.ptr` (`<` integer-literal `>`)?
+                  | `!llvm.ptr<` type (`,` integer-literal)? `>`
+```
+
+where the former case is the opaque pointer type and the latter case is the
+non-opaque pointer type; the optional group containing the integer literal
+corresponds to the memory space. All cases are represented by `LLVMPointerType`
+internally.
 
 #### Array Types
 
 Array types represent sequences of elements in memory. Array elements can be
 addressed with a value unknown at compile time, and can be nested. Only 1D
 arrays are allowed though.
 
 Array types are parameterized by the fixed size and the element type.

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

 // Type constraint accepting any LLVM pointer type.
 def LLVM_AnyPointer : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMPointerType>()">,
                           "LLVM pointer type">;
 
 // Type constraint accepting LLVM pointer type with an additional constraint
 // on the element type.
 class LLVM_PointerTo<Type pointee> : Type<
   And<[LLVM_AnyPointer.predicate,
+       Or<[CPred<"$_self.cast<::mlir::LLVM::LLVMPointerType>().isOpaque()">,
            SubstLeaves<
              "$_self",
              "$_self.cast<::mlir::LLVM::LLVMPointerType>().getElementType()",
-         pointee.predicate>]>,
+             pointee.predicate>]>]>,
   "LLVM pointer to " # pointee.summary>;
 
 // Type constraints accepting LLVM pointer type to integer of a specific width.
 class LLVM_IntPtrBase<int width, int addressSpace = 0> : Type<
   LLVM_PointerTo<I<width>>.predicate,
   "LLVM pointer to " # I<width>.summary>,
   BuildableType<"::mlir::LLVM::LLVMPointerType::get("
                 "::mlir::IntegerType::get($_builder.getContext(), "

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

class MemoryOpWithAlignmentAndAttributes : MemoryOpWithAlignmentBase {
   code setAliasScopeMetadataCode = [{
     moduleTranslation.setAliasScopeMetadata(op, inst);
   }];
 }
 
 // Memory-related operations.
 def LLVM_AllocaOp : LLVM_Op<"alloca">, MemoryOpWithAlignmentBase {
   let arguments = (ins AnyInteger:$arraySize,
-                   OptionalAttr<I64Attr>:$alignment);
-  let results = (outs Res<LLVM_AnyPointer, "", [MemAlloc<AutomaticAllocationScopeResource>]>:$res);
+                   OptionalAttr<I64Attr>:$alignment,
+                   OptionalAttr<TypeAttr>:$elem_type);
+  let results = (outs Res<LLVM_AnyPointer, "",
+                          [MemAlloc<AutomaticAllocationScopeResource>]>:$res);
   string llvmBuilder = [{
     auto addrSpace = $_resultType->getPointerAddressSpace();
-    auto *inst = builder.CreateAlloca(
-        $_resultType->getPointerElementType(), addrSpace, $arraySize);
+    llvm::Type *elementType = moduleTranslation.convertType(
+        $elem_type ? *$elem_type
+                   : op.getType().cast<LLVMPointerType>().getElementType());
+    auto *inst = builder.CreateAlloca(elementType, addrSpace, $arraySize);
     }] # setAlignmentCode # [{
     $res = inst;
   }];
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$arraySize,
       "unsigned":$alignment),
     [{
       if (alignment == 0)
-        return build($_builder, $_state, resultType, arraySize, IntegerAttr());
+        return build($_builder, $_state, resultType, arraySize, IntegerAttr(),
+                     TypeAttr());
       build($_builder, $_state, resultType, arraySize,
-        $_builder.getI64IntegerAttr(alignment));
+        $_builder.getI64IntegerAttr(alignment), TypeAttr());
   }]>];
   let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 }
 
 def LLVM_GEPOp : LLVM_Op<"getelementptr", [NoSideEffect]> {
   let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$base,
                    Variadic<LLVM_ScalarOrVectorOf<AnyInteger>>:$indices,
-                   I32ElementsAttr:$structIndices);
+                   I32ElementsAttr:$structIndices,
+                   OptionalAttr<TypeAttr>:$elem_type);
   let results = (outs LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$res);
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$basePtr, "ValueRange":$indices,
                CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "Type":$resultType, "Value":$basePtr, "ValueRange":$indices,
                "ArrayRef<int32_t>":$structIndices,
                CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
   ];
   let llvmBuilder = [{
     SmallVector<llvm::Value *> indices;
     indices.reserve($structIndices.size());
     unsigned operandIdx = 0;
     for (int32_t structIndex : $structIndices.getValues<int32_t>()) {
       if (structIndex == GEPOp::kDynamicIndex)
         indices.push_back($indices[operandIdx++]);
       else
         indices.push_back(builder.getInt32(structIndex));
     }
-    $res = builder.CreateGEP(
-      $base->getType()->getPointerElementType(), $base, indices);
+    Type baseElementType = op.getSourceElementType();
+    llvm::Type *elementType = moduleTranslation.convertType(baseElementType);
+    $res = builder.CreateGEP(elementType, $base, indices);
   }];
   let assemblyFormat = [{
     $base `[` custom<GEPIndices>($indices, $structIndices) `]` attr-dict
-    `:` functional-type(operands, results)
+    `:` functional-type(operands, results) (`,` $elem_type^)?
   }];
 
   let extraClassDeclaration = [{
     constexpr static int kDynamicIndex = std::numeric_limits<int32_t>::min();
+    Type getSourceElementType();
   }];
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def LLVM_LoadOp : LLVM_Op<"load">, MemoryOpWithAlignmentAndAttributes {
   let arguments = (ins Arg<LLVM_PointerTo<LLVM_LoadableType>, "", [MemRead]>:$addr,
                    OptionalAttr<SymbolRefArrayAttr>:$access_groups,
                    OptionalAttr<SymbolRefArrayAttr>:$alias_scopes,
                    OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes,
                    OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
                    UnitAttr:$nontemporal);
   let results = (outs LLVM_LoadableType:$res);
   string llvmBuilder = [{
-    auto *inst = builder.CreateLoad(
-      $addr->getType()->getPointerElementType(), $addr, $volatile_);
+    auto *inst = builder.CreateLoad($_resultType, $addr, $volatile_);
   }] # setAlignmentCode
      # setNonTemporalMetadataCode
      # setAccessGroupsMetadataCode
      # setAliasScopeMetadataCode
      # [{
     $res = inst;
   }];
   let builders = [
     OpBuilder<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
       CArg<"bool", "false">:$isVolatile, CArg<"bool", "false">:$isNonTemporal),
     [{
       auto type = addr.getType().cast<LLVMPointerType>().getElementType();
+      assert(type && "must provide explicit element type to the constructor "
+                     "when the pointer type is opaque");
       build($_builder, $_state, type, addr, alignment, isVolatile, isNonTemporal);
     }]>,
     OpBuilder<(ins "Type":$t, "Value":$addr,
       CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
-      CArg<"bool", "false">:$isNonTemporal)>];
+      CArg<"bool", "false">:$isNonTemporal)>,];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def LLVM_StoreOp : LLVM_Op<"store">, MemoryOpWithAlignmentAndAttributes {
   let arguments = (ins LLVM_LoadableType:$value,
                    Arg<LLVM_PointerTo<LLVM_LoadableType>,"",[MemWrite]>:$addr,
                    OptionalAttr<SymbolRefArrayAttr>:$access_groups,

 /// data       - Start address of the matrix read
 /// rows       - Number of rows in matrix (must be a constant)
 /// isVolatile - True if the load operation is marked as volatile.
 /// columns    - Number of columns in matrix (must be a constant)
 /// stride     - Space between columns
 def LLVM_MatrixColumnMajorLoadOp : LLVM_Op<"intr.matrix.column.major.load"> {
   let arguments = (ins LLVM_Type:$data, LLVM_Type:$stride, I1Attr:$isVolatile,
                    I32Attr:$rows, I32Attr:$columns);
-  let results = (outs LLVM_Type:$res);
+  let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     const llvm::DataLayout &dl =
       builder.GetInsertBlock()->getModule()->getDataLayout();
-    llvm::Type *ElemTy = $data->getType()->getPointerElementType();
+    llvm::Type *ElemTy = moduleTranslation.convertType(
+        getVectorElementType(op.getType()));
     llvm::Align align = dl.getABITypeAlign(ElemTy);
     $res = mb.CreateColumnMajorLoad(
       ElemTy, $data, align, $stride, $isVolatile, $rows,
       $columns);
   }];
   let assemblyFormat = "$data `,` `<` `stride` `=` $stride `>` attr-dict"
     "`:` type($res) `from` type($data) `stride` type($stride)";
 }
 
 /// Create a column major, strided 2-D matrix store, as specified in the LLVM
 /// MatrixBuilder.
 /// matrix     - Matrix to store
 /// ptr        - Pointer to write back to
 /// isVolatile - True if the load operation is marked as volatile.
 /// rows       - Number of rows in matrix (must be a constant)
 /// columns    - Number of columns in matrix (must be a constant)
 /// stride     - Space between columns
 def LLVM_MatrixColumnMajorStoreOp : LLVM_Op<"intr.matrix.column.major.store"> {
-  let arguments = (ins LLVM_Type:$matrix, LLVM_Type:$data, LLVM_Type:$stride,
-                   I1Attr:$isVolatile, I32Attr:$rows, I32Attr:$columns);
+  let arguments = (ins LLVM_AnyVector:$matrix, LLVM_Type:$data,
+                   LLVM_Type:$stride, I1Attr:$isVolatile, I32Attr:$rows,
+                   I32Attr:$columns);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     const llvm::DataLayout &dl =
       builder.GetInsertBlock()->getModule()->getDataLayout();
+    Type elementType = getVectorElementType(op.getMatrix().getType());
     llvm::Align align = dl.getABITypeAlign(
-      $data->getType()->getPointerElementType());
+      moduleTranslation.convertType(elementType));
     mb.CreateColumnMajorStore(
       $matrix, $data, align, $stride, $isVolatile,
       $rows, $columns);
   }];
   let assemblyFormat = "$matrix `,` $data `,` `<` `stride` `=` $stride `>` "
     "attr-dict`:` type($matrix) `to` type($data) `stride` type($stride)";
 }
 
def LLVM_GetActiveLaneMaskOp
   let assemblyFormat = "$base `,` $n attr-dict `:` "
     "type($base) `,` type($n) `to` type($res)";
 }
 
 /// Create a call to Masked Load intrinsic.
 def LLVM_MaskedLoadOp : LLVM_Op<"intr.masked.load"> {
   let arguments = (ins LLVM_Type:$data, LLVM_Type:$mask,
                    Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
-  let results = (outs LLVM_Type:$res);
-  let builders = [LLVM_OneResultOpBuilder];
+  let results = (outs LLVM_AnyVector:$res);
   string llvmBuilder = [{
-    llvm::Type *Ty = $data->getType()->getPointerElementType();
     $res = $pass_thru.empty() ? builder.CreateMaskedLoad(
-      Ty, $data, llvm::Align($alignment), $mask) :
+        $_resultType, $data, llvm::Align($alignment), $mask) :
       builder.CreateMaskedLoad(
-        Ty, $data, llvm::Align($alignment), $mask, $pass_thru[0]);
+        $_resultType, $data, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 }
 
 /// Create a call to Masked Store intrinsic.
 def LLVM_MaskedStoreOp : LLVM_Op<"intr.masked.store"> {
   let arguments = (ins LLVM_Type:$value, LLVM_Type:$data, LLVM_Type:$mask,
                    I32Attr:$alignment);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   string llvmBuilder = [{
     builder.CreateMaskedStore(
       $value, $data, llvm::Align($alignment), $mask);
   }];
   let assemblyFormat = "$value `,` $data `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` type($data)";
 }
 
 /// Create a call to Masked Gather intrinsic.
 def LLVM_masked_gather : LLVM_Op<"intr.masked.gather"> {
-  let arguments = (ins LLVM_Type:$ptrs, LLVM_Type:$mask,
+  let arguments = (ins LLVM_AnyVector:$ptrs, LLVM_Type:$mask,
                    Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   string llvmBuilder = [{
-    llvm::VectorType *PtrVecTy = cast<llvm::VectorType>($ptrs->getType());
-    llvm::Type *Ty = llvm::VectorType::get(
-      PtrVecTy->getElementType()->getPointerElementType(),
-      PtrVecTy->getElementCount());
     $res = $pass_thru.empty() ? builder.CreateMaskedGather(
-      Ty, $ptrs, llvm::Align($alignment), $mask) :
+        $_resultType, $ptrs, llvm::Align($alignment), $mask) :
       builder.CreateMaskedGather(
-        Ty, $ptrs, llvm::Align($alignment), $mask, $pass_thru[0]);
+        $_resultType, $ptrs, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 }
 
 /// Create a call to Masked Scatter intrinsic.
 def LLVM_masked_scatter : LLVM_Op<"intr.masked.scatter"> {
   let arguments = (ins LLVM_Type:$value, LLVM_Type:$ptrs, LLVM_Type:$mask,

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                               Type result, ArrayRef<Type> arguments, bool);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMPointerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect pointer type. This type typically represents a reference to an
-/// object in memory. It is parameterized by the element type and the address
-/// space.
+/// object in memory. Pointers may be opaque or parameterized by the element
+/// type. Both opaque and non-opaque pointers are additionally parameterized by
+/// the address space.
 class LLVMPointerType : public Type::TypeBase<LLVMPointerType, Type,
                                               detail::LLVMPointerTypeStorage,
                                               DataLayoutTypeInterface::Trait> {
 public:
   /// Inherit base constructors.
   using Base::Base;
-  using Base::getChecked;
 
   /// Checks if the given type can have a pointer type pointing to it.
   static bool isValidElementType(Type type);
 
   /// Gets or creates an instance of LLVM dialect pointer type pointing to an
   /// object of `pointee` type in the given address space. The pointer type is
-  /// created in the same context as `pointee`.
+  /// created in the same context as `pointee`. If the pointee is not provided,
+  /// creates an opaque pointer in the given context and address space.
+  static LLVMPointerType get(MLIRContext *context, unsigned addressSpace = 0);
   static LLVMPointerType get(Type pointee, unsigned addressSpace = 0);
   static LLVMPointerType
   getChecked(function_ref<InFlightDiagnostic()> emitError, Type pointee,
              unsigned addressSpace = 0);
+  static LLVMPointerType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, MLIRContext *context,
+             unsigned addressSpace = 0);
 
-  /// Returns the pointed-to type.
+  /// Returns the pointed-to type. It may be null if the pointer is opaque.
   Type getElementType() const;
 
+  /// Returns `true` if this type is the opaque pointer type, i.e., it has no
+  /// pointed-to type.
+  bool isOpaque() const;
+
   /// Returns the address space of the pointer.
   unsigned getAddressSpace() const;
 
   /// Verifies that the type about to be constructed is well-formed.
   static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                               Type pointee, unsigned);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              MLIRContext *context, unsigned) {
+    return success();
+  }
 
   /// Hooks for DataLayoutTypeInterface. Should not be called directly. Obtain a
   /// DataLayout instance and query it instead.
   unsigned getTypeSizeInBits(const DataLayout &dataLayout,
                              DataLayoutEntryListRef params) const;
   unsigned getABIAlignment(const DataLayout &dataLayout,
                            DataLayoutEntryListRef params) const;
   unsigned getPreferredAlignment(const DataLayout &dataLayout,

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

 using namespace mlir;
 using namespace mlir::LLVM;
 using mlir::LLVM::linkage::getMaxEnumValForLinkage;
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsDialect.cpp.inc"
 
 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
+static constexpr const char kElemTypeAttrName[] = "elem_type";
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 
 static auto processFMFAttr(ArrayRef<NamedAttribute> attrs) {
   SmallVector<NamedAttribute, 8> filteredAttrs(
ParseResult ICmpOp::parse(OpAsmParser &parser, OperationState &result) {
   return parseCmpOp<ICmpPredicate>(parser, result);
 }
 
 ParseResult FCmpOp::parse(OpAsmParser &parser, OperationState &result) {
   return parseCmpOp<FCmpPredicate>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
-// Printing/parsing for LLVM::AllocaOp.
+// Printing, parsing and verification for LLVM::AllocaOp.
 //===----------------------------------------------------------------------===//
 
 void AllocaOp::print(OpAsmPrinter &p) {
-  auto elemTy = getType().cast<LLVM::LLVMPointerType>().getElementType();
+  Type elemTy = getType().cast<LLVM::LLVMPointerType>().getElementType();
+  if (!elemTy)
+    elemTy = *getElemType();
 
   auto funcTy =
       FunctionType::get(getContext(), {getArraySize().getType()}, {getType()});
 
   p << ' ' << getArraySize() << " x " << elemTy;
   if (getAlignment().hasValue() && *getAlignment() != 0)
     p.printOptionalAttrDict((*this)->getAttrs());
   else
-    p.printOptionalAttrDict((*this)->getAttrs(), {"alignment"});
+    p.printOptionalAttrDict((*this)->getAttrs(),
+                            {"alignment", kElemTypeAttrName});
   p << " : " << funcTy;
 }
 
 // <operation> ::= `llvm.alloca` ssa-use `x` type attribute-dict?
 //                 `:` type `,` type
 ParseResult AllocaOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::UnresolvedOperand arraySize;
   Type type, elemType;
if (!funcType || funcType.getNumInputs() != 1 ||
       funcType.getNumResults() != 1)
     return parser.emitError(
         trailingTypeLoc,
         "expected trailing function type with one argument and one result");
 
   if (parser.resolveOperand(arraySize, funcType.getInput(0), result.operands))
     return failure();
 
+  Type resultType = funcType.getResult(0);
+  if (auto ptrResultType = resultType.dyn_cast<LLVMPointerType>()) {
+    if (ptrResultType.isOpaque())
+      result.addAttribute(kElemTypeAttrName, TypeAttr::get(elemType));
+  }
+
   result.addTypes({funcType.getResult(0)});
   return success();
 }
 
+/// Checks that the elemental type is present in either the pointer type or
+/// the attribute, but not both.
+static LogicalResult verifyOpaquePtr(Operation *op, LLVMPointerType ptrType,
+                                     Optional<Type> ptrElementType) {
+  if (ptrType.isOpaque() && !ptrElementType.hasValue()) {
+    return op->emitOpError() << "expected '" << kElemTypeAttrName
+                             << "' attribute if opaque pointer type is used";
+  }
+  if (!ptrType.isOpaque() && ptrElementType.hasValue()) {
+    return op->emitOpError()
+           << "unexpected '" << kElemTypeAttrName
+           << "' attribute when non-opaque pointer type is used";
+  }
+  return success();
+}
+
+LogicalResult AllocaOp::verify() {
+  return verifyOpaquePtr(getOperation(), getType().cast<LLVMPointerType>(),
+                         getElemType());
+}
+
 //===----------------------------------------------------------------------===//
 // LLVM::BrOp
 //===----------------------------------------------------------------------===//
 
 SuccessorOperands BrOp::getSuccessorOperands(unsigned index) {
   assert(index == 0 && "invalid successor index");
   return SuccessorOperands(getDestOperandsMutable());
 }

 }
 
 /// Populates `indices` with positions of GEP indices that correspond to
 /// LLVMStructTypes potentially nested in the given `baseGEPType`, which must
 /// be either an LLVMPointer type or a vector thereof. If `structSizes` is
 /// provided, it is populated with sizes of the indexed structs for bounds
 /// verification purposes.
 static void
-findKnownStructIndices(Type baseGEPType, SmallVectorImpl<unsigned> &indices,
+findKnownStructIndices(Type sourceElementType,
+                       SmallVectorImpl<unsigned> &indices,
                        SmallVectorImpl<unsigned> *structSizes = nullptr) {
-  Type type = baseGEPType;
-  if (auto vectorType = type.dyn_cast<VectorType>())
-    type = vectorType.getElementType();
-  if (auto scalableVectorType = type.dyn_cast<LLVMScalableVectorType>())
-    type = scalableVectorType.getElementType();
-  if (auto fixedVectorType = type.dyn_cast<LLVMFixedVectorType>())
-    type = fixedVectorType.getElementType();
-
-  Type pointeeType = type.cast<LLVMPointerType>().getElementType();
   SmallPtrSet<Type, 4> visited;
-  recordStructIndices(pointeeType, /*currentIndex=*/1, indices, structSizes,
-                      visited);
+  recordStructIndices(sourceElementType, /*currentIndex=*/1, indices,
+                      structSizes, visited);
 }
 
 void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
                   Value basePtr, ValueRange operands,
                   ArrayRef<NamedAttribute> attributes) {
   build(builder, result, resultType, basePtr, operands,
         SmallVector<int32_t>(operands.size(), LLVM::GEPOp::kDynamicIndex),
         attributes);
 }
 
+/// Returns the elemental type of any LLVM-compatible vector type or self.
+static Type extractVectorElementType(Type type) {
+  if (auto vectorType = type.dyn_cast<VectorType>())
+    return vectorType.getElementType();
+  if (auto scalableVectorType = type.dyn_cast<LLVMScalableVectorType>())
+    return scalableVectorType.getElementType();
+  if (auto fixedVectorType = type.dyn_cast<LLVMFixedVectorType>())
+    return fixedVectorType.getElementType();
+  return type;
+}
+
 void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
                   Value basePtr, ValueRange indices,
                   ArrayRef<int32_t> structIndices,
                   ArrayRef<NamedAttribute> attributes) {
   SmallVector<Value> remainingIndices;
   SmallVector<int32_t> updatedStructIndices(structIndices.begin(),
                                             structIndices.end());
   SmallVector<unsigned> structRelatedPositions;
-  findKnownStructIndices(basePtr.getType(), structRelatedPositions);
+  auto ptrType =
+      extractVectorElementType(basePtr.getType()).cast<LLVMPointerType>();
+  assert(!ptrType.isOpaque() && "expected non-opaque pointer");
+  findKnownStructIndices(ptrType.getElementType(), structRelatedPositions);
 
   SmallVector<unsigned> operandsToErase;
   for (unsigned pos : structRelatedPositions) {
     // GEP may not be indexing as deep as some structs are located.
     if (pos >= structIndices.size())
       continue;
 
     // If the index is already static, it's fine.
llvm::interleaveComma(structIndices.getValues<int32_t>(), printer,
                           if (cst == LLVM::GEPOp::kDynamicIndex)
                             printer.printOperand(indices[operandIdx++]);
                           else
                             printer << cst;
                         });
 }
 
 LogicalResult LLVM::GEPOp::verify() {
+  if (failed(verifyOpaquePtr(
+          getOperation(),
+          extractVectorElementType(getType()).cast<LLVMPointerType>(),
+          getElemType())))
+    return failure();
+
   SmallVector<unsigned> indices;
   SmallVector<unsigned> structSizes;
-  findKnownStructIndices(getBase().getType(), indices, &structSizes);
+  findKnownStructIndices(getSourceElementType(), indices, &structSizes);
   DenseIntElementsAttr structIndices = getStructIndices();
   for (unsigned i : llvm::seq<unsigned>(0, indices.size())) {
     unsigned index = indices[i];
     // GEP may not be indexing as deep as some structs nested in the type.
     if (index >= structIndices.getNumElements())
       continue;
 
     int32_t staticIndex = structIndices.getValues<int32_t>()[index];
     if (staticIndex == LLVM::GEPOp::kDynamicIndex)
       return emitOpError() << "expected index " << index
                            << " indexing a struct to be constant";
     if (staticIndex < 0 || static_cast<unsigned>(staticIndex) >= structSizes[i])
       return emitOpError() << "index " << index
                            << " indexing a struct is out of bounds";
   }
   return success();
 }
 
+Type LLVM::GEPOp::getSourceElementType() {
+  if (Optional<Type> elemType = getElemType())
+    return *elemType;
+
+  return extractVectorElementType(getBase().getType())
+      .cast<LLVMPointerType>()
+      .getElementType();
+}
+
 //===----------------------------------------------------------------------===//
 // Builder, printer and parser for for LLVM::LoadOp.
 //===----------------------------------------------------------------------===//
 
 LogicalResult verifySymbolAttribute(
     Operation *op, StringRef attributeName,
     llvm::function_ref<LogicalResult(Operation *, SymbolRefAttr)>
         verifySymbolType) {
if (alignment != 0)
     result.addAttribute("alignment", builder.getI64IntegerAttr(alignment));
 }
 
 void LoadOp::print(OpAsmPrinter &p) {
   p << ' ';
   if (getVolatile_())
     p << "volatile ";
   p << getAddr();
-  p.printOptionalAttrDict((*this)->getAttrs(), {kVolatileAttrName});
+  p.printOptionalAttrDict((*this)->getAttrs(),
+                          {kVolatileAttrName, kElemTypeAttrName});
   p << " : " << getAddr().getType();
+  if (getAddr().getType().cast<LLVMPointerType>().isOpaque())
+    p << " -> " << getType();
 }
 
-// Extract the pointee type from the LLVM pointer type wrapped in MLIR.  Return
-// the resulting type wrapped in MLIR, or nullptr on error.
-static Type getLoadStoreElementType(OpAsmParser &parser, Type type,
+// Extract the pointee type from the LLVM pointer type wrapped in MLIR. Return
+// the resulting type if any, null type if opaque pointers are used, and None
+// if the given type is not the pointer type.
+static Optional<Type> getLoadStoreElementType(OpAsmParser &parser, Type type,
                                               SMLoc trailingTypeLoc) {
   auto llvmTy = type.dyn_cast<LLVM::LLVMPointerType>();
-  if (!llvmTy)
-    return parser.emitError(trailingTypeLoc, "expected LLVM pointer type"),
-           nullptr;
+  if (!llvmTy) {
+    parser.emitError(trailingTypeLoc, "expected LLVM pointer type");
+    return llvm::None;
+  }
   return llvmTy.getElementType();
 }
 
 // <operation> ::= `llvm.load` `volatile` ssa-use attribute-dict? `:` type
+//                 (`->` type)?
 ParseResult LoadOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::UnresolvedOperand addr;
   Type type;
   SMLoc trailingTypeLoc;
 
   if (succeeded(parser.parseOptionalKeyword("volatile")))
     result.addAttribute(kVolatileAttrName, parser.getBuilder().getUnitAttr());
 
   if (parser.parseOperand(addr) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type) ||
       parser.resolveOperand(addr, type, result.operands))
     return failure();
 
-  Type elemTy = getLoadStoreElementType(parser, type, trailingTypeLoc);
+  Optional<Type> elemTy =
+      getLoadStoreElementType(parser, type, trailingTypeLoc);
+  if (!elemTy)
+    return failure();
+  if (*elemTy) {
+    result.addTypes(*elemTy);
+    return success();
+  }
 
-  result.addTypes(elemTy);
+  Type trailingType;
+  if (parser.parseArrow() || parser.parseType(trailingType))
+    return failure();
+  result.addTypes(trailingType);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Builder, printer and parser for LLVM::StoreOp.
 //===----------------------------------------------------------------------===//
 
 LogicalResult StoreOp::verify() { return verifyMemoryOpMetadata(*this); }

 }
 
 void StoreOp::print(OpAsmPrinter &p) {
   p << ' ';
   if (getVolatile_())
     p << "volatile ";
   p << getValue() << ", " << getAddr();
   p.printOptionalAttrDict((*this)->getAttrs(), {kVolatileAttrName});
-  p << " : " << getAddr().getType();
+  p << " : ";
+  if (getAddr().getType().cast<LLVMPointerType>().isOpaque())
+    p << getValue().getType() << ", ";
+  p << getAddr().getType();
 }
 
 // <operation> ::= `llvm.store` `volatile` ssa-use `,` ssa-use
-//                 attribute-dict? `:` type
+//                 attribute-dict? `:` type (`,` type)?
 ParseResult StoreOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::UnresolvedOperand addr, value;
   Type type;
   SMLoc trailingTypeLoc;
 
   if (succeeded(parser.parseOptionalKeyword("volatile")))
     result.addAttribute(kVolatileAttrName, parser.getBuilder().getUnitAttr());
 
   if (parser.parseOperand(value) || parser.parseComma() ||
       parser.parseOperand(addr) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type))
     return failure();
 
-  Type elemTy = getLoadStoreElementType(parser, type, trailingTypeLoc);
-  if (!elemTy)
+  Type operandType;
+  if (succeeded(parser.parseOptionalComma())) {
+    operandType = type;
+    if (parser.parseType(type))
       return failure();
+  } else {
+    Optional<Type> maybeOperandType =
+        getLoadStoreElementType(parser, type, trailingTypeLoc);
+    if (!maybeOperandType)
+      return failure();
+    operandType = *maybeOperandType;
+  }
 
-  if (parser.resolveOperand(value, elemTy, result.operands) ||
+  if (parser.resolveOperand(value, operandType, result.operands) ||
       parser.resolveOperand(addr, type, result.operands))
     return failure();
 
   return success();
 }
 
 ///===---------------------------------------------------------------------===//
 /// LLVM::InvokeOp

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

void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
   if (!type) {
     printer << "<<NULL-TYPE>>";
     return;
   }
 
   printer << getTypeKeyword(type);
 
   if (auto ptrType = type.dyn_cast<LLVMPointerType>()) {
+    if (ptrType.isOpaque()) {
+      if (ptrType.getAddressSpace() != 0)
+        printer << '<' << ptrType.getAddressSpace() << '>';
+      return;
+    }
+
     printer << '<';
     dispatchPrint(printer, ptrType.getElementType());
     if (ptrType.getAddressSpace() != 0)
       printer << ", " << ptrType.getAddressSpace();
     printer << '>';
     return;
   }
 
static LLVMFunctionType parseFunctionType(AsmParser &parser) {
   if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
     return LLVMFunctionType();
   return parser.getChecked<LLVMFunctionType>(loc, returnType, argTypes,
                                              /*isVarArg=*/false);
 }
 
 /// Parses an LLVM dialect pointer type.
 ///   llvm-type ::= `ptr<` llvm-type (`,` integer)? `>`
+///               | `ptr` (`<` integer `>`)?
 static LLVMPointerType parsePointerType(AsmParser &parser) {
   SMLoc loc = parser.getCurrentLocation();
   Type elementType;
-  if (parser.parseLess() || dispatchParse(parser, elementType))
-    return LLVMPointerType();
+  if (parser.parseOptionalLess()) {
+    return parser.getChecked<LLVMPointerType>(loc, parser.getContext(),
+                                              /*addressSpace=*/0);
+  }
 
   unsigned addressSpace = 0;
+  OptionalParseResult opr = parser.parseOptionalInteger(addressSpace);
+  if (opr.hasValue()) {
+    if (failed(*opr) || parser.parseGreater())
+      return LLVMPointerType();
+    return parser.getChecked<LLVMPointerType>(loc, parser.getContext(),
+                                              addressSpace);
+  }
+
+  if (dispatchParse(parser, elementType))
+    return LLVMPointerType();
+
   if (succeeded(parser.parseOptionalComma()) &&
       failed(parser.parseInteger(addressSpace)))
     return LLVMPointerType();
   if (failed(parser.parseGreater()))
     return LLVMPointerType();
   return parser.getChecked<LLVMPointerType>(loc, elementType, addressSpace);
 }
 

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

LLVMFunctionType::verify(function_ref<InFlightDiagnostic()> emitError,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMPointerType::isValidElementType(Type type) {
+  if (!type)
+    return true;
   return isCompatibleOuterType(type)
              ? !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
                          LLVMLabelType>()
              : type.isa<PointerElementTypeInterface>();
 }
 
 LLVMPointerType LLVMPointerType::get(Type pointee, unsigned addressSpace) {
-  assert(pointee && "expected non-null subtype");
+  assert(pointee && "expected non-null subtype, pass the context instead if "
+                    "the opaque pointer type is desired");
   return Base::get(pointee.getContext(), pointee, addressSpace);
 }
 
+LLVMPointerType LLVMPointerType::get(MLIRContext *context,
+                                     unsigned addressSpace) {
+  return Base::get(context, Type(), addressSpace);
+}
+
 LLVMPointerType
 LLVMPointerType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                             Type pointee, unsigned addressSpace) {
   return Base::getChecked(emitError, pointee.getContext(), pointee,
                           addressSpace);
 }
 
+LLVMPointerType
+LLVMPointerType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                            MLIRContext *context, unsigned addressSpace) {
+  return Base::getChecked(emitError, context, Type(), addressSpace);
+}
+
 Type LLVMPointerType::getElementType() const { return getImpl()->pointeeType; }
 
+bool LLVMPointerType::isOpaque() const { return !getImpl()->pointeeType; }
+
 unsigned LLVMPointerType::getAddressSpace() const {
   return getImpl()->addressSpace;
 }
 
 LogicalResult
 LLVMPointerType::verify(function_ref<InFlightDiagnostic()> emitError,
                         Type pointee, unsigned) {
   if (!isValidElementType(pointee))
return llvm::TypeSwitch<Type, bool>(type)
       .Case<LLVMFunctionType>([&](auto funcType) {
         return isCompatible(funcType.getReturnType()) &&
                llvm::all_of(funcType.getParams(), isCompatible);
       })
       .Case<IntegerType>([](auto intType) { return intType.isSignless(); })
       .Case<VectorType>([&](auto vecType) {
         return vecType.getRank() == 1 && isCompatible(vecType.getElementType());
       })
+      .Case<LLVMPointerType>([&](auto pointerType) {
+        if (pointerType.isOpaque())
+          return true;
+        return isCompatible(pointerType.getElementType());
+      })
       // clang-format off
       .Case<
-          LLVMPointerType,
           LLVMFixedVectorType,
           LLVMScalableVectorType,
           LLVMArrayType
       >([&](auto containerType) {
         return isCompatible(containerType.getElementType());
       })
       .Case<
         BFloat16Type,

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

private:
   const Type *argumentTypes;
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMPointerTypeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Storage type for LLVM dialect pointer types. These are uniqued by a pair of
-/// element type and address space.
+/// element type and address space. The element type may be null indicating that
+/// the pointer is opaque.
 struct LLVMPointerTypeStorage : public TypeStorage {
   using KeyTy = std::tuple<Type, unsigned>;
 
   LLVMPointerTypeStorage(const KeyTy &key)
       : pointeeType(std::get<0>(key)), addressSpace(std::get<1>(key)) {}
 
   static LLVMPointerTypeStorage *construct(TypeStorageAllocator &allocator,
                                            const KeyTy &key) {

mlir/lib/Target/LLVMIR/TypeToLLVM.cpp

private:
 
   /// Translates the given integer type.
   llvm::Type *translate(IntegerType type) {
     return llvm::IntegerType::get(context, type.getWidth());
   }
 
   /// Translates the given pointer type.
   llvm::Type *translate(LLVM::LLVMPointerType type) {
+    if (type.isOpaque())
+      return llvm::PointerType::get(context, type.getAddressSpace());
     return llvm::PointerType::get(translateType(type.getElementType()),
                                   type.getAddressSpace());
   }
 
   /// Translates the given structure type, supports both identified and literal
   /// structs. This will _create_ a new identified structure every time, use
   /// `convertType` if a structure with the same name must be looked up instead.
   llvm::Type *translate(LLVM::LLVMStructType type) {

mlir/test/Dialect/LLVMIR/invalid.mlir

 
 func @alloca_non_integer_alignment() {
   // expected-error@+1 {{expected integer alignment}}
   llvm.alloca %size x i32 {alignment = 3.0} : !llvm.ptr<i32>
 }
 
 // -----
 
+func @alloca_opaque_ptr_no_type(%sz : i64) {
+  // expected-error@below {{expected 'elem_type' attribute if opaque pointer type is used}}
+  "llvm.alloca"(%sz) : (i64) -> !llvm.ptr
+}
+
+// -----
+
+func @alloca_ptr_type_attr_non_opaque_ptr(%sz : i64) {
+  // expected-error@below {{unexpected 'elem_type' attribute when non-opaque pointer type is used}}
+  "llvm.alloca"(%sz) { elem_type = i32 } : (i64) -> !llvm.ptr<i32>
+}
+
+// -----
+
 func @gep_missing_input_result_type(%pos : i64, %base : !llvm.ptr<f32>) {
   // expected-error@+1 {{2 operands present, but expected 0}}
   llvm.getelementptr %base[%pos] : () -> ()
 }
 
 // -----
 
 func @gep_missing_input_type(%pos : i64, %base : !llvm.ptr<f32>) {

 
 func @store_non_ptr_type(%foo : f32, %bar : f32) {
   // expected-error@+1 {{expected LLVM pointer type}}
   llvm.store %bar, %foo : f32
 }
 
 // -----
 
+func @store_malformed_elem_type(%foo: !llvm.ptr, %bar: f32) {
+  // expected-error@+1 {{expected non-function type}}
+  llvm.store %bar, %foo : !llvm.ptr, "f32"
+}
+
+// -----
+
 func @call_non_function_type(%callee : !llvm.func<i8 (i8)>, %arg : i8) {
   // expected-error@+1 {{expected function type}}
   llvm.call %callee(%arg) : !llvm.func<i8 (i8)>
 }
 
 // -----
 
 func @invalid_call() {

mlir/test/Dialect/LLVMIR/opaque-ptr.mlir

+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+// CHECK-LABEL: @opaque_ptr_load
+llvm.func @opaque_ptr_load(%arg0: !llvm.ptr) -> i32 {
+  // CHECK: = llvm.load %{{.*}} : !llvm.ptr -> i32
+  %0 = llvm.load %arg0 : !llvm.ptr -> i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: @opaque_ptr_store
+llvm.func @opaque_ptr_store(%arg0: i32, %arg1: !llvm.ptr){
+  // CHECK: llvm.store %{{.*}}, %{{.*}} : i32, !llvm.ptr
+  llvm.store %arg0, %arg1 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: @opaque_ptr_ptr_store
+llvm.func @opaque_ptr_ptr_store(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
+  // CHECK: llvm.store %{{.*}}, %{{.*}} : !llvm.ptr, !llvm.ptr
+  llvm.store %arg0, %arg1 : !llvm.ptr, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: @opaque_ptr_alloca
+llvm.func @opaque_ptr_alloca(%arg0: i32) -> !llvm.ptr {
+  // CHECK: llvm.alloca %{{.*}} x f32 : (i32) -> !llvm.ptr
+  %0 = llvm.alloca %arg0 x f32 : (i32) -> !llvm.ptr
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_gep
+llvm.func @opaque_ptr_gep(%arg0: !llvm.ptr, %arg1: i32) -> !llvm.ptr {
+  // CHECK: = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i32) -> !llvm.ptr, f32
+  %0 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr, i32) -> !llvm.ptr, f32
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_gep_struct
+llvm.func @opaque_ptr_gep_struct(%arg0: !llvm.ptr, %arg1: i32) -> !llvm.ptr {
+  // CHECK: = llvm.getelementptr %{{.*}}[%{{.*}}, 0, 1]
+  // CHECK: : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(struct<(f32, f64)>, struct<(i32, i64)>)>
+  %0 = llvm.getelementptr %arg0[%arg1, 0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(struct<(f32, f64)>, struct<(i32, i64)>)>
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_matrix_load_store
+llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector<48 x f32> {
+  // CHECK: = llvm.intr.matrix.column.major.load
+  // CHECK: vector<48xf32> from !llvm.ptr stride i64
+  %0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+    vector<48 x f32> from !llvm.ptr stride i64
+  // CHECK: llvm.intr.matrix.column.major.store
+  // CHECK: vector<48xf32> to !llvm.ptr stride i64
+  llvm.intr.matrix.column.major.store %0, %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+    vector<48 x f32> to !llvm.ptr stride i64
+  llvm.return %0 : vector<48 x f32>
+}
+
+// CHECK-LABEL: @opaque_ptr_masked_load
+llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vector<7xf32> {
+  // CHECK: = llvm.intr.masked.load
+  // CHECK: (!llvm.ptr, vector<7xi1>) -> vector<7xf32>
+  %0 = llvm.intr.masked.load %arg0, %arg1 { alignment = 1: i32} :
+    (!llvm.ptr, vector<7xi1>) -> vector<7xf32>
+  llvm.return %0 : vector<7 x f32>
+}
+
+// CHECK-LABEL: @opaque_ptr_gather
+llvm.func @opaque_ptr_gather(%M: !llvm.vec<7 x ptr>, %mask: vector<7xi1>) -> vector<7xf32> {
+  // CHECK: = llvm.intr.masked.gather
+  // CHECK: (!llvm.vec<7 x ptr>, vector<7xi1>) -> vector<7xf32>
+  %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
+      (!llvm.vec<7 x ptr>, vector<7xi1>) -> vector<7xf32>
+  llvm.return %a : vector<7xf32>
+}

mlir/test/Dialect/LLVMIR/types.mlir

func @ptr() {
   // CHECK: !llvm.ptr<i8>
   "some.op"() : () -> !llvm.ptr<i8, 0>
   // CHECK: !llvm.ptr<i8, 1>
   "some.op"() : () -> !llvm.ptr<i8, 1>
   // CHECK: !llvm.ptr<i8, 42>
   "some.op"() : () -> !llvm.ptr<i8, 42>
   // CHECK: !llvm.ptr<ptr<i8, 42>, 9>
   "some.op"() : () -> !llvm.ptr<ptr<i8, 42>, 9>
+  // CHECK: !llvm.ptr
+  "some.op"() : () -> !llvm.ptr
+  // CHECK: !llvm.ptr<42>
+  "some.op"() : () -> !llvm.ptr<42>
   return
 }
 
 // CHECK-LABEL: @vec
 func @vec() {
   // CHECK: vector<4xi32>
   "some.op"() : () -> vector<4xi32>
   // CHECK: vector<4xf32>

mlir/test/Target/LLVMIR/opaque-ptr.mlir

+// RUN: mlir-translate -mlir-to-llvmir -opaque-pointers %s | FileCheck %s
+
+// CHECK-LABEL: @opaque_ptr_load
+llvm.func @opaque_ptr_load(%arg0: !llvm.ptr) -> i32 {
+  // CHECK: load i32, ptr %{{.*}}
+  %0 = llvm.load %arg0 : !llvm.ptr -> i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: @opaque_ptr_store
+llvm.func @opaque_ptr_store(%arg0: i32, %arg1: !llvm.ptr){
+  // CHECK: store i32 %{{.*}}, ptr %{{.*}}
+  llvm.store %arg0, %arg1 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: @opaque_ptr_ptr_store
+llvm.func @opaque_ptr_ptr_store(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
+  // CHECK: store ptr %{{.*}}, ptr %{{.*}}
+  llvm.store %arg0, %arg1 : !llvm.ptr, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: @opaque_ptr_alloca
+llvm.func @opaque_ptr_alloca(%arg0: i32) -> !llvm.ptr {
+  // CHECK: alloca float, i32 %{{.*}}
+  %0 = llvm.alloca %arg0 x f32 : (i32) -> !llvm.ptr
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_gep
+llvm.func @opaque_ptr_gep(%arg0: !llvm.ptr, %arg1: i32) -> !llvm.ptr {
+  // CHECK: getelementptr float, ptr %{{.*}}, i32 %{{.*}}
+  %0 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr, i32) -> !llvm.ptr, f32
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_gep_struct
+llvm.func @opaque_ptr_gep_struct(%arg0: !llvm.ptr, %arg1: i32) -> !llvm.ptr {
+  // CHECK: getelementptr { { float, double }, { i32, i64 } }, ptr %{{.*}}, i32 0, i32 1
+  %0 = llvm.getelementptr %arg0[%arg1, 0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(struct<(f32, f64)>, struct<(i32, i64)>)>
+  llvm.return %0 : !llvm.ptr
+}
+
+// CHECK-LABEL: @opaque_ptr_matrix_load_store
+llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector<48 x f32> {
+  // CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32.i64
+  // CHECK: (ptr {{.*}}, i64 %{{.*}}
+  %0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+    vector<48 x f32> from !llvm.ptr stride i64
+  // CHECK: call void @llvm.matrix.column.major.store.v48f32.i64
+  // CHECK: <48 x float> %{{.*}}, ptr {{.*}}, i64
+  llvm.intr.matrix.column.major.store %0, %ptr, <stride=%stride>
+    { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+    vector<48 x f32> to !llvm.ptr stride i64
+  llvm.return %0 : vector<48 x f32>
+}
+
+// CHECK-LABEL: @opaque_ptr_masked_load
+llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vector<7xf32> {
+  // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr
+  %0 = llvm.intr.masked.load %arg0, %arg1 { alignment = 1: i32} :
+    (!llvm.ptr, vector<7xi1>) -> vector<7xf32>
+  llvm.return %0 : vector<7 x f32>
+}
+
+// CHECK-LABEL: @opaque_ptr_gather
+llvm.func @opaque_ptr_gather(%M: !llvm.vec<7 x ptr>, %mask: vector<7xi1>) -> vector<7xf32> {
+  // CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> {{.*}}, i32
+  %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
+      (!llvm.vec<7 x ptr>, vector<7xi1>) -> vector<7xf32>
+  llvm.return %a : vector<7xf32>
+}