[mlir][llvmir] Add support for llvm.signext/zeroext function attributes.

[vzakhari]

Summary

This change-set adds basic support for llvm.signext and llvm.zeroext
attributes, and makes sure that the attributes are translated to LLVM IR
when attached to arguments.

This is needed for https://github.com/llvm/llvm-project/issues/58579

Depends on D137047

[ftynse]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

992–1010

I see that this is just following the precedent, but could we rather do the verification in LLVM dialect? Dialects have a mechanism for verifying the attributes that use the namespace of the dialect.

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

86

Nit: prefer @below to @+1

[vzakhari]

Thank you for the review, Alex! I hope you do not mind that I move the verification code in a separate change-set.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

992–1010

Yes, I know that this is a long-standing concern (e.g. https://reviews.llvm.org/D121948#inline-1166282). I am taking AR to move them all to LLVM dialect verification code in a separate change-set.

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

let extraClassDeclaration = [{
     static StringRef getLoopOptionsAttrName() { return "options"; }
     static StringRef getAccessGroupsAttrName() { return "access_groups"; }
     static StringRef getStructAttrsAttrName() { return "llvm.struct_attrs"; }
     static StringRef getByValAttrName() { return "llvm.byval"; }
     static StringRef getByRefAttrName() { return "llvm.byref"; }
     static StringRef getStructRetAttrName() { return "llvm.sret"; }
     static StringRef getInAllocaAttrName() { return "llvm.inalloca"; }
     static StringRef getNoUndefAttrName() { return "llvm.noundef"; }
+    static StringRef getSExtAttrName() { return "llvm.signext"; }
+    static StringRef getZExtAttrName() { return "llvm.zeroext"; }
 
     /// Verifies if the attribute is a well-formed value for "llvm.struct_attrs"
     static LogicalResult verifyStructAttr(
         Operation *op, Attribute attr, Type annotatedType);
 
     /// Verifies if the given string is a well-formed data layout descriptor.
     /// Uses `reportError` to report errors.
     static LogicalResult verifyDataLayoutString(

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

for (auto kvp : llvm::zip(function.getArgumentTypes(), llvmFunc->args())) {
       }
 
       if (auto attr = function.getArgAttrOfType<UnitAttr>(
               argIdx, LLVMDialect::getNoUndefAttrName())) {
         // llvm.noundef can be added to any argument type.
         llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
                              .addAttribute(llvm::Attribute::NoUndef));
       }
+      if (auto attr = function.getArgAttrOfType<UnitAttr>(
+              argIdx, LLVMDialect::getSExtAttrName())) {
+        // llvm.signext can be added to any integer argument type.
+        if (!mlirArgTy.isa<mlir::IntegerType>())
+          return function.emitError(
+              "llvm.signext attribute attached to LLVM non-integer argument");
+        llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
+                             .addAttribute(llvm::Attribute::SExt));
+      }
+      if (auto attr = function.getArgAttrOfType<UnitAttr>(
+              argIdx, LLVMDialect::getZExtAttrName())) {
+        // llvm.zeroext can be added to any integer argument type.
+        if (!mlirArgTy.isa<mlir::IntegerType>())
+          return function.emitError(
+              "llvm.zeroext attribute attached to LLVM non-integer argument");
+        llvmArg.addAttrs(llvm::AttrBuilder(llvmArg.getContext())
+                             .addAttribute(llvm::Attribute::ZExt));
+      }
+
       ++argIdx;
     }
 
     // Forward the pass-through attributes to LLVM.
     if (failed(forwardPassthroughAttributes(
             function.getLoc(), function.getPassthrough(), llvmFunc)))
       return failure();
   }

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

 
 // expected-error @below{{llvm.align attribute attached to LLVM non-pointer argument}}
 llvm.func @invalid_align(%arg0 : f32 {llvm.align = 4}) -> f32 {
   llvm.return %arg0 : f32
 }
 
 // -----
 
+// expected-error@+1{{llvm.signext attribute attached to LLVM non-integer argument}}
+llvm.func @invalid_signext(%arg0: f32 {llvm.signext}) {
+  "llvm.return"() : () -> ()
+}
+
+// -----
+
+// expected-error@+1{{llvm.zeroext attribute attached to LLVM non-integer argument}}
+llvm.func @invalid_zeroext(%arg0: f32 {llvm.zeroext}) {
+  "llvm.return"() : () -> ()
+}
+
+// -----
+
 llvm.func @no_non_complex_struct() -> !llvm.array<2 x array<2 x array<2 x struct<(i32)>>>> {
   // expected-error @below{{expected struct type to be a complex number}}
   %0 = llvm.mlir.constant(dense<[[[1, 2], [3, 4]], [[42, 43], [44, 45]]]> : tensor<2x2x2xi32>) : !llvm.array<2 x array<2 x array<2 x struct<(i32)>>>>
   llvm.return %0 : !llvm.array<2 x array<2 x array<2 x struct<(i32)>>>>
 }
 
 // -----
 

mlir/test/Target/LLVMIR/llvmir.mlir

 // CHECK-LABEL: define void @inallocaattr(ptr inalloca(i32) %
 llvm.func @inallocaattr(%arg0: !llvm.ptr<i32> {llvm.inalloca = i32}) {
   llvm.return
 }
 
 // CHECK-LABEL: declare void @inallocaattr_decl(ptr inalloca(i32))
 llvm.func @inallocaattr_decl(!llvm.ptr<i32> {llvm.inalloca = i32})
 
+// CHECK-LABEL: define void @signextattr(i1 signext %
+llvm.func @signextattr(%arg0: i1 {llvm.signext}) {
+  llvm.return
+}
+
+// CHECK-LABEL: declare void @signextattr_decl(i1 signext)
+llvm.func @signextattr_decl(i1 {llvm.signext})
+
+// CHECK-LABEL: define void @zeroextattr(i1 zeroext %
+llvm.func @zeroextattr(%arg0: i1 {llvm.zeroext}) {
+  llvm.return
+}
+
+// CHECK-LABEL: declare void @zeroextattr_decl(i1 zeroext)
+llvm.func @zeroextattr_decl(i1 {llvm.zeroext})
+
 // CHECK-LABEL: @llvm_varargs(...)
 llvm.func @llvm_varargs(...)
 
 llvm.func @intpointerconversion(%arg0 : i32) -> i32 {
 // CHECK:      %2 = inttoptr i32 %0 to ptr
 // CHECK-NEXT: %3 = ptrtoint ptr %2 to i32
   %1 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
   %2 = llvm.ptrtoint %1 : !llvm.ptr<i32> to i32