[mlir] move LLVM target import header and tests

[ftynse]

Summary

Move Target/LLVMIR.h to target/LLVMIR/Import.h to better reflect the purpose of
this file. Also move all LLVM IR target tests under the LLVMIR directory.

mlir/include/mlir/Target/LLVMIR/Import.h

-//===- LLVMIR.h - MLIR to LLVM IR conversion --------------------*- C++ -*-===//
+//===- Import.h - LLVM IR To MLIR translation -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file declares the entry point for the MLIR to LLVM IR conversion.
+// This file declares the entry point for the LLVM IR to MLIR conversion.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TARGET_LLVMIR_H
-#define MLIR_TARGET_LLVMIR_H
+#ifndef MLIR_TARGET_LLVMIR_IMPORT_H
+#define MLIR_TARGET_LLVMIR_IMPORT_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 
 // Forward-declare LLVM classes.
 namespace llvm {
 class Module;

 /// to the error handler registered with the MLIR context, if any (obtained from
 /// the MLIR module), and return `{}`.
 OwningModuleRef
 translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                         MLIRContext *context);
 
 } // namespace mlir
 
-#endif // MLIR_TARGET_LLVMIR_H
+#endif // MLIR_TARGET_LLVMIR_IMPORT_H

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
-#include "mlir/Target/LLVMIR.h"
+#include "mlir/Target/LLVMIR/Import.h"
 #include "mlir/Translation.h"
 
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"

mlir/test/Target/LLVMIR/arm-neon.mlir

 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
 // CHECK-LABEL: arm_neon_smull
 llvm.func @arm_neon_smull(%arg0: vector<8xi8>, %arg1: vector<8xi8>) -> !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)> {
   //      CHECK: %[[V0:.*]] = call <8 x i16> @llvm.aarch64.neon.smull.v8i16(<8 x i8> %{{.*}}, <8 x i8> %{{.*}})
   // CHECK-NEXT: %[[V00:.*]] = shufflevector <8 x i16> %3, <8 x i16> %[[V0]], <4 x i32> <i32 3, i32 4, i32 5, i32 6>
   %0 = "llvm_arm_neon.smull"(%arg0, %arg1) : (vector<8xi8>, vector<8xi8>) -> vector<8xi16>
   %1 = llvm.shufflevector %0, %0 [3, 4, 5, 6] : vector<8xi16>, vector<8xi16>
 
   // CHECK-NEXT: %[[V1:.*]] = call <4 x i32> @llvm.aarch64.neon.smull.v4i32(<4 x i16> %[[V00]], <4 x i16> %[[V00]])
   // CHECK-NEXT: %[[V11:.*]] = shufflevector <4 x i32> %[[V1]], <4 x i32> %[[V1]], <2 x i32> <i32 1, i32 2>
   %2 = "llvm_arm_neon.smull"(%1, %1) : (vector<4xi16>, vector<4xi16>) -> vector<4xi32>
   %3 = llvm.shufflevector %2, %2 [1, 2] : vector<4xi32>, vector<4xi32>
 
   // CHECK-NEXT: %[[V1:.*]] = call <2 x i64> @llvm.aarch64.neon.smull.v2i64(<2 x i32> %[[V11]], <2 x i32> %[[V11]])
   %4 = "llvm_arm_neon.smull"(%3, %3) : (vector<2xi32>, vector<2xi32>) -> vector<2xi64>
 
   %5 = llvm.mlir.undef : !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)>
   %6 = llvm.insertvalue %0, %5[0] : !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)>
   %7 = llvm.insertvalue %2, %6[1] : !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)>
   %8 = llvm.insertvalue %4, %7[2] : !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)>
 
   //      CHECK: ret { <8 x i16>, <4 x i32>, <2 x i64> }
   llvm.return %8 : !llvm.struct<(vector<8xi16>, vector<4xi32>, vector<2xi64>)>
 }

mlir/test/Target/LLVMIR/arm-sve.mlir

 // RUN: mlir-translate --mlir-to-llvmir %s | FileCheck %s
 
 // CHECK-LABEL: define <vscale x 4 x i32> @arm_sve_sdot
 llvm.func @arm_sve_sdot(%arg0: !llvm.vec<?x16 x i8>,
                         %arg1: !llvm.vec<?x16 x i8>,
                         %arg2: !llvm.vec<?x4 x i32>)
                         -> !llvm.vec<?x4 x i32> {
   // CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.sdot.nxv4i32(<vscale x 4
   %0 = "llvm_arm_sve.sdot"(%arg2, %arg0, %arg1) :
     (!llvm.vec<?x4 x i32>, !llvm.vec<?x16 x i8>, !llvm.vec<?x16 x i8>)
         -> !llvm.vec<?x4 x i32>
   llvm.return %0 : !llvm.vec<?x4 x i32>
 }
 
 // CHECK-LABEL: define <vscale x 4 x i32> @arm_sve_smmla
 llvm.func @arm_sve_smmla(%arg0: !llvm.vec<?x16 x i8>,
                          %arg1: !llvm.vec<?x16 x i8>,
                          %arg2: !llvm.vec<?x4 x i32>)
                          -> !llvm.vec<?x4 x i32> {
   // CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.smmla.nxv4i32(<vscale x 4
   %0 = "llvm_arm_sve.smmla"(%arg2, %arg0, %arg1) :
     (!llvm.vec<?x4 x i32>, !llvm.vec<?x16 x i8>, !llvm.vec<?x16 x i8>)
         -> !llvm.vec<?x4 x i32>
   llvm.return %0 : !llvm.vec<?x4 x i32>
 }
 
 // CHECK-LABEL: define <vscale x 4 x i32> @arm_sve_udot
 llvm.func @arm_sve_udot(%arg0: !llvm.vec<?x16 x i8>,
                         %arg1: !llvm.vec<?x16 x i8>,
                         %arg2: !llvm.vec<?x4 x i32>)
                         -> !llvm.vec<?x4 x i32> {
   // CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.udot.nxv4i32(<vscale x 4
   %0 = "llvm_arm_sve.udot"(%arg2, %arg0, %arg1) :
     (!llvm.vec<?x4 x i32>, !llvm.vec<?x16 x i8>, !llvm.vec<?x16 x i8>)
         -> !llvm.vec<?x4 x i32>
   llvm.return %0 : !llvm.vec<?x4 x i32>
 }
 
 // CHECK-LABEL: define <vscale x 4 x i32> @arm_sve_ummla
 llvm.func @arm_sve_ummla(%arg0: !llvm.vec<?x16 x i8>,
                          %arg1: !llvm.vec<?x16 x i8>,
                          %arg2: !llvm.vec<?x4 x i32>)
                          -> !llvm.vec<?x4 x i32> {
   // CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.ummla.nxv4i32(<vscale x 4
   %0 = "llvm_arm_sve.ummla"(%arg2, %arg0, %arg1) :
     (!llvm.vec<?x4 x i32>, !llvm.vec<?x16 x i8>, !llvm.vec<?x16 x i8>)
         -> !llvm.vec<?x4 x i32>
   llvm.return %0 : !llvm.vec<?x4 x i32>
 }
 
 // CHECK-LABEL: define i64 @get_vector_scale()
 llvm.func @get_vector_scale() -> i64 {
   // CHECK: call i64 @llvm.vscale.i64()
   %0 = "llvm_arm_sve.vscale"() : () -> i64
   llvm.return %0 : i64
 }

mlir/test/Target/LLVMIR/avx512.mlir

 // RUN: mlir-translate --mlir-to-llvmir %s | FileCheck %s
 
 // CHECK-LABEL: define <16 x float> @LLVM_x86_avx512_mask_ps_512
 llvm.func @LLVM_x86_avx512_mask_ps_512(%a: vector<16 x f32>,
                                        %c: i16)
   -> (vector<16 x f32>)
 {
   %b = llvm.mlir.constant(42 : i32) : i32
   // CHECK: call <16 x float> @llvm.x86.avx512.mask.rndscale.ps.512(<16 x float>
   %0 = "llvm_avx512.mask.rndscale.ps.512"(%a, %b, %a, %c, %b) :
     (vector<16 x f32>, i32, vector<16 x f32>, i16, i32) -> vector<16 x f32>
   // CHECK: call <16 x float> @llvm.x86.avx512.mask.scalef.ps.512(<16 x float>
   %1 = "llvm_avx512.mask.scalef.ps.512"(%a, %a, %a, %c, %b) :
     (vector<16 x f32>, vector<16 x f32>, vector<16 x f32>, i16, i32) -> vector<16 x f32>
   llvm.return %1: vector<16 x f32>
 }
 
 // CHECK-LABEL: define <8 x double> @LLVM_x86_avx512_mask_pd_512
 llvm.func @LLVM_x86_avx512_mask_pd_512(%a: vector<8xf64>,
                                        %c: i8)
   -> (vector<8xf64>)
 {
   %b = llvm.mlir.constant(42 : i32) : i32
   // CHECK: call <8 x double> @llvm.x86.avx512.mask.rndscale.pd.512(<8 x double>
   %0 = "llvm_avx512.mask.rndscale.pd.512"(%a, %b, %a, %c, %b) :
     (vector<8xf64>, i32, vector<8xf64>, i8, i32) -> vector<8xf64>
   // CHECK: call <8 x double> @llvm.x86.avx512.mask.scalef.pd.512(<8 x double>
   %1 = "llvm_avx512.mask.scalef.pd.512"(%a, %a, %a, %c, %b) :
     (vector<8xf64>, vector<8xf64>, vector<8xf64>, i8, i32) -> vector<8xf64>
   llvm.return %1: vector<8xf64>
 }
 
 // CHECK-LABEL: define { <16 x i1>, <16 x i1> } @LLVM_x86_vp2intersect_d_512
 llvm.func @LLVM_x86_vp2intersect_d_512(%a: vector<16xi32>, %b: vector<16xi32>)
   -> !llvm.struct<(vector<16 x i1>, vector<16 x i1>)>
 {
   // CHECK: call { <16 x i1>, <16 x i1> } @llvm.x86.avx512.vp2intersect.d.512(<16 x i32>
   %0 = "llvm_avx512.vp2intersect.d.512"(%a, %b) :
     (vector<16xi32>, vector<16xi32>) -> !llvm.struct<(vector<16 x i1>, vector<16 x i1>)>
   llvm.return %0 : !llvm.struct<(vector<16 x i1>, vector<16 x i1>)>
 }
 
 // CHECK-LABEL: define { <8 x i1>, <8 x i1> } @LLVM_x86_vp2intersect_q_512
 llvm.func @LLVM_x86_vp2intersect_q_512(%a: vector<8xi64>, %b: vector<8xi64>)
   -> !llvm.struct<(vector<8 x i1>, vector<8 x i1>)>
 {
   // CHECK: call { <8 x i1>, <8 x i1> } @llvm.x86.avx512.vp2intersect.q.512(<8 x i64>
   %0 = "llvm_avx512.vp2intersect.q.512"(%a, %b) :
     (vector<8xi64>, vector<8xi64>) -> !llvm.struct<(vector<8 x i1>, vector<8 x i1>)>
   llvm.return %0 : !llvm.struct<(vector<8 x i1>, vector<8 x i1>)>
 }

mlir/test/Target/LLVMIR/import.ll

 ; RUN: mlir-translate -import-llvm %s | FileCheck %s
 
 %struct.t = type {}
 %struct.s = type { %struct.t, i64 }
 
 ; CHECK: llvm.mlir.global external @g1() : !llvm.struct<"struct.s", (struct<"struct.t", ()>, i64)>
 @g1 = external global %struct.s, align 8
 ; CHECK: llvm.mlir.global external @g2() : f64
 @g2 = external global double, align 8
 ; CHECK: llvm.mlir.global internal @g3("string")
 @g3 = internal global [6 x i8] c"string"
 
 ; CHECK: llvm.mlir.global external @g5() : vector<8xi32>
 @g5 = external global <8 x i32>
 
 @g4 = external global i32, align 8
 ; CHECK: llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> {
 ; CHECK-DAG:   %[[addr:[0-9]+]] = llvm.mlir.addressof @g4 : !llvm.ptr<i32>
 ; CHECK-DAG:   %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
 ; CHECK-NEXT:  %[[gepinit:[0-9]+]] = llvm.getelementptr %[[addr]][%[[c2]]] : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
 ; CHECK-NEXT:  llvm.return %[[gepinit]] : !llvm.ptr<i32>
 ; CHECK-NEXT: }
 @int_gep = internal constant i32* getelementptr (i32, i32* @g4, i32 2)
 
 ;
 ; Linkage attribute.
 ;
 
 ; CHECK: llvm.mlir.global private @private(42 : i32) : i32
 @private = private global i32 42
 ; CHECK: llvm.mlir.global internal @internal(42 : i32) : i32
 @internal = internal global i32 42
 ; CHECK: llvm.mlir.global available_externally @available_externally(42 : i32) : i32
 @available_externally = available_externally global i32 42
 ; CHECK: llvm.mlir.global linkonce @linkonce(42 : i32) : i32
 @linkonce = linkonce global i32 42
 ; CHECK: llvm.mlir.global weak @weak(42 : i32) : i32
 @weak = weak global i32 42
 ; CHECK: llvm.mlir.global common @common(0 : i32) : i32
 @common = common global i32 zeroinitializer
 ; CHECK: llvm.mlir.global appending @appending(dense<[0, 1]> : tensor<2xi32>) : !llvm.array<2 x i32>
 @appending = appending global [2 x i32] [i32 0, i32 1]
 ; CHECK: llvm.mlir.global extern_weak @extern_weak() : i32
 @extern_weak = extern_weak global i32
 ; CHECK: llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32
 @linkonce_odr = linkonce_odr global i32 42
 ; CHECK: llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32
 @weak_odr = weak_odr global i32 42
 ; CHECK: llvm.mlir.global external @external() : i32
 @external = external global i32
 
 ;
 ; Sequential constants.
 ;
 
 ; CHECK: llvm.mlir.global internal constant @vector_constant(dense<[1, 2]> : vector<2xi32>) : vector<2xi32>
 @vector_constant = internal constant <2 x i32> <i32 1, i32 2>
 ; CHECK: llvm.mlir.global internal constant @array_constant(dense<[1.000000e+00, 2.000000e+00]> : tensor<2xf32>) : !llvm.array<2 x f32>
 @array_constant = internal constant [2 x float] [float 1., float 2.]
 ; CHECK: llvm.mlir.global internal constant @nested_array_constant(dense<[{{\[}}1, 2], [3, 4]]> : tensor<2x2xi32>) : !llvm.array<2 x array<2 x i32>>
 @nested_array_constant = internal constant [2 x [2 x i32]] [[2 x i32] [i32 1, i32 2], [2 x i32] [i32 3, i32 4]]
 ; CHECK: llvm.mlir.global internal constant @nested_array_constant3(dense<[{{\[}}[1, 2], [3, 4]]]> : tensor<1x2x2xi32>) : !llvm.array<1 x array<2 x array<2 x i32>>>
 @nested_array_constant3 = internal constant [1 x [2 x [2 x i32]]] [[2 x [2 x i32]] [[2 x i32] [i32 1, i32 2], [2 x i32] [i32 3, i32 4]]]
 ; CHECK: llvm.mlir.global internal constant @nested_array_vector(dense<[{{\[}}[1, 2], [3, 4]]]> : vector<1x2x2xi32>) : !llvm.array<1 x array<2 x vector<2xi32>>>
 @nested_array_vector = internal constant [1 x [2 x <2 x i32>]] [[2 x <2 x i32>] [<2 x i32> <i32 1, i32 2>, <2 x i32> <i32 3, i32 4>]]
 
 ;
 ; Linkage on functions.
 ;
 
 ; CHECK: llvm.func internal @func_internal
 define internal void @func_internal() {
   ret void
 }
 
 ; CHECK: llvm.func @fe(i32) -> f32
 declare float @fe(i32)
 
 ; FIXME: function attributes.
 ; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 {
 ; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
 ; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
 ; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
 ; CHECK-DAG: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
 define internal dso_local i32 @f1(i64 %a) norecurse {
 entry:
 ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
   %aa = inttoptr i64 %a to i64*
 ; %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<f64>
 ; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<f64>
 ; %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
 ; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr<f64> to i64
 ; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr<f64>, i32) -> !llvm.ptr<f64>
   %bb = ptrtoint double* @g2 to i64
   %cc = getelementptr double, double* @g2, i32 2
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
   %b = trunc i64 %a to i32
 ; CHECK: %[[c:[0-9]+]] = llvm.call @fe(%[[b]]) : (i32) -> f32
   %c = call float @fe(i32 %b)
 ; CHECK: %[[d:[0-9]+]] = llvm.fptosi %[[c]] : f32 to i32
   %d = fptosi float %c to i32
 ; FIXME: icmp should return i1.
 ; CHECK: %[[e:[0-9]+]] = llvm.icmp "ne" %[[d]], %[[c2]] : i32
   %e = icmp ne i32 %d, 2
 ; CHECK: llvm.cond_br %[[e]], ^bb1, ^bb2
   br i1 %e, label %if.then, label %if.end
 
 ; CHECK: ^bb1:
 if.then:
 ; CHECK: llvm.return %[[c42]] : i32
   ret i32 42
   
 ; CHECK: ^bb2:
 if.end:
 ; CHECK: %[[orcond:[0-9]+]] = llvm.or %[[e]], %[[c1]] : i1
   %or.cond = or i1 %e, 1
 ; CHECK: llvm.return %[[c43]]
   ret i32 43
 }
 
 ; Test that instructions that dominate can be out of sequential order.
 ; CHECK-LABEL: llvm.func @f2(%arg0: i64) -> i64 {
 ; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : i64
 define i64 @f2(i64 %a) noduplicate {
 entry:
 ; CHECK: llvm.br ^bb2
   br label %next
 
 ; CHECK: ^bb1:
 end:
 ; CHECK: llvm.return %1
   ret i64 %b
 
 ; CHECK: ^bb2:
 next:
 ; CHECK: %1 = llvm.add %arg0, %[[c3]] : i64
   %b = add i64 %a, 3
 ; CHECK: llvm.br ^bb1
   br label %end
 }
 
 ; Test arguments/phis.
 ; CHECK-LABEL: llvm.func @f2_phis(%arg0: i64) -> i64 {
 ; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : i64
 define i64 @f2_phis(i64 %a) noduplicate {
 entry:
 ; CHECK: llvm.br ^bb2
   br label %next
 
 ; CHECK: ^bb1(%1: i64):
 end:
   %c = phi i64 [ %b, %next ]
 ; CHECK: llvm.return %1
   ret i64 %c
 
 ; CHECK: ^bb2:
 next:
 ; CHECK: %2 = llvm.add %arg0, %[[c3]] : i64
   %b = add i64 %a, 3
 ; CHECK: llvm.br ^bb1
   br label %end
 }
 
 ; CHECK-LABEL: llvm.func @f3() -> !llvm.ptr<i32>
 define i32* @f3() {
 ; CHECK: %[[c:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<f64>
 ; CHECK: %[[b:[0-9]+]] = llvm.bitcast %[[c]] : !llvm.ptr<f64> to !llvm.ptr<i32>
 ; CHECK: llvm.return %[[b]] : !llvm.ptr<i32>
   ret i32* bitcast (double* @g2 to i32*)
 }
 
 ; CHECK-LABEL: llvm.func @f4() -> !llvm.ptr<i32>
 define i32* @f4() {
 ; CHECK: %[[b:[0-9]+]] = llvm.mlir.null : !llvm.ptr<i32>
 ; CHECK: llvm.return %[[b]] : !llvm.ptr<i32>
   ret i32* bitcast (double* null to i32*)
 }
 
 ; CHECK-LABEL: llvm.func @f5
 define void @f5(i32 %d) {
 ; FIXME: icmp should return i1.
 ; CHECK: = llvm.icmp "eq"
   %1 = icmp eq i32 %d, 2
 ; CHECK: = llvm.icmp "slt"
   %2 = icmp slt i32 %d, 2
 ; CHECK: = llvm.icmp "sle"
   %3 = icmp sle i32 %d, 2
 ; CHECK: = llvm.icmp "sgt"
   %4 = icmp sgt i32 %d, 2
 ; CHECK: = llvm.icmp "sge"
   %5 = icmp sge i32 %d, 2
 ; CHECK: = llvm.icmp "ult"
   %6 = icmp ult i32 %d, 2
 ; CHECK: = llvm.icmp "ule"
   %7 = icmp ule i32 %d, 2
 ; CHECK: = llvm.icmp "ugt"
   %8 = icmp ugt i32 %d, 2
   ret void
 }
 
 ; CHECK-LABEL: llvm.func @f6(%arg0: !llvm.ptr<func<void (i16)>>)
 define void @f6(void (i16) *%fn) {
 ; CHECK: %[[c:[0-9]+]] = llvm.mlir.constant(0 : i16) : i16
 ; CHECK: llvm.call %arg0(%[[c]])
   call void %fn(i16 0)
   ret void
 }
 
 ; CHECK-LABEL: llvm.func @FPArithmetic(%arg0: f32, %arg1: f32, %arg2: f64, %arg3: f64)
 define void @FPArithmetic(float %a, float %b, double %c, double %d) {
   ; CHECK: %[[a1:[0-9]+]] = llvm.mlir.constant(3.030000e+01 : f64) : f64
   ; CHECK: %[[a2:[0-9]+]] = llvm.mlir.constant(3.030000e+01 : f32) : f32
   ; CHECK: %[[a3:[0-9]+]] = llvm.fadd %[[a2]], %arg0 : f32
   %1 = fadd float 0x403E4CCCC0000000, %a
   ; CHECK: %[[a4:[0-9]+]] = llvm.fadd %arg0, %arg1 : f32
   %2 = fadd float %a, %b
   ; CHECK: %[[a5:[0-9]+]] = llvm.fadd %[[a1]], %arg2 : f64
   %3 = fadd double 3.030000e+01, %c
   ; CHECK: %[[a6:[0-9]+]] = llvm.fsub %arg0, %arg1 : f32
   %4 = fsub float %a, %b
   ; CHECK: %[[a7:[0-9]+]] = llvm.fsub %arg2, %arg3 : f64
   %5 = fsub double %c, %d
   ; CHECK: %[[a8:[0-9]+]] = llvm.fmul %arg0, %arg1 : f32
   %6 = fmul float %a, %b
   ; CHECK: %[[a9:[0-9]+]] = llvm.fmul %arg2, %arg3 : f64
   %7 = fmul double %c, %d
   ; CHECK: %[[a10:[0-9]+]] = llvm.fdiv %arg0, %arg1 : f32
   %8 = fdiv float %a, %b
   ; CHECK: %[[a12:[0-9]+]] = llvm.fdiv %arg2, %arg3 : f64
   %9 = fdiv double %c, %d
   ; CHECK: %[[a11:[0-9]+]] = llvm.frem %arg0, %arg1 : f32
   %10 = frem float %a, %b
   ; CHECK: %[[a13:[0-9]+]] = llvm.frem %arg2, %arg3 : f64
   %11 = frem double %c, %d
   ret void
 }
 
 ;
 ; Functions as constants.
 ;
 
 ; Calling the function that has not been defined yet.
 ; CHECK-LABEL: @precaller
 define i32 @precaller() {
   %1 = alloca i32 ()*
   ; CHECK: %[[func:.*]] = llvm.mlir.addressof @callee : !llvm.ptr<func<i32 ()>>
   ; CHECK: llvm.store %[[func]], %[[loc:.*]]
   store i32 ()* @callee, i32 ()** %1
   ; CHECK: %[[indir:.*]] = llvm.load %[[loc]]
   %2 = load i32 ()*, i32 ()** %1
   ; CHECK: llvm.call %[[indir]]()
   %3 = call i32 %2()
   ret i32 %3
 }
 
 define i32 @callee() {
   ret i32 42
 }
 
 ; Calling the function that has been defined.
 ; CHECK-LABEL: @postcaller
 define i32 @postcaller() {
   %1 = alloca i32 ()*
   ; CHECK: %[[func:.*]] = llvm.mlir.addressof @callee : !llvm.ptr<func<i32 ()>>
   ; CHECK: llvm.store %[[func]], %[[loc:.*]]
   store i32 ()* @callee, i32 ()** %1
   ; CHECK: %[[indir:.*]] = llvm.load %[[loc]]
   %2 = load i32 ()*, i32 ()** %1
   ; CHECK: llvm.call %[[indir]]()
   %3 = call i32 %2()
   ret i32 %3
 }
 
 @_ZTIi = external dso_local constant i8*
 @_ZTIii= external dso_local constant i8**
 declare void @foo(i8*)
 declare i8* @bar(i8*)
 declare i32 @__gxx_personality_v0(...)
 
 ; CHECK-LABEL: @invokeLandingpad
 define i32 @invokeLandingpad() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   ; CHECK: %[[a1:[0-9]+]] = llvm.bitcast %{{[0-9]+}} : !llvm.ptr<ptr<ptr<i8>>> to !llvm.ptr<i8>
   ; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x i8 : (i32) -> !llvm.ptr<i8>
   %1 = alloca i8
   ; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> ()
   invoke void @foo(i8* %1) to label %4 unwind label %2
 
 ; CHECK: ^bb1:
   ; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr<ptr<i8>>) (catch %[[a1]] : !llvm.ptr<i8>) (filter %{{[0-9]+}} : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
   %3 = landingpad { i8*, i32 } catch i8** @_ZTIi catch i8* bitcast (i8*** @_ZTIii to i8*)
   ; FIXME: Change filter to a constant array once they are handled.
   ; Currently, even though it parses this, LLVM module is broken
           filter [1 x i8] [i8 1]
   resume { i8*, i32 } %3
 
 ; CHECK: ^bb2:
   ; CHECK: llvm.return %{{[0-9]+}} : i32
   ret i32 1
 
 ; CHECK: ^bb3:
   ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
   %6 = invoke i8* @bar(i8* %1) to label %4 unwind label %2
 
 ; CHECK: ^bb4:
   ; CHECK: llvm.return %{{[0-9]+}} : i32
   ret i32 0
 }
 
 ;CHECK-LABEL: @useFreezeOp
 define i32 @useFreezeOp(i32 %x) {
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9a-z]+}} : i32
   %1 = freeze i32 %x
   %2 = add i8 10, 10
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9]+}} : i8
   %3 = freeze i8 %2
   %poison = add nsw i1 0, undef
   ret i32 0
 }
 
 ;CHECK-LABEL: @useFenceInst
 define i32 @useFenceInst() {
   ;CHECK: llvm.fence syncscope("agent") seq_cst
   fence syncscope("agent") seq_cst
   ;CHECK: llvm.fence release
   fence release
   ;CHECK: llvm.fence seq_cst
   fence syncscope("") seq_cst
   ret i32 0
 }

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

 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
 // CHECK-LABEL: define void @func_no_debug()
 // CHECK-NOT: !dbg
 llvm.func @func_no_debug() {
   llvm.return loc(unknown)
 } loc(unknown)
 
 // CHECK-LABEL: define void @func_with_debug()
 // CHECK-SAME: !dbg ![[FUNC_LOC:[0-9]+]]
 llvm.func @func_with_debug() {
   // CHECK: call void @func_no_debug(), !dbg ![[CALLSITE_LOC:[0-9]+]]
   llvm.call @func_no_debug() : () -> () loc(callsite("mysource.cc":3:4 at "mysource.cc":5:6))
 
   // CHECK: call void @func_no_debug(), !dbg ![[FILE_LOC:[0-9]+]]
   llvm.call @func_no_debug() : () -> () loc("foo.mlir":1:2)
 
   // CHECK: call void @func_no_debug(), !dbg ![[NAMED_LOC:[0-9]+]]
   llvm.call @func_no_debug() : () -> () loc("named"("foo.mlir":10:10))
 
   // CHECK: call void @func_no_debug(), !dbg ![[FUSED_LOC:[0-9]+]]
   llvm.call @func_no_debug() : () -> () loc(fused[callsite("mysource.cc":1:1 at "mysource.cc":5:6), "mysource.cc":1:1])
 
   llvm.return
 } loc("foo.mlir":1:1)
 
 // CHECK-DAG: ![[FUNC_LOC]] = distinct !DISubprogram{{.*}}, line: 1
 // CHECK-DAG: ![[CALLSITE_LOC]] = !DILocation(line: 3, column: 4,
 // CHECK-DAG: ![[FILE_LOC]] = !DILocation(line: 1, column: 2,
 // CHECK-DAG: ![[NAMED_LOC]] = !DILocation(line: 10, column: 10
 // CHECK-DAG: ![[FUSED_LOC]] = !DILocation(line: 1, column: 1

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

 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
 // CHECK-LABEL: @intrinsics
 llvm.func @intrinsics(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: !llvm.ptr<i8>) {
   %c3 = llvm.mlir.constant(3 : i32) : i32
   %c1 = llvm.mlir.constant(1 : i32) : i32
   %c0 = llvm.mlir.constant(0 : i32) : i32
   // CHECK: call float @llvm.fmuladd.f32
   "llvm.intr.fmuladd"(%arg0, %arg1, %arg0) : (f32, f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.fmuladd.v8f32
   "llvm.intr.fmuladd"(%arg2, %arg2, %arg2) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   // CHECK: call float @llvm.fma.f32
   "llvm.intr.fma"(%arg0, %arg1, %arg0) : (f32, f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.fma.v8f32
   "llvm.intr.fma"(%arg2, %arg2, %arg2) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   // CHECK: call void @llvm.prefetch.p0i8(i8* %3, i32 0, i32 3, i32 1)
   "llvm.intr.prefetch"(%arg3, %c0, %c3, %c1) : (!llvm.ptr<i8>, i32, i32, i32) -> ()
   llvm.return
 }
 
 // CHECK-LABEL: @exp_test
 llvm.func @exp_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.exp.f32
   "llvm.intr.exp"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.exp.v8f32
   "llvm.intr.exp"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @exp2_test
 llvm.func @exp2_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.exp2.f32
   "llvm.intr.exp2"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.exp2.v8f32
   "llvm.intr.exp2"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @log_test
 llvm.func @log_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.log.f32
   "llvm.intr.log"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.log.v8f32
   "llvm.intr.log"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @log10_test
 llvm.func @log10_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.log10.f32
   "llvm.intr.log10"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.log10.v8f32
   "llvm.intr.log10"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @log2_test
 llvm.func @log2_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.log2.f32
   "llvm.intr.log2"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.log2.v8f32
   "llvm.intr.log2"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @fabs_test
 llvm.func @fabs_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.fabs.f32
   "llvm.intr.fabs"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.fabs.v8f32
   "llvm.intr.fabs"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @sqrt_test
 llvm.func @sqrt_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.sqrt.f32
   "llvm.intr.sqrt"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.sqrt.v8f32
   "llvm.intr.sqrt"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @ceil_test
 llvm.func @ceil_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.ceil.f32
   "llvm.intr.ceil"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.ceil.v8f32
   "llvm.intr.ceil"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @floor_test
 llvm.func @floor_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.floor.f32
   "llvm.intr.floor"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.floor.v8f32
   "llvm.intr.floor"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @cos_test
 llvm.func @cos_test(%arg0: f32, %arg1: vector<8xf32>) {
   // CHECK: call float @llvm.cos.f32
   "llvm.intr.cos"(%arg0) : (f32) -> f32
   // CHECK: call <8 x float> @llvm.cos.v8f32
   "llvm.intr.cos"(%arg1) : (vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @copysign_test
 llvm.func @copysign_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.copysign.f32
   "llvm.intr.copysign"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.copysign.v8f32
   "llvm.intr.copysign"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @pow_test
 llvm.func @pow_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.pow.f32
   "llvm.intr.pow"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.pow.v8f32
   "llvm.intr.pow"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @bitreverse_test
 llvm.func @bitreverse_test(%arg0: i32, %arg1: vector<8xi32>) {
   // CHECK: call i32 @llvm.bitreverse.i32
   "llvm.intr.bitreverse"(%arg0) : (i32) -> i32
   // CHECK: call <8 x i32> @llvm.bitreverse.v8i32
   "llvm.intr.bitreverse"(%arg1) : (vector<8xi32>) -> vector<8xi32>
   llvm.return
 }
 
 // CHECK-LABEL: @ctpop_test
 llvm.func @ctpop_test(%arg0: i32, %arg1: vector<8xi32>) {
   // CHECK: call i32 @llvm.ctpop.i32
   "llvm.intr.ctpop"(%arg0) : (i32) -> i32
   // CHECK: call <8 x i32> @llvm.ctpop.v8i32
   "llvm.intr.ctpop"(%arg1) : (vector<8xi32>) -> vector<8xi32>
   llvm.return
 }
 
 // CHECK-LABEL: @maximum_test
 llvm.func @maximum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.maximum.f32
   "llvm.intr.maximum"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.maximum.v8f32
   "llvm.intr.maximum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @minimum_test
 llvm.func @minimum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.minimum.f32
   "llvm.intr.minimum"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.minimum.v8f32
   "llvm.intr.minimum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @maxnum_test
 llvm.func @maxnum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.maxnum.f32
   "llvm.intr.maxnum"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.maxnum.v8f32
   "llvm.intr.maxnum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @minnum_test
 llvm.func @minnum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {
   // CHECK: call float @llvm.minnum.f32
   "llvm.intr.minnum"(%arg0, %arg1) : (f32, f32) -> f32
   // CHECK: call <8 x float> @llvm.minnum.v8f32
   "llvm.intr.minnum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @smax_test
 llvm.func @smax_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call i32 @llvm.smax.i32
   "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32
   // CHECK: call <8 x i32> @llvm.smax.v8i32
   "llvm.intr.smax"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>
   llvm.return
 }
 
 // CHECK-LABEL: @smin_test
 llvm.func @smin_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call i32 @llvm.smin.i32
   "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32
   // CHECK: call <8 x i32> @llvm.smin.v8i32
   "llvm.intr.smin"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>
   llvm.return
 }
 
 // CHECK-LABEL: @vector_reductions
 llvm.func @vector_reductions(%arg0: f32, %arg1: vector<8xf32>, %arg2: vector<8xi32>) {
   // CHECK: call i32 @llvm.vector.reduce.add.v8i32
   "llvm.intr.vector.reduce.add"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.and.v8i32
   "llvm.intr.vector.reduce.and"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call float @llvm.vector.reduce.fmax.v8f32
   "llvm.intr.vector.reduce.fmax"(%arg1) : (vector<8xf32>) -> f32
   // CHECK: call float @llvm.vector.reduce.fmin.v8f32
   "llvm.intr.vector.reduce.fmin"(%arg1) : (vector<8xf32>) -> f32
   // CHECK: call i32 @llvm.vector.reduce.mul.v8i32
   "llvm.intr.vector.reduce.mul"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.or.v8i32
   "llvm.intr.vector.reduce.or"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.smax.v8i32
   "llvm.intr.vector.reduce.smax"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.smin.v8i32
   "llvm.intr.vector.reduce.smin"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.umax.v8i32
   "llvm.intr.vector.reduce.umax"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call i32 @llvm.vector.reduce.umin.v8i32
   "llvm.intr.vector.reduce.umin"(%arg2) : (vector<8xi32>) -> i32
   // CHECK: call float @llvm.vector.reduce.fadd.v8f32
   "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) : (f32, vector<8xf32>) -> f32
   // CHECK: call float @llvm.vector.reduce.fmul.v8f32
   "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) : (f32, vector<8xf32>) -> f32
   // CHECK: call reassoc float @llvm.vector.reduce.fadd.v8f32
   "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) {reassoc = true} : (f32, vector<8xf32>) -> f32
   // CHECK: call reassoc float @llvm.vector.reduce.fmul.v8f32
   "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) {reassoc = true} : (f32, vector<8xf32>) -> f32
   // CHECK: call i32 @llvm.vector.reduce.xor.v8i32
   "llvm.intr.vector.reduce.xor"(%arg2) : (vector<8xi32>) -> i32
   llvm.return
 }
 
 // CHECK-LABEL: @matrix_intrinsics
 //                                       4x16                       16x3
 llvm.func @matrix_intrinsics(%A: vector<64 x f32>, %B: vector<48 x f32>,
                              %ptr: !llvm.ptr<f32>, %stride: i64) {
   // CHECK: call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %0, <48 x float> %1, i32 4, i32 16, i32 3)
   %C = llvm.intr.matrix.multiply %A, %B
     { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} :
     (vector<64 x f32>, vector<48 x f32>) -> vector<12 x f32>
   // CHECK: call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %1, i32 3, i32 16)
   %D = llvm.intr.matrix.transpose %B { rows = 3: i32, columns = 16: i32} :
     vector<48 x f32> into vector<48 x f32>
   // CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32(float* align 4 %2, i64 %3, i1 false, i32 3, i32 16)
   %E = 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<f32> stride i64
   // CHECK: call void @llvm.matrix.column.major.store.v48f32(<48 x float> %7, float* align 4 %2, i64 %3, i1 false, i32 3, i32 16)
   llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride>
     { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
     vector<48 x f32> to !llvm.ptr<f32> stride i64
   llvm.return
 }
 
 // CHECK-LABEL: @get_active_lane_mask
 llvm.func @get_active_lane_mask(%base: i64, %n: i64) -> (vector<7xi1>) {
   // CHECK: call <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64 %0, i64 %1)
   %0 = llvm.intr.get.active.lane.mask %base, %n : i64, i64 to vector<7xi1>
   llvm.return %0 : vector<7xi1>
 }
 
 // CHECK-LABEL: @masked_load_store_intrinsics
 llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr<vector<7xf32>>, %mask: vector<7xi1>) {
   // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0v7f32(<7 x float>* %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> undef)
   %a = llvm.intr.masked.load %A, %mask { alignment = 1: i32} :
     (!llvm.ptr<vector<7xf32>>, vector<7xi1>) -> vector<7xf32>
   // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0v7f32(<7 x float>* %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> %{{.*}})
   %b = llvm.intr.masked.load %A, %mask, %a { alignment = 1: i32} :
     (!llvm.ptr<vector<7xf32>>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
   // CHECK: call void @llvm.masked.store.v7f32.p0v7f32(<7 x float> %{{.*}}, <7 x float>* %0, i32 {{.*}}, <7 x i1> %{{.*}})
   llvm.intr.masked.store %b, %A, %mask { alignment = 1: i32} :
     vector<7xf32>, vector<7xi1> into !llvm.ptr<vector<7xf32>>
   llvm.return
 }
 
 // CHECK-LABEL: @masked_gather_scatter_intrinsics
 llvm.func @masked_gather_scatter_intrinsics(%M: !llvm.vec<7 x ptr<f32>>, %mask: vector<7xi1>) {
   // CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0f32(<7 x float*> %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> undef)
   %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
       (!llvm.vec<7 x ptr<f32>>, vector<7xi1>) -> vector<7xf32>
   // CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0f32(<7 x float*> %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> %{{.*}})
   %b = llvm.intr.masked.gather %M, %mask, %a { alignment = 1: i32} :
       (!llvm.vec<7 x ptr<f32>>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
   // CHECK: call void @llvm.masked.scatter.v7f32.v7p0f32(<7 x float> %{{.*}}, <7 x float*> %{{.*}}, i32 1, <7 x i1> %{{.*}})
   llvm.intr.masked.scatter %b, %M, %mask { alignment = 1: i32} :
       vector<7xf32>, vector<7xi1> into !llvm.vec<7 x ptr<f32>>
   llvm.return
 }
 
 // CHECK-LABEL: @masked_expand_compress_intrinsics
 llvm.func @masked_expand_compress_intrinsics(%ptr: !llvm.ptr<f32>, %mask: vector<7xi1>, %passthru: vector<7xf32>) {
   // CHECK: call <7 x float> @llvm.masked.expandload.v7f32(float* %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})
   %0 = "llvm.intr.masked.expandload"(%ptr, %mask, %passthru)
     : (!llvm.ptr<f32>, vector<7xi1>, vector<7xf32>) -> (vector<7xf32>)
   // CHECK: call void @llvm.masked.compressstore.v7f32(<7 x float> %{{.*}}, float* %{{.*}}, <7 x i1> %{{.*}})
   "llvm.intr.masked.compressstore"(%0, %ptr, %mask)
     : (vector<7xf32>, !llvm.ptr<f32>, vector<7xi1>) -> ()
   llvm.return
 }
 
 // CHECK-LABEL: @memcpy_test
 llvm.func @memcpy_test(%arg0: i32, %arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>) {
   %i1 = llvm.mlir.constant(false) : i1
   // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %{{.*}}, i8* %{{.*}}, i32 %{{.*}}, i1 {{.*}})
   "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %i1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
   %sz = llvm.mlir.constant(10: i64) : i64
   // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* %{{.*}}, i8* %{{.*}}, i64 10, i1 {{.*}})
   "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %i1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
   llvm.return
 }
 
 // CHECK-LABEL: @sadd_with_overflow_test
 llvm.func @sadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.sadd.with.overflow.i32
   "llvm.intr.sadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32
   "llvm.intr.sadd.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @uadd_with_overflow_test
 llvm.func @uadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.uadd.with.overflow.i32
   "llvm.intr.uadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32
   "llvm.intr.uadd.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @ssub_with_overflow_test
 llvm.func @ssub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.ssub.with.overflow.i32
   "llvm.intr.ssub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32
   "llvm.intr.ssub.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @usub_with_overflow_test
 llvm.func @usub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.usub.with.overflow.i32
   "llvm.intr.usub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32
   "llvm.intr.usub.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @smul_with_overflow_test
 llvm.func @smul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.smul.with.overflow.i32
   "llvm.intr.smul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32
   "llvm.intr.smul.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @umul_with_overflow_test
 llvm.func @umul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {
   // CHECK: call { i32, i1 } @llvm.umul.with.overflow.i32
   "llvm.intr.umul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
   // CHECK: call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32
   "llvm.intr.umul.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   llvm.return
 }
 
 // CHECK-LABEL: @coro_id
 llvm.func @coro_id(%arg0: i32, %arg1: !llvm.ptr<i8>) {
   // CHECK: call token @llvm.coro.id
   %null = llvm.mlir.null : !llvm.ptr<i8>
   llvm.intr.coro.id %arg0, %arg1, %arg1, %null : !llvm.token
   llvm.return
 }
 
 // CHECK-LABEL: @coro_begin
 llvm.func @coro_begin(%arg0: i32, %arg1: !llvm.ptr<i8>) {
   %null = llvm.mlir.null : !llvm.ptr<i8>
   %token = llvm.intr.coro.id %arg0, %arg1, %arg1, %null : !llvm.token
   // CHECK: call i8* @llvm.coro.begin
   llvm.intr.coro.begin %token, %arg1 : !llvm.ptr<i8>
   llvm.return
 }
 
 // CHECK-LABEL: @coro_size
 llvm.func @coro_size() {
   // CHECK: call i64 @llvm.coro.size.i64
   %0 = llvm.intr.coro.size : i64
   // CHECK: call i32 @llvm.coro.size.i32
   %1 = llvm.intr.coro.size : i32
   llvm.return
 }
 
 // CHECK-LABEL: @coro_save
 llvm.func @coro_save(%arg0: !llvm.ptr<i8>) {
   // CHECK: call token @llvm.coro.save
   %0 = llvm.intr.coro.save %arg0 : !llvm.token
   llvm.return
 }
 
 // CHECK-LABEL: @coro_suspend
 llvm.func @coro_suspend(%arg0: i32, %arg1 : i1, %arg2 : !llvm.ptr<i8>) {
   %null = llvm.mlir.null : !llvm.ptr<i8>
   %token = llvm.intr.coro.id %arg0, %arg2, %arg2, %null : !llvm.token
   // CHECK: call i8 @llvm.coro.suspend
   %0 = llvm.intr.coro.suspend %token, %arg1 : i8
   llvm.return
 }
 
 // CHECK-LABEL: @coro_end
 llvm.func @coro_end(%arg0: !llvm.ptr<i8>, %arg1 : i1) {
   // CHECK: call i1 @llvm.coro.end
   %0 = llvm.intr.coro.end %arg0, %arg1 : i1
   llvm.return
 }
 
 // CHECK-LABEL: @coro_free
 llvm.func @coro_free(%arg0: i32, %arg1 : !llvm.ptr<i8>) {
   %null = llvm.mlir.null : !llvm.ptr<i8>
   %token = llvm.intr.coro.id %arg0, %arg1, %arg1, %null : !llvm.token
   // CHECK: call i8* @llvm.coro.free
   %0 = llvm.intr.coro.free %token, %arg1 : !llvm.ptr<i8>
   llvm.return
 }
 
 // CHECK-LABEL: @coro_resume
 llvm.func @coro_resume(%arg0: !llvm.ptr<i8>) {
   // CHECK: call void @llvm.coro.resume
   llvm.intr.coro.resume %arg0
   llvm.return
 }
 
 // CHECK-LABEL: @stack_save
 llvm.func @stack_save() {
   // CHECK: call i8* @llvm.stacksave
   %0 = llvm.intr.stacksave : !llvm.ptr<i8>
   llvm.return
 }
 
 // CHECK-LABEL: @stack_restore
 llvm.func @stack_restore(%arg0: !llvm.ptr<i8>) {
   // CHECK: call void @llvm.stackrestore
   llvm.intr.stackrestore %arg0
   llvm.return
 }
 
 // Check that intrinsics are declared with appropriate types.
 // CHECK-DAG: declare float @llvm.fma.f32(float, float, float)
 // CHECK-DAG: declare <8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>) #0
 // CHECK-DAG: declare float @llvm.fmuladd.f32(float, float, float)
 // CHECK-DAG: declare <8 x float> @llvm.fmuladd.v8f32(<8 x float>, <8 x float>, <8 x float>) #0
 // CHECK-DAG: declare void @llvm.prefetch.p0i8(i8* nocapture readonly, i32 immarg, i32 immarg, i32)
 // CHECK-DAG: declare float @llvm.exp.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.exp.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.log.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.log.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.log10.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.log10.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.log2.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.log2.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.fabs.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.fabs.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.sqrt.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.sqrt.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.ceil.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.ceil.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.cos.f32(float)
 // CHECK-DAG: declare <8 x float> @llvm.cos.v8f32(<8 x float>) #0
 // CHECK-DAG: declare float @llvm.copysign.f32(float, float)
 // CHECK-DAG: declare <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float>, <48 x float>, i32 immarg, i32 immarg, i32 immarg)
 // CHECK-DAG: declare <48 x float> @llvm.matrix.transpose.v48f32(<48 x float>, i32 immarg, i32 immarg)
 // CHECK-DAG: declare <48 x float> @llvm.matrix.column.major.load.v48f32(float* nocapture, i64, i1 immarg, i32 immarg, i32 immarg)
 // CHECK-DAG: declare void @llvm.matrix.column.major.store.v48f32(<48 x float>, float* nocapture writeonly, i64, i1 immarg, i32 immarg, i32 immarg)
 // CHECK-DAG: declare <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64, i64)
 // CHECK-DAG: declare <7 x float> @llvm.masked.load.v7f32.p0v7f32(<7 x float>*, i32 immarg, <7 x i1>, <7 x float>)
 // CHECK-DAG: declare void @llvm.masked.store.v7f32.p0v7f32(<7 x float>, <7 x float>*, i32 immarg, <7 x i1>)
 // CHECK-DAG: declare <7 x float> @llvm.masked.gather.v7f32.v7p0f32(<7 x float*>, i32 immarg, <7 x i1>, <7 x float>)
 // CHECK-DAG: declare void @llvm.masked.scatter.v7f32.v7p0f32(<7 x float>, <7 x float*>, i32 immarg, <7 x i1>)
 // CHECK-DAG: declare <7 x float> @llvm.masked.expandload.v7f32(float*, <7 x i1>, <7 x float>)
 // CHECK-DAG: declare void @llvm.masked.compressstore.v7f32(<7 x float>, float*, <7 x i1>)
 // CHECK-DAG: declare void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i32, i1 immarg)
 // CHECK-DAG: declare void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64 immarg, i1 immarg)
 // CHECK-DAG: declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32)
 // CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32(<8 x i32>, <8 x i32>) #0
 // CHECK-DAG: declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32)
 // CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32(<8 x i32>, <8 x i32>) #0
 // CHECK-DAG: declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)
 // CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32(<8 x i32>, <8 x i32>) #0
 // CHECK-DAG: declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)
 // CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32(<8 x i32>, <8 x i32>) #0
 // CHECK-DAG: declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32)
 // CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32>, <8 x i32>) #0
 // CHECK-DAG: declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
 // CHECK-DAG: declare i8* @llvm.coro.begin(token, i8* writeonly)
 // CHECK-DAG: declare i64 @llvm.coro.size.i64()
 // CHECK-DAG: declare i32 @llvm.coro.size.i32()
 // CHECK-DAG: declare token @llvm.coro.save(i8*)
 // CHECK-DAG: declare i8 @llvm.coro.suspend(token, i1)
 // CHECK-DAG: declare i1 @llvm.coro.end(i8*, i1)
 // CHECK-DAG: declare i8* @llvm.coro.free(token, i8* nocapture readonly)
 // CHECK-DAG: declare void @llvm.coro.resume(i8*)

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

 // RUN: mlir-translate -verify-diagnostics -split-input-file -mlir-to-llvmir %s
 
 // expected-error @+1 {{unsupported module-level operation}}
 func @foo() {
   llvm.return
 }
 
 // -----
 
 // expected-error @+1 {{llvm.noalias attribute attached to LLVM non-pointer argument}}
 llvm.func @invalid_noalias(%arg0 : f32 {llvm.noalias = true}) -> f32 {
   llvm.return %arg0 : f32
 }
 
 // -----
 
 // expected-error @+1 {{llvm.sret attribute attached to LLVM non-pointer argument}}
 llvm.func @invalid_noalias(%arg0 : f32 {llvm.sret}) -> f32 {
   llvm.return %arg0 : f32
 }
 // -----
 
 // expected-error @+1 {{llvm.byval attribute attached to LLVM non-pointer argument}}
 llvm.func @invalid_noalias(%arg0 : f32 {llvm.byval}) -> f32 {
   llvm.return %arg0 : f32
 }
 
 // -----
 
 // expected-error @+1 {{llvm.align attribute attached to LLVM non-pointer argument}}
 llvm.func @invalid_align(%arg0 : f32 {llvm.align = 4}) -> f32 {
   llvm.return %arg0 : f32
 }
 
 // -----
 
 llvm.func @no_nested_struct() -> !llvm.array<2 x array<2 x array<2 x struct<(i32)>>>> {
   // expected-error @+1 {{struct types are not supported in constants}}
   %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)>>>>
 }
 
 // -----
 
 // expected-error @+1 {{unsupported constant value}}
 llvm.mlir.global internal constant @test([2.5, 7.4]) : !llvm.array<2 x f64>
 
 // -----
 
 // expected-error @+1 {{LLVM attribute 'noinline' does not expect a value}}
 llvm.func @passthrough_unexpected_value() attributes {passthrough = [["noinline", "42"]]}
 
 // -----
 
 // expected-error @+1 {{LLVM attribute 'alignstack' expects a value}}
 llvm.func @passthrough_expected_value() attributes {passthrough = ["alignstack"]}
 
 // -----
 
 // expected-error @+1 {{expected 'passthrough' to contain string or array attributes}}
 llvm.func @passthrough_wrong_type() attributes {passthrough = [42]}
 
 // -----
 
 // expected-error @+1 {{expected arrays within 'passthrough' to contain two strings}}
 llvm.func @passthrough_wrong_type() attributes {passthrough = [[42, 42]]}

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

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
 //
 // Primitives.
 //
 
 // CHECK: declare void @return_void()
 llvm.func @return_void() -> !llvm.void
 // CHECK: declare half @return_half()
 llvm.func @return_half() -> f16
 // CHECK: declare bfloat @return_bfloat()
 llvm.func @return_bfloat() -> bf16
 // CHECK: declare float @return_float()
 llvm.func @return_float() -> f32
 // CHECK: declare double @return_double()
 llvm.func @return_double() -> f64
 // CHECK: declare fp128 @return_fp128()
 llvm.func @return_fp128() -> f128
 // CHECK: declare x86_fp80 @return_x86_fp80()
 llvm.func @return_x86_fp80() -> f80
 // CHECK: declare ppc_fp128 @return_ppc_fp128()
 llvm.func @return_ppc_fp128() -> !llvm.ppc_fp128
 // CHECK: declare x86_mmx @return_x86_mmx()
 llvm.func @return_x86_mmx() -> !llvm.x86_mmx
 
 //
 // Functions.
 //
 
 // CHECK: declare void @f_void_i32(i32)
 llvm.func @f_void_i32(i32) -> !llvm.void
 // CHECK: declare i32 @f_i32_empty()
 llvm.func @f_i32_empty() -> i32
 // CHECK: declare i32 @f_i32_half_bfloat_float_double(half, bfloat, float, double)
 llvm.func @f_i32_half_bfloat_float_double(f16, bf16, f32, f64) -> i32
 // CHECK: declare i32 @f_i32_i32_i32(i32, i32)
 llvm.func @f_i32_i32_i32(i32, i32) -> i32
 // CHECK: declare void @f_void_variadic(...)
 llvm.func @f_void_variadic(...)
 // CHECK: declare void @f_void_i32_i32_variadic(i32, i32, ...)
 llvm.func @f_void_i32_i32_variadic(i32, i32, ...)
 // CHECK: declare i32 (i32)* @f_f_i32_i32()
 llvm.func @f_f_i32_i32() -> !llvm.ptr<func<i32 (i32)>>
 
 //
 // Integers.
 //
 
 // CHECK: declare i1 @return_i1()
 llvm.func @return_i1() -> i1
 // CHECK: declare i8 @return_i8()
 llvm.func @return_i8() -> i8
 // CHECK: declare i16 @return_i16()
 llvm.func @return_i16() -> i16
 // CHECK: declare i32 @return_i32()
 llvm.func @return_i32() -> i32
 // CHECK: declare i64 @return_i64()
 llvm.func @return_i64() -> i64
 // CHECK: declare i57 @return_i57()
 llvm.func @return_i57() -> i57
 // CHECK: declare i129 @return_i129()
 llvm.func @return_i129() -> i129
 
 //
 // Pointers.
 //
 
 // CHECK: declare i8* @return_pi8()
 llvm.func @return_pi8() -> !llvm.ptr<i8>
 // CHECK: declare float* @return_pfloat()
 llvm.func @return_pfloat() -> !llvm.ptr<f32>
 // CHECK: declare i8** @return_ppi8()
 llvm.func @return_ppi8() -> !llvm.ptr<ptr<i8>>
 // CHECK: declare i8***** @return_pppppi8()
 llvm.func @return_pppppi8() -> !llvm.ptr<ptr<ptr<ptr<ptr<i8>>>>>
 // CHECK: declare i8* @return_pi8_0()
 llvm.func @return_pi8_0() -> !llvm.ptr<i8, 0>
 // CHECK: declare i8 addrspace(1)* @return_pi8_1()
 llvm.func @return_pi8_1() -> !llvm.ptr<i8, 1>
 // CHECK: declare i8 addrspace(42)* @return_pi8_42()
 llvm.func @return_pi8_42() -> !llvm.ptr<i8, 42>
 // CHECK: declare i8 addrspace(42)* addrspace(9)* @return_ppi8_42_9()
 llvm.func @return_ppi8_42_9() -> !llvm.ptr<ptr<i8, 42>, 9>
 
 //
 // Vectors.
 //
 
 // CHECK: declare <4 x i32> @return_v4_i32()
 llvm.func @return_v4_i32() -> vector<4xi32>
 // CHECK: declare <4 x float> @return_v4_float()
 llvm.func @return_v4_float() -> vector<4xf32>
 // CHECK: declare <vscale x 4 x i32> @return_vs_4_i32()
 llvm.func @return_vs_4_i32() -> !llvm.vec<?x4 x i32>
 // CHECK: declare <vscale x 8 x half> @return_vs_8_half()
 llvm.func @return_vs_8_half() -> !llvm.vec<?x8 x f16>
 // CHECK: declare <4 x i8*> @return_v_4_pi8()
 llvm.func @return_v_4_pi8() -> !llvm.vec<4xptr<i8>>
 
 //
 // Arrays.
 //
 
 // CHECK: declare [10 x i32] @return_a10_i32()
 llvm.func @return_a10_i32() -> !llvm.array<10 x i32>
 // CHECK: declare [8 x float] @return_a8_float()
 llvm.func @return_a8_float() -> !llvm.array<8 x f32>
 // CHECK: declare [10 x i32 addrspace(4)*] @return_a10_pi32_4()
 llvm.func @return_a10_pi32_4() -> !llvm.array<10 x ptr<i32, 4>>
 // CHECK: declare [10 x [4 x float]] @return_a10_a4_float()
 llvm.func @return_a10_a4_float() -> !llvm.array<10 x array<4 x f32>>
 
 //
 // Literal structures.
 //
 
 // CHECK: declare {} @return_struct_empty()
 llvm.func @return_struct_empty() -> !llvm.struct<()>
 // CHECK: declare { i32 } @return_s_i32()
 llvm.func @return_s_i32() -> !llvm.struct<(i32)>
 // CHECK: declare { float, i32 } @return_s_float_i32()
 llvm.func @return_s_float_i32() -> !llvm.struct<(f32, i32)>
 // CHECK: declare { { i32 } } @return_s_s_i32()
 llvm.func @return_s_s_i32() -> !llvm.struct<(struct<(i32)>)>
 // CHECK: declare { i32, { i32 }, float } @return_s_i32_s_i32_float()
 llvm.func @return_s_i32_s_i32_float() -> !llvm.struct<(i32, struct<(i32)>, f32)>
 
 // CHECK: declare <{}> @return_sp_empty()
 llvm.func @return_sp_empty() -> !llvm.struct<packed ()>
 // CHECK: declare <{ i32 }> @return_sp_i32()
 llvm.func @return_sp_i32() -> !llvm.struct<packed (i32)>
 // CHECK: declare <{ float, i32 }> @return_sp_float_i32()
 llvm.func @return_sp_float_i32() -> !llvm.struct<packed (f32, i32)>
 // 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)>)>
 
 // -----
 // 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, void ()* }
 // CHECK: %self-recursive = type { %self-recursive* }
 // CHECK: %unpacked = type { i32 }
 // CHECK: %packed = type <{ i32 }>
 // CHECK: %"name with spaces and !^$@$#" = type <{ i32 }>
 // CHECK: %mutually-a = type { %mutually-b* }
 // CHECK: %mutually-b = type { %mutually-a addrspace(3)* }
 // CHECK: %struct-of-arrays = type { [10 x i32] }
 // CHECK: %array-of-structs = type { i32 }
 // CHECK: %ptr-to-struct = type { i8 }
 
 // CHECK: declare %empty
 llvm.func @return_s_empty() -> !llvm.struct<"empty", ()>
 // CHECK: declare %opaque
 llvm.func @return_s_opaque() -> !llvm.struct<"opaque", opaque>
 // CHECK: declare %long
 llvm.func @return_s_long() -> !llvm.struct<"long", (i32, struct<(i32, i1)>, f32, ptr<func<void ()>>)>
 // CHECK: declare %self-recursive
 llvm.func @return_s_self_recursive() -> !llvm.struct<"self-recursive", (ptr<struct<"self-recursive">>)>
 // CHECK: declare %unpacked
 llvm.func @return_s_unpacked() -> !llvm.struct<"unpacked", (i32)>
 // CHECK: declare %packed
 llvm.func @return_s_packed() -> !llvm.struct<"packed", packed (i32)>
 // CHECK: declare %"name with spaces and !^$@$#"
 llvm.func @return_s_symbols() -> !llvm.struct<"name with spaces and !^$@$#", packed (i32)>
 
 // CHECK: declare %mutually-a
 llvm.func @return_s_mutually_a() -> !llvm.struct<"mutually-a", (ptr<struct<"mutually-b", (ptr<struct<"mutually-a">, 3>)>>)>
 // CHECK: declare %mutually-b
 llvm.func @return_s_mutually_b() -> !llvm.struct<"mutually-b", (ptr<struct<"mutually-a", (ptr<struct<"mutually-b">>)>, 3>)>
 
 // CHECK: declare %struct-of-arrays
 llvm.func @return_s_struct_of_arrays() -> !llvm.struct<"struct-of-arrays", (array<10 x i32>)>
 // CHECK: declare [10 x %array-of-structs]
 llvm.func @return_s_array_of_structs() -> !llvm.array<10 x struct<"array-of-structs", (i32)>>
 // CHECK: declare %ptr-to-struct*
 llvm.func @return_s_ptr_to_struct() -> !llvm.ptr<struct<"ptr-to-struct", (i8)>>

mlir/test/Target/LLVMIR/llvmir.mlir

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
 // CHECK: @i32_global = internal global i32 42
 llvm.mlir.global internal @i32_global(42: i32) : i32
 
 // CHECK: @i32_const = internal constant i53 52
 llvm.mlir.global internal constant @i32_const(52: i53) : i53
 
 // CHECK: @int_global_array = internal global [3 x i32] [i32 62, i32 62, i32 62]
 llvm.mlir.global internal @int_global_array(dense<62> : vector<3xi32>) : !llvm.array<3 x i32>
 
 // CHECK: @i32_global_addr_space = internal addrspace(7) global i32 62
 llvm.mlir.global internal @i32_global_addr_space(62: i32) {addr_space = 7 : i32} : i32
 
 // CHECK: @float_global = internal global float 0.000000e+00
 llvm.mlir.global internal @float_global(0.0: f32) : f32
 
 // CHECK: @float_global_array = internal global [1 x float] [float -5.000000e+00]
 llvm.mlir.global internal @float_global_array(dense<[-5.0]> : vector<1xf32>) : !llvm.array<1 x f32>
 
 // CHECK: @string_const = internal constant [6 x i8] c"foobar"
 llvm.mlir.global internal constant @string_const("foobar") : !llvm.array<6 x i8>
 
 // CHECK: @int_global_undef = internal global i64 undef
 llvm.mlir.global internal @int_global_undef() : i64
 
 // CHECK: @int_gep = internal constant i32* getelementptr (i32, i32* @i32_global, i32 2)
 llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> {
   %addr = llvm.mlir.addressof @i32_global : !llvm.ptr<i32>
   %_c0 = llvm.mlir.constant(2: i32) :i32
   %gepinit = llvm.getelementptr %addr[%_c0] : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
   llvm.return %gepinit : !llvm.ptr<i32>
 }
 
 //
 // Linkage attribute.
 //
 
 // CHECK: @private = private global i32 42
 llvm.mlir.global private @private(42 : i32) : i32
 // CHECK: @internal = internal global i32 42
 llvm.mlir.global internal @internal(42 : i32) : i32
 // CHECK: @available_externally = available_externally global i32 42
 llvm.mlir.global available_externally @available_externally(42 : i32) : i32
 // CHECK: @linkonce = linkonce global i32 42
 llvm.mlir.global linkonce @linkonce(42 : i32) : i32
 // CHECK: @weak = weak global i32 42
 llvm.mlir.global weak @weak(42 : i32) : i32
 // CHECK: @common = common global i32 0
 llvm.mlir.global common @common(0 : i32) : i32
 // CHECK: @appending = appending global [3 x i32] [i32 1, i32 2, i32 3]
 llvm.mlir.global appending @appending(dense<[1,2,3]> : vector<3xi32>) : !llvm.array<3xi32>
 // CHECK: @extern_weak = extern_weak global i32
 llvm.mlir.global extern_weak @extern_weak() : i32
 // CHECK: @linkonce_odr = linkonce_odr global i32 42
 llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32
 // CHECK: @weak_odr = weak_odr global i32 42
 llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32
 // CHECK: @external = external global i32
 llvm.mlir.global external @external() : i32
 
 
 //
 // Declarations of the allocation functions to be linked against. These are
 // inserted before other functions in the module.
 //
 
 // CHECK: declare i8* @malloc(i64)
 llvm.func @malloc(i64) -> !llvm.ptr<i8>
 // CHECK: declare void @free(i8*)
 
 
 //
 // Basic functionality: function and block conversion, function calls,
 // phi nodes, scalar type conversion, arithmetic operations.
 //
 
 // CHECK-LABEL: define void @empty()
 // CHECK-NEXT:    ret void
 // CHECK-NEXT:  }
 llvm.func @empty() {
   llvm.return
 }
 
 // CHECK-LABEL: @global_refs
 llvm.func @global_refs() {
   // Check load from globals.
   // CHECK: load i32, i32* @i32_global
   %0 = llvm.mlir.addressof @i32_global : !llvm.ptr<i32>
   %1 = llvm.load %0 : !llvm.ptr<i32>
 
   // Check the contracted form of load from array constants.
   // CHECK: load i8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @string_const, i64 0, i64 0)
   %2 = llvm.mlir.addressof @string_const : !llvm.ptr<array<6 x i8>>
   %c0 = llvm.mlir.constant(0 : index) : i64
   %3 = llvm.getelementptr %2[%c0, %c0] : (!llvm.ptr<array<6 x i8>>, i64, i64) -> !llvm.ptr<i8>
   %4 = llvm.load %3 : !llvm.ptr<i8>
 
   llvm.return
 }
 
 // CHECK-LABEL: declare void @body(i64)
 llvm.func @body(i64)
 
 
 // CHECK-LABEL: define void @simple_loop()
 llvm.func @simple_loop() {
 // CHECK: br label %[[SIMPLE_bb1:[0-9]+]]
   llvm.br ^bb1
 
 // Constants are inlined in LLVM rather than a separate instruction.
 // CHECK: [[SIMPLE_bb1]]:
 // CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0
   %0 = llvm.mlir.constant(1 : index) : i64
   %1 = llvm.mlir.constant(42 : index) : i64
   llvm.br ^bb2(%0 : i64)
 
 // CHECK: [[SIMPLE_bb2]]:
 // CHECK-NEXT:   %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %[[SIMPLE_bb3:[0-9]+]] ], [ 1, %[[SIMPLE_bb1]] ]
 // CHECK-NEXT:   %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 42
 // CHECK-NEXT:   br i1 %{{[0-9]+}}, label %[[SIMPLE_bb3]], label %[[SIMPLE_bb4:[0-9]+]]
 ^bb2(%2: i64): // 2 preds: ^bb1, ^bb3
   %3 = llvm.icmp "slt" %2, %1 : i64
   llvm.cond_br %3, ^bb3, ^bb4
 
 // CHECK: [[SIMPLE_bb3]]:
 // CHECK-NEXT:   call void @body(i64 %{{[0-9]+}})
 // CHECK-NEXT:   %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
 // CHECK-NEXT:   br label %[[SIMPLE_bb2]]
 ^bb3:   // pred: ^bb2
   llvm.call @body(%2) : (i64) -> ()
   %4 = llvm.mlir.constant(1 : index) : i64
   %5 = llvm.add %2, %4 : i64
   llvm.br ^bb2(%5 : i64)
 
 // CHECK: [[SIMPLE_bb4]]:
 // CHECK-NEXT:    ret void
 ^bb4:   // pred: ^bb2
   llvm.return
 }
 
 // CHECK-LABEL: define void @simple_caller()
 // CHECK-NEXT:   call void @simple_loop()
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 llvm.func @simple_caller() {
   llvm.call @simple_loop() : () -> ()
   llvm.return
 }
 
 //func @simple_indirect_caller() {
 //^bb0:
 //  %f = constant @simple_loop : () -> ()
 //  call_indirect %f() : () -> ()
 //  return
 //}
 
 // CHECK-LABEL: define void @ml_caller()
 // CHECK-NEXT:   call void @simple_loop()
 // CHECK-NEXT:   call void @more_imperfectly_nested_loops()
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 llvm.func @ml_caller() {
   llvm.call @simple_loop() : () -> ()
   llvm.call @more_imperfectly_nested_loops() : () -> ()
   llvm.return
 }
 
 // CHECK-LABEL: declare i64 @body_args(i64)
 llvm.func @body_args(i64) -> i64
 // CHECK-LABEL: declare i32 @other(i64, i32)
 llvm.func @other(i64, i32) -> i32
 
 // CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}})
 // CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]]
 llvm.func @func_args(%arg0: i32, %arg1: i32) -> i32 {
   %0 = llvm.mlir.constant(0 : i32) : i32
   llvm.br ^bb1
 
 // CHECK: [[ARGS_bb1]]:
 // CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0
   %1 = llvm.mlir.constant(0 : index) : i64
   %2 = llvm.mlir.constant(42 : index) : i64
   llvm.br ^bb2(%1 : i64)
 
 // CHECK: [[ARGS_bb2]]:
 // CHECK-NEXT:   %5 = phi i64 [ %12, %[[ARGS_bb3:[0-9]+]] ], [ 0, %[[ARGS_bb1]] ]
 // CHECK-NEXT:   %6 = icmp slt i64 %5, 42
 // CHECK-NEXT:   br i1 %6, label %[[ARGS_bb3]], label %[[ARGS_bb4:[0-9]+]]
 ^bb2(%3: i64): // 2 preds: ^bb1, ^bb3
   %4 = llvm.icmp "slt" %3, %2 : i64
   llvm.cond_br %4, ^bb3, ^bb4
 
 // CHECK: [[ARGS_bb3]]:
 // CHECK-NEXT:   %8 = call i64 @body_args(i64 %5)
 // CHECK-NEXT:   %9 = call i32 @other(i64 %8, i32 %0)
 // CHECK-NEXT:   %10 = call i32 @other(i64 %8, i32 %9)
 // CHECK-NEXT:   %11 = call i32 @other(i64 %8, i32 %1)
 // CHECK-NEXT:   %12 = add i64 %5, 1
 // CHECK-NEXT:   br label %[[ARGS_bb2]]
 ^bb3:   // pred: ^bb2
   %5 = llvm.call @body_args(%3) : (i64) -> i64
   %6 = llvm.call @other(%5, %arg0) : (i64, i32) -> i32
   %7 = llvm.call @other(%5, %6) : (i64, i32) -> i32
   %8 = llvm.call @other(%5, %arg1) : (i64, i32) -> i32
   %9 = llvm.mlir.constant(1 : index) : i64
   %10 = llvm.add %3, %9 : i64
   llvm.br ^bb2(%10 : i64)
 
 // CHECK: [[ARGS_bb4]]:
 // CHECK-NEXT:   %14 = call i32 @other(i64 0, i32 0)
 // CHECK-NEXT:   ret i32 %14
 ^bb4:   // pred: ^bb2
   %11 = llvm.mlir.constant(0 : index) : i64
   %12 = llvm.call @other(%11, %0) : (i64, i32) -> i32
   llvm.return %12 : i32
 }
 
 // CHECK: declare void @pre(i64)
 llvm.func @pre(i64)
 
 // CHECK: declare void @body2(i64, i64)
 llvm.func @body2(i64, i64)
 
 // CHECK: declare void @post(i64)
 llvm.func @post(i64)
 
 // CHECK-LABEL: define void @imperfectly_nested_loops()
 // CHECK-NEXT:   br label %[[IMPER_bb1:[0-9]+]]
 llvm.func @imperfectly_nested_loops() {
   llvm.br ^bb1
 
 // CHECK: [[IMPER_bb1]]:
 // CHECK-NEXT:   br label %[[IMPER_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0
   %0 = llvm.mlir.constant(0 : index) : i64
   %1 = llvm.mlir.constant(42 : index) : i64
   llvm.br ^bb2(%0 : i64)
 
 // CHECK: [[IMPER_bb2]]:
 // CHECK-NEXT:   %3 = phi i64 [ %13, %[[IMPER_bb7:[0-9]+]] ], [ 0, %[[IMPER_bb1]] ]
 // CHECK-NEXT:   %4 = icmp slt i64 %3, 42
 // CHECK-NEXT:   br i1 %4, label %[[IMPER_bb3:[0-9]+]], label %[[IMPER_bb8:[0-9]+]]
 ^bb2(%2: i64): // 2 preds: ^bb1, ^bb7
   %3 = llvm.icmp "slt" %2, %1 : i64
   llvm.cond_br %3, ^bb3, ^bb8
 
 // CHECK: [[IMPER_bb3]]:
 // CHECK-NEXT:   call void @pre(i64 %3)
 // CHECK-NEXT:   br label %[[IMPER_bb4:[0-9]+]]
 ^bb3:   // pred: ^bb2
   llvm.call @pre(%2) : (i64) -> ()
   llvm.br ^bb4
 
 // CHECK: [[IMPER_bb4]]:
 // CHECK-NEXT:   br label %[[IMPER_bb5:[0-9]+]]
 ^bb4:   // pred: ^bb3
   %4 = llvm.mlir.constant(7 : index) : i64
   %5 = llvm.mlir.constant(56 : index) : i64
   llvm.br ^bb5(%4 : i64)
 
 // CHECK: [[IMPER_bb5]]:
 // CHECK-NEXT:   %8 = phi i64 [ %11, %[[IMPER_bb6:[0-9]+]] ], [ 7, %[[IMPER_bb4]] ]
 // CHECK-NEXT:   %9 = icmp slt i64 %8, 56
 // CHECK-NEXT:   br i1 %9, label %[[IMPER_bb6]], label %[[IMPER_bb7]]
 ^bb5(%6: i64): // 2 preds: ^bb4, ^bb6
   %7 = llvm.icmp "slt" %6, %5 : i64
   llvm.cond_br %7, ^bb6, ^bb7
 
 // CHECK: [[IMPER_bb6]]:
 // CHECK-NEXT:   call void @body2(i64 %3, i64 %8)
 // CHECK-NEXT:   %11 = add i64 %8, 2
 // CHECK-NEXT:   br label %[[IMPER_bb5]]
 ^bb6:   // pred: ^bb5
   llvm.call @body2(%2, %6) : (i64, i64) -> ()
   %8 = llvm.mlir.constant(2 : index) : i64
   %9 = llvm.add %6, %8 : i64
   llvm.br ^bb5(%9 : i64)
 
 // CHECK: [[IMPER_bb7]]:
 // CHECK-NEXT:   call void @post(i64 %3)
 // CHECK-NEXT:   %13 = add i64 %3, 1
 // CHECK-NEXT:   br label %[[IMPER_bb2]]
 ^bb7:   // pred: ^bb5
   llvm.call @post(%2) : (i64) -> ()
   %10 = llvm.mlir.constant(1 : index) : i64
   %11 = llvm.add %2, %10 : i64
   llvm.br ^bb2(%11 : i64)
 
 // CHECK: [[IMPER_bb8]]:
 // CHECK-NEXT:   ret void
 ^bb8:   // pred: ^bb2
   llvm.return
 }
 
 // CHECK: declare void @mid(i64)
 llvm.func @mid(i64)
 
 // CHECK: declare void @body3(i64, i64)
 llvm.func @body3(i64, i64)
 
 // A complete function transformation check.
 // CHECK-LABEL: define void @more_imperfectly_nested_loops()
 // CHECK-NEXT:   br label %1
 // CHECK: 1:                                      ; preds = %0
 // CHECK-NEXT:   br label %2
 // CHECK: 2:                                      ; preds = %19, %1
 // CHECK-NEXT:   %3 = phi i64 [ %20, %19 ], [ 0, %1 ]
 // CHECK-NEXT:   %4 = icmp slt i64 %3, 42
 // CHECK-NEXT:   br i1 %4, label %5, label %21
 // CHECK: 5:                                      ; preds = %2
 // CHECK-NEXT:   call void @pre(i64 %3)
 // CHECK-NEXT:   br label %6
 // CHECK: 6:                                      ; preds = %5
 // CHECK-NEXT:   br label %7
 // CHECK: 7:                                      ; preds = %10, %6
 // CHECK-NEXT:   %8 = phi i64 [ %11, %10 ], [ 7, %6 ]
 // CHECK-NEXT:   %9 = icmp slt i64 %8, 56
 // CHECK-NEXT:   br i1 %9, label %10, label %12
 // CHECK: 10:                                     ; preds = %7
 // CHECK-NEXT:   call void @body2(i64 %3, i64 %8)
 // CHECK-NEXT:   %11 = add i64 %8, 2
 // CHECK-NEXT:   br label %7
 // CHECK: 12:                                     ; preds = %7
 // CHECK-NEXT:   call void @mid(i64 %3)
 // CHECK-NEXT:   br label %13
 // CHECK: 13:                                     ; preds = %12
 // CHECK-NEXT:   br label %14
 // CHECK: 14:                                     ; preds = %17, %13
 // CHECK-NEXT:   %15 = phi i64 [ %18, %17 ], [ 18, %13 ]
 // CHECK-NEXT:   %16 = icmp slt i64 %15, 37
 // CHECK-NEXT:   br i1 %16, label %17, label %19
 // CHECK: 17:                                     ; preds = %14
 // CHECK-NEXT:   call void @body3(i64 %3, i64 %15)
 // CHECK-NEXT:   %18 = add i64 %15, 3
 // CHECK-NEXT:   br label %14
 // CHECK: 19:                                     ; preds = %14
 // CHECK-NEXT:   call void @post(i64 %3)
 // CHECK-NEXT:   %20 = add i64 %3, 1
 // CHECK-NEXT:   br label %2
 // CHECK: 21:                                     ; preds = %2
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 llvm.func @more_imperfectly_nested_loops() {
   llvm.br ^bb1
 ^bb1: // pred: ^bb0
   %0 = llvm.mlir.constant(0 : index) : i64
   %1 = llvm.mlir.constant(42 : index) : i64
   llvm.br ^bb2(%0 : i64)
 ^bb2(%2: i64):  // 2 preds: ^bb1, ^bb11
   %3 = llvm.icmp "slt" %2, %1 : i64
   llvm.cond_br %3, ^bb3, ^bb12
 ^bb3: // pred: ^bb2
   llvm.call @pre(%2) : (i64) -> ()
   llvm.br ^bb4
 ^bb4: // pred: ^bb3
   %4 = llvm.mlir.constant(7 : index) : i64
   %5 = llvm.mlir.constant(56 : index) : i64
   llvm.br ^bb5(%4 : i64)
 ^bb5(%6: i64):  // 2 preds: ^bb4, ^bb6
   %7 = llvm.icmp "slt" %6, %5 : i64
   llvm.cond_br %7, ^bb6, ^bb7
 ^bb6: // pred: ^bb5
   llvm.call @body2(%2, %6) : (i64, i64) -> ()
   %8 = llvm.mlir.constant(2 : index) : i64
   %9 = llvm.add %6, %8 : i64
   llvm.br ^bb5(%9 : i64)
 ^bb7: // pred: ^bb5
   llvm.call @mid(%2) : (i64) -> ()
   llvm.br ^bb8
 ^bb8: // pred: ^bb7
   %10 = llvm.mlir.constant(18 : index) : i64
   %11 = llvm.mlir.constant(37 : index) : i64
   llvm.br ^bb9(%10 : i64)
 ^bb9(%12: i64): // 2 preds: ^bb8, ^bb10
   %13 = llvm.icmp "slt" %12, %11 : i64
   llvm.cond_br %13, ^bb10, ^bb11
 ^bb10:  // pred: ^bb9
   llvm.call @body3(%2, %12) : (i64, i64) -> ()
   %14 = llvm.mlir.constant(3 : index) : i64
   %15 = llvm.add %12, %14 : i64
   llvm.br ^bb9(%15 : i64)
 ^bb11:  // pred: ^bb9
   llvm.call @post(%2) : (i64) -> ()
   %16 = llvm.mlir.constant(1 : index) : i64
   %17 = llvm.add %2, %16 : i64
   llvm.br ^bb2(%17 : i64)
 ^bb12:  // pred: ^bb2
   llvm.return
 }
 
 
 //
 // Check that linkage is translated for functions. No need to check all linkage
 // flags since the logic is the same as for globals.
 //
 
 // CHECK: define internal void @func_internal
 llvm.func internal @func_internal() {
   llvm.return
 }
 
 //
 // MemRef type conversion, allocation and communication with functions.
 //
 
 // CHECK-LABEL: define void @memref_alloc()
 llvm.func @memref_alloc() {
 // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 400)
 // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
   %0 = llvm.mlir.constant(10 : index) : i64
   %1 = llvm.mlir.constant(10 : index) : i64
   %2 = llvm.mul %0, %1 : i64
   %3 = llvm.mlir.undef : !llvm.struct<(ptr<f32>)>
   %4 = llvm.mlir.constant(4 : index) : i64
   %5 = llvm.mul %2, %4 : i64
   %6 = llvm.call @malloc(%5) : (i64) -> !llvm.ptr<i8>
   %7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %8 = llvm.insertvalue %7, %3[0] : !llvm.struct<(ptr<f32>)>
 // CHECK-NEXT: ret void
   llvm.return
 }
 
 // CHECK-LABEL: declare i64 @get_index()
 llvm.func @get_index() -> i64
 
 // CHECK-LABEL: define void @store_load_static()
 llvm.func @store_load_static() {
 ^bb0:
 // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 40)
 // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
   %0 = llvm.mlir.constant(10 : index) : i64
   %1 = llvm.mlir.undef : !llvm.struct<(ptr<f32>)>
   %2 = llvm.mlir.constant(4 : index) : i64
   %3 = llvm.mul %0, %2 : i64
   %4 = llvm.call @malloc(%3) : (i64) -> !llvm.ptr<i8>
   %5 = llvm.bitcast %4 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %6 = llvm.insertvalue %5, %1[0] : !llvm.struct<(ptr<f32>)>
   %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32
   llvm.br ^bb1
 ^bb1:   // pred: ^bb0
   %8 = llvm.mlir.constant(0 : index) : i64
   %9 = llvm.mlir.constant(10 : index) : i64
   llvm.br ^bb2(%8 : i64)
 // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
 ^bb2(%10: i64):        // 2 preds: ^bb1, ^bb3
 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10
   %11 = llvm.icmp "slt" %10, %9 : i64
 // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
   llvm.cond_br %11, ^bb3, ^bb4
 ^bb3:   // pred: ^bb2
 // CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}}
   %12 = llvm.mlir.constant(10 : index) : i64
   %13 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<f32>)>
   %14 = llvm.getelementptr %13[%10] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %7, %14 : !llvm.ptr<f32>
   %15 = llvm.mlir.constant(1 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
   %16 = llvm.add %10, %15 : i64
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb2(%16 : i64)
 ^bb4:   // pred: ^bb2
   llvm.br ^bb5
 ^bb5:   // pred: ^bb4
   %17 = llvm.mlir.constant(0 : index) : i64
   %18 = llvm.mlir.constant(10 : index) : i64
   llvm.br ^bb6(%17 : i64)
 // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
 ^bb6(%19: i64):        // 2 preds: ^bb5, ^bb7
 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10
   %20 = llvm.icmp "slt" %19, %18 : i64
 // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
   llvm.cond_br %20, ^bb7, ^bb8
 ^bb7:   // pred: ^bb6
 // CHECK:      %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
   %21 = llvm.mlir.constant(10 : index) : i64
   %22 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<f32>)>
   %23 = llvm.getelementptr %22[%19] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   %24 = llvm.load %23 : !llvm.ptr<f32>
   %25 = llvm.mlir.constant(1 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
   %26 = llvm.add %19, %25 : i64
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb6(%26 : i64)
 ^bb8:   // pred: ^bb6
 // CHECK: ret void
   llvm.return
 }
 
 // CHECK-LABEL: define void @store_load_dynamic(i64 {{%.*}})
 llvm.func @store_load_dynamic(%arg0: i64) {
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
   %0 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64)>
   %1 = llvm.mlir.constant(4 : index) : i64
   %2 = llvm.mul %arg0, %1 : i64
   %3 = llvm.call @malloc(%2) : (i64) -> !llvm.ptr<i8>
   %4 = llvm.bitcast %3 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %5 = llvm.insertvalue %4, %0[0] : !llvm.struct<(ptr<f32>, i64)>
   %6 = llvm.insertvalue %arg0, %5[1] : !llvm.struct<(ptr<f32>, i64)>
   %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb1
 ^bb1:   // pred: ^bb0
   %8 = llvm.mlir.constant(0 : index) : i64
   llvm.br ^bb2(%8 : i64)
 // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
 ^bb2(%9: i64): // 2 preds: ^bb1, ^bb3
 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}
   %10 = llvm.icmp "slt" %9, %arg0 : i64
 // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
   llvm.cond_br %10, ^bb3, ^bb4
 ^bb3:   // pred: ^bb2
 // CHECK:      %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}}
   %11 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<f32>, i64)>
   %12 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<f32>, i64)>
   %13 = llvm.getelementptr %12[%9] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %7, %13 : !llvm.ptr<f32>
   %14 = llvm.mlir.constant(1 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
   %15 = llvm.add %9, %14 : i64
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb2(%15 : i64)
 ^bb4:   // pred: ^bb3
   llvm.br ^bb5
 ^bb5:   // pred: ^bb4
   %16 = llvm.mlir.constant(0 : index) : i64
   llvm.br ^bb6(%16 : i64)
 // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
 ^bb6(%17: i64):        // 2 preds: ^bb5, ^bb7
 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}
   %18 = llvm.icmp "slt" %17, %arg0 : i64
 // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
   llvm.cond_br %18, ^bb7, ^bb8
 ^bb7:   // pred: ^bb6
 // CHECK:      %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
   %19 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<f32>, i64)>
   %20 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<f32>, i64)>
   %21 = llvm.getelementptr %20[%17] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   %22 = llvm.load %21 : !llvm.ptr<f32>
   %23 = llvm.mlir.constant(1 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
   %24 = llvm.add %17, %23 : i64
 // CHECK-NEXT: br label %{{[0-9]+}}
   llvm.br ^bb6(%24 : i64)
 ^bb8:   // pred: ^bb6
 // CHECK: ret void
   llvm.return
 }
 
 // CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}})
 llvm.func @store_load_mixed(%arg0: i64) {
   %0 = llvm.mlir.constant(10 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } undef, float* %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 10, 2
   %1 = llvm.mlir.constant(2 : index) : i64
   %2 = llvm.mlir.constant(4 : index) : i64
   %3 = llvm.mul %1, %arg0 : i64
   %4 = llvm.mul %3, %2 : i64
   %5 = llvm.mul %4, %0 : i64
   %6 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64, i64)>
   %7 = llvm.mlir.constant(4 : index) : i64
   %8 = llvm.mul %5, %7 : i64
   %9 = llvm.call @malloc(%8) : (i64) -> !llvm.ptr<i8>
   %10 = llvm.bitcast %9 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %11 = llvm.insertvalue %10, %6[0] : !llvm.struct<(ptr<f32>, i64, i64)>
   %12 = llvm.insertvalue %arg0, %11[1] : !llvm.struct<(ptr<f32>, i64, i64)>
   %13 = llvm.insertvalue %0, %12[2] : !llvm.struct<(ptr<f32>, i64, i64)>
 
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
   %14 = llvm.mlir.constant(1 : index) : i64
   %15 = llvm.mlir.constant(2 : index) : i64
   %16 = llvm.call @get_index() : () -> i64
   %17 = llvm.call @get_index() : () -> i64
   %18 = llvm.mlir.constant(4.200000e+01 : f32) : f32
   %19 = llvm.mlir.constant(2 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 1, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
   %20 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<f32>, i64, i64)>
   %21 = llvm.mlir.constant(4 : index) : i64
   %22 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<f32>, i64, i64)>
   %23 = llvm.mul %14, %20 : i64
   %24 = llvm.add %23, %15 : i64
   %25 = llvm.mul %24, %21 : i64
   %26 = llvm.add %25, %16 : i64
   %27 = llvm.mul %26, %22 : i64
   %28 = llvm.add %27, %17 : i64
   %29 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<f32>, i64, i64)>
   %30 = llvm.getelementptr %29[%28] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %18, %30 : !llvm.ptr<f32>
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
   %31 = llvm.mlir.constant(2 : index) : i64
   %32 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<f32>, i64, i64)>
   %33 = llvm.mlir.constant(4 : index) : i64
   %34 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<f32>, i64, i64)>
   %35 = llvm.mul %17, %32 : i64
   %36 = llvm.add %35, %16 : i64
   %37 = llvm.mul %36, %33 : i64
   %38 = llvm.add %37, %15 : i64
   %39 = llvm.mul %38, %34 : i64
   %40 = llvm.add %39, %14 : i64
   %41 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<f32>, i64, i64)>
   %42 = llvm.getelementptr %41[%40] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   %43 = llvm.load %42 : !llvm.ptr<f32>
 // CHECK-NEXT: ret void
   llvm.return
 }
 
 // CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}})
 llvm.func @memref_args_rets(%arg0: !llvm.struct<(ptr<f32>)>, %arg1: !llvm.struct<(ptr<f32>, i64)>, %arg2: !llvm.struct<(ptr<f32>, i64)>) -> !llvm.struct<(ptr<f32>, i64)> {
   %0 = llvm.mlir.constant(7 : index) : i64
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
   %1 = llvm.call @get_index() : () -> i64
   %2 = llvm.mlir.constant(4.200000e+01 : f32) : f32
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
 // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
   %3 = llvm.mlir.constant(10 : index) : i64
   %4 = llvm.extractvalue %arg0[0] : !llvm.struct<(ptr<f32>)>
   %5 = llvm.getelementptr %4[%0] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %2, %5 : !llvm.ptr<f32>
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
 // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
   %6 = llvm.extractvalue %arg1[1] : !llvm.struct<(ptr<f32>, i64)>
   %7 = llvm.extractvalue %arg1[0] : !llvm.struct<(ptr<f32>, i64)>
   %8 = llvm.getelementptr %7[%0] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %2, %8 : !llvm.ptr<f32>
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 7, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
 // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
   %9 = llvm.mlir.constant(10 : index) : i64
   %10 = llvm.extractvalue %arg2[1] : !llvm.struct<(ptr<f32>, i64)>
   %11 = llvm.mul %0, %10 : i64
   %12 = llvm.add %11, %1 : i64
   %13 = llvm.extractvalue %arg2[0] : !llvm.struct<(ptr<f32>, i64)>
   %14 = llvm.getelementptr %13[%12] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   llvm.store %2, %14 : !llvm.ptr<f32>
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 10, %{{[0-9]+}}
 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
 // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
 // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
   %15 = llvm.mlir.constant(10 : index) : i64
   %16 = llvm.mul %15, %1 : i64
   %17 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64)>
   %18 = llvm.mlir.constant(4 : index) : i64
   %19 = llvm.mul %16, %18 : i64
   %20 = llvm.call @malloc(%19) : (i64) -> !llvm.ptr<i8>
   %21 = llvm.bitcast %20 : !llvm.ptr<i8> to !llvm.ptr<f32>
   %22 = llvm.insertvalue %21, %17[0] : !llvm.struct<(ptr<f32>, i64)>
   %23 = llvm.insertvalue %1, %22[1] : !llvm.struct<(ptr<f32>, i64)>
 // CHECK-NEXT: ret { float*, i64 } %{{[0-9]+}}
   llvm.return %23 : !llvm.struct<(ptr<f32>, i64)>
 }
 
 
 // CHECK-LABEL: define i64 @memref_dim({ float*, i64, i64 } {{%.*}})
 llvm.func @memref_dim(%arg0: !llvm.struct<(ptr<f32>, i64, i64)>) -> i64 {
 // Expecting this to create an LLVM constant.
   %0 = llvm.mlir.constant(42 : index) : i64
 // CHECK-NEXT: %2 = extractvalue { float*, i64, i64 } %0, 1
   %1 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr<f32>, i64, i64)>
 // Expecting this to create an LLVM constant.
   %2 = llvm.mlir.constant(10 : index) : i64
 // CHECK-NEXT: %3 = extractvalue { float*, i64, i64 } %0, 2
   %3 = llvm.extractvalue %arg0[2] : !llvm.struct<(ptr<f32>, i64, i64)>
 // Checking that the constant for d0 has been created.
 // CHECK-NEXT: %4 = add i64 42, %2
   %4 = llvm.add %0, %1 : i64
 // Checking that the constant for d2 has been created.
 // CHECK-NEXT: %5 = add i64 10, %3
   %5 = llvm.add %2, %3 : i64
 // CHECK-NEXT: %6 = add i64 %4, %5
   %6 = llvm.add %4, %5 : i64
 // CHECK-NEXT: ret i64 %6
   llvm.return %6 : i64
 }
 
 llvm.func @get_i64() -> i64
 llvm.func @get_f32() -> f32
 llvm.func @get_memref() -> !llvm.struct<(ptr<f32>, i64, i64)>
 
 // CHECK-LABEL: define { i64, float, { float*, i64, i64 } } @multireturn()
 llvm.func @multireturn() -> !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)> {
   %0 = llvm.call @get_i64() : () -> i64
   %1 = llvm.call @get_f32() : () -> f32
   %2 = llvm.call @get_memref() : () -> !llvm.struct<(ptr<f32>, i64, i64)>
 // CHECK:        %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } undef, i64 %{{[0-9]+}}, 0
 // CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1
 // CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, { float*, i64, i64 } %{{[0-9]+}}, 2
 // CHECK-NEXT:   ret { i64, float, { float*, i64, i64 } } %{{[0-9]+}}
   %3 = llvm.mlir.undef : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %4 = llvm.insertvalue %0, %3[0] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %5 = llvm.insertvalue %1, %4[1] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %6 = llvm.insertvalue %2, %5[2] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   llvm.return %6 : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
 }
 
 
 // CHECK-LABEL: define void @multireturn_caller()
 llvm.func @multireturn_caller() {
 // CHECK-NEXT:   %1 = call { i64, float, { float*, i64, i64 } } @multireturn()
 // CHECK-NEXT:   [[ret0:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 0
 // CHECK-NEXT:   [[ret1:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 1
 // CHECK-NEXT:   [[ret2:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 2
   %0 = llvm.call @multireturn() : () -> !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %3 = llvm.extractvalue %0[2] : !llvm.struct<(i64, f32, struct<(ptr<f32>, i64, i64)>)>
   %4 = llvm.mlir.constant(42) : i64
 // CHECK:   add i64 [[ret0]], 42
   %5 = llvm.add %1, %4 : i64
   %6 = llvm.mlir.constant(4.200000e+01 : f32) : f32
 // CHECK:   fadd float [[ret1]], 4.200000e+01
   %7 = llvm.fadd %2, %6 : f32
   %8 = llvm.mlir.constant(0 : index) : i64
   %9 = llvm.mlir.constant(42 : index) : i64
 // CHECK:   extractvalue { float*, i64, i64 } [[ret2]], 0
   %10 = llvm.extractvalue %3[1] : !llvm.struct<(ptr<f32>, i64, i64)>
   %11 = llvm.mlir.constant(10 : index) : i64
   %12 = llvm.extractvalue %3[2] : !llvm.struct<(ptr<f32>, i64, i64)>
   %13 = llvm.mul %8, %10 : i64
   %14 = llvm.add %13, %8 : i64
   %15 = llvm.mul %14, %11 : i64
   %16 = llvm.add %15, %8 : i64
   %17 = llvm.mul %16, %12 : i64
   %18 = llvm.add %17, %8 : i64
   %19 = llvm.extractvalue %3[0] : !llvm.struct<(ptr<f32>, i64, i64)>
   %20 = llvm.getelementptr %19[%18] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   %21 = llvm.load %20 : !llvm.ptr<f32>
   llvm.return
 }
 
 // CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}})
 llvm.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>) -> vector<4xf32> {
   %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32>
 // CHECK-NEXT: %4 = fadd <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
   %1 = llvm.fadd %arg0, %0 : vector<4xf32>
 // CHECK-NEXT: %5 = select <4 x i1> %1, <4 x float> %4, <4 x float> %0
   %2 = llvm.select %arg1, %1, %arg0 : vector<4xi1>, vector<4xf32>
 // CHECK-NEXT: %6 = sdiv <4 x i64> %2, %2
   %3 = llvm.sdiv %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %7 = udiv <4 x i64> %2, %2
   %4 = llvm.udiv %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %8 = srem <4 x i64> %2, %2
   %5 = llvm.srem %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %9 = urem <4 x i64> %2, %2
   %6 = llvm.urem %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %10 = fdiv <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
   %7 = llvm.fdiv %arg0, %0 : vector<4xf32>
 // CHECK-NEXT: %11 = frem <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
   %8 = llvm.frem %arg0, %0 : vector<4xf32>
 // CHECK-NEXT: %12 = and <4 x i64> %2, %2
   %9 = llvm.and %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %13 = or <4 x i64> %2, %2
   %10 = llvm.or %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %14 = xor <4 x i64> %2, %2
   %11 = llvm.xor %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %15 = shl <4 x i64> %2, %2
   %12 = llvm.shl %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %16 = lshr <4 x i64> %2, %2
   %13 = llvm.lshr %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT: %17 = ashr <4 x i64> %2, %2
   %14 = llvm.ashr %arg2, %arg2 : vector<4xi64>
 // CHECK-NEXT:    ret <4 x float> %4
   llvm.return %1 : vector<4xf32>
 }
 
 // CHECK-LABEL: @vector_splat_1d
 llvm.func @vector_splat_1d() -> vector<4xf32> {
   // CHECK: ret <4 x float> zeroinitializer
   %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4xf32>) : vector<4xf32>
   llvm.return %0 : vector<4xf32>
 }
 
 // CHECK-LABEL: @vector_splat_2d
 llvm.func @vector_splat_2d() -> !llvm.array<4 x vector<16 x f32>> {
   // CHECK: ret [4 x <16 x float>] zeroinitializer
   %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4x16xf32>) : !llvm.array<4 x vector<16 x f32>>
   llvm.return %0 : !llvm.array<4 x vector<16 x f32>>
 }
 
 // CHECK-LABEL: @vector_splat_3d
 llvm.func @vector_splat_3d() -> !llvm.array<4 x array<16 x vector<4 x f32>>> {
   // CHECK: ret [4 x [16 x <4 x float>]] zeroinitializer
   %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4x16x4xf32>) : !llvm.array<4 x array<16 x vector<4 x f32>>>
   llvm.return %0 : !llvm.array<4 x array<16 x vector<4 x f32>>>
 }
 
 // CHECK-LABEL: @vector_splat_nonzero
 llvm.func @vector_splat_nonzero() -> vector<4xf32> {
   // CHECK: ret <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
   %0 = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>
   llvm.return %0 : vector<4xf32>
 }
 
 // CHECK-LABEL: @ops
 llvm.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32) -> !llvm.struct<(f32, i32)> {
 // CHECK-NEXT: fsub float %0, %1
   %0 = llvm.fsub %arg0, %arg1 : f32
 // CHECK-NEXT: %6 = sub i32 %2, %3
   %1 = llvm.sub %arg2, %arg3 : i32
 // CHECK-NEXT: %7 = icmp slt i32 %2, %6
   %2 = llvm.icmp "slt" %arg2, %1 : i32
 // CHECK-NEXT: %8 = select i1 %7, i32 %2, i32 %6
   %3 = llvm.select %2, %arg2, %1 : i1, i32
 // CHECK-NEXT: %9 = sdiv i32 %2, %3
   %4 = llvm.sdiv %arg2, %arg3 : i32
 // CHECK-NEXT: %10 = udiv i32 %2, %3
   %5 = llvm.udiv %arg2, %arg3 : i32
 // CHECK-NEXT: %11 = srem i32 %2, %3
   %6 = llvm.srem %arg2, %arg3 : i32
 // CHECK-NEXT: %12 = urem i32 %2, %3
   %7 = llvm.urem %arg2, %arg3 : i32
 
   %8 = llvm.mlir.undef : !llvm.struct<(f32, i32)>
   %9 = llvm.insertvalue %0, %8[0] : !llvm.struct<(f32, i32)>
   %10 = llvm.insertvalue %3, %9[1] : !llvm.struct<(f32, i32)>
 
 // CHECK: %15 = fdiv float %0, %1
   %11 = llvm.fdiv %arg0, %arg1 : f32
 // CHECK-NEXT: %16 = frem float %0, %1
   %12 = llvm.frem %arg0, %arg1 : f32
 
 // CHECK-NEXT: %17 = and i32 %2, %3
   %13 = llvm.and %arg2, %arg3 : i32
 // CHECK-NEXT: %18 = or i32 %2, %3
   %14 = llvm.or %arg2, %arg3 : i32
 // CHECK-NEXT: %19 = xor i32 %2, %3
   %15 = llvm.xor %arg2, %arg3 : i32
 // CHECK-NEXT: %20 = shl i32 %2, %3
   %16 = llvm.shl %arg2, %arg3 : i32
 // CHECK-NEXT: %21 = lshr i32 %2, %3
   %17 = llvm.lshr %arg2, %arg3 : i32
 // CHECK-NEXT: %22 = ashr i32 %2, %3
   %18 = llvm.ashr %arg2, %arg3 : i32
 
 // CHECK-NEXT: fneg float %0
   %19 = llvm.fneg %arg0 : f32
 
   llvm.return %10 : !llvm.struct<(f32, i32)>
 }
 
 //
 // Indirect function calls
 //
 
 // CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}})
 llvm.func @indirect_const_call(%arg0: i64) {
 // CHECK-NEXT:  call void @body(i64 %0)
   %0 = llvm.mlir.addressof @body : !llvm.ptr<func<void (i64)>>
   llvm.call %0(%arg0) : (i64) -> ()
 // CHECK-NEXT:  ret void
   llvm.return
 }
 
 // CHECK-LABEL: define i32 @indirect_call(i32 (float)* {{%.*}}, float {{%.*}})
 llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (f32)>>, %arg1: f32) -> i32 {
 // CHECK-NEXT:  %3 = call i32 %0(float %1)
   %0 = llvm.call %arg0(%arg1) : (f32) -> i32
 // CHECK-NEXT:  ret i32 %3
   llvm.return %0 : i32
 }
 
 //
 // Check that we properly construct phi nodes in the blocks that have the same
 // predecessor more than once.
 //
 
 // CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}})
 llvm.func @cond_br_arguments(%arg0: i1, %arg1: i1) {
 // CHECK-NEXT:   br i1 %0, label %3, label %5
   llvm.cond_br %arg0, ^bb1(%arg0 : i1), ^bb2
 
 // CHECK:      3:
 // CHECK-NEXT:   %4 = phi i1 [ %1, %5 ], [ %0, %2 ]
 ^bb1(%0 : i1):
 // CHECK-NEXT:   ret void
   llvm.return
 
 // CHECK:      5:
 ^bb2:
 // CHECK-NEXT:   br label %3
   llvm.br ^bb1(%arg1 : i1)
 }
 
 // CHECK-LABEL: define void @llvm_noalias(float* noalias {{%*.}})
 llvm.func @llvm_noalias(%arg0: !llvm.ptr<f32> {llvm.noalias = true}) {
   llvm.return
 }
 
 // CHECK-LABEL: define void @byvalattr(i32* byval(i32) %
 llvm.func @byvalattr(%arg0: !llvm.ptr<i32> {llvm.byval}) {
   llvm.return
 }
 
 // CHECK-LABEL: define void @sretattr(i32* sret(i32) %
 llvm.func @sretattr(%arg0: !llvm.ptr<i32> {llvm.sret}) {
   llvm.return
 }
 
 // CHECK-LABEL: define void @llvm_align(float* align 4 {{%*.}})
 llvm.func @llvm_align(%arg0: !llvm.ptr<f32> {llvm.align = 4}) {
   llvm.return
 }
 
 // CHECK-LABEL: @llvm_varargs(...)
 llvm.func @llvm_varargs(...)
 
 llvm.func @intpointerconversion(%arg0 : i32) -> i32 {
 // CHECK:      %2 = inttoptr i32 %0 to i32*
 // CHECK-NEXT: %3 = ptrtoint i32* %2 to i32
   %1 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
   %2 = llvm.ptrtoint %1 : !llvm.ptr<i32> to i32
   llvm.return %2 : i32
 }
 
 llvm.func @fpconversion(%arg0 : i32) -> i32 {
 // CHECK:      %2 = sitofp i32 %0 to float
 // CHECK-NEXT: %3 = fptosi float %2 to i32
 // CHECK-NEXT: %4 = uitofp i32 %3 to float
 // CHECK-NEXT: %5 = fptoui float %4 to i32
   %1 = llvm.sitofp %arg0 : i32 to f32
   %2 = llvm.fptosi %1 : f32 to i32
   %3 = llvm.uitofp %2 : i32 to f32
   %4 = llvm.fptoui %3 : f32 to i32
   llvm.return %4 : i32
 }
 
 // CHECK-LABEL: @addrspace
 llvm.func @addrspace(%arg0 : !llvm.ptr<i32>) -> !llvm.ptr<i32, 2> {
 // CHECK: %2 = addrspacecast i32* %0 to i32 addrspace(2)*
   %1 = llvm.addrspacecast %arg0 : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
   llvm.return %1 : !llvm.ptr<i32, 2>
 }
 
 llvm.func @stringconstant() -> !llvm.array<12 x i8> {
   %1 = llvm.mlir.constant("Hello world!") : !llvm.array<12 x i8>
   // CHECK: ret [12 x i8] c"Hello world!"
   llvm.return %1 : !llvm.array<12 x i8>
 }
 
 llvm.func @noreach() {
 // CHECK:    unreachable
   llvm.unreachable
 }
 
 // CHECK-LABEL: define void @fcmp
 llvm.func @fcmp(%arg0: f32, %arg1: f32) {
   // CHECK: fcmp oeq float %0, %1
   // CHECK-NEXT: fcmp ogt float %0, %1
   // CHECK-NEXT: fcmp oge float %0, %1
   // CHECK-NEXT: fcmp olt float %0, %1
   // CHECK-NEXT: fcmp ole float %0, %1
   // CHECK-NEXT: fcmp one float %0, %1
   // CHECK-NEXT: fcmp ord float %0, %1
   // CHECK-NEXT: fcmp ueq float %0, %1
   // CHECK-NEXT: fcmp ugt float %0, %1
   // CHECK-NEXT: fcmp uge float %0, %1
   // CHECK-NEXT: fcmp ult float %0, %1
   // CHECK-NEXT: fcmp ule float %0, %1
   // CHECK-NEXT: fcmp une float %0, %1
   // CHECK-NEXT: fcmp uno float %0, %1
   %0 = llvm.fcmp "oeq" %arg0, %arg1 : f32
   %1 = llvm.fcmp "ogt" %arg0, %arg1 : f32
   %2 = llvm.fcmp "oge" %arg0, %arg1 : f32
   %3 = llvm.fcmp "olt" %arg0, %arg1 : f32
   %4 = llvm.fcmp "ole" %arg0, %arg1 : f32
   %5 = llvm.fcmp "one" %arg0, %arg1 : f32
   %6 = llvm.fcmp "ord" %arg0, %arg1 : f32
   %7 = llvm.fcmp "ueq" %arg0, %arg1 : f32
   %8 = llvm.fcmp "ugt" %arg0, %arg1 : f32
   %9 = llvm.fcmp "uge" %arg0, %arg1 : f32
   %10 = llvm.fcmp "ult" %arg0, %arg1 : f32
   %11 = llvm.fcmp "ule" %arg0, %arg1 : f32
   %12 = llvm.fcmp "une" %arg0, %arg1 : f32
   %13 = llvm.fcmp "uno" %arg0, %arg1 : f32
   llvm.return
 }
 
 // CHECK-LABEL: @vect
 llvm.func @vect(%arg0: vector<4xf32>, %arg1: i32, %arg2: f32) {
   // CHECK-NEXT: extractelement <4 x float> {{.*}}, i32
   // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i32
   // CHECK-NEXT: shufflevector <4 x float> {{.*}}, <4 x float> {{.*}}, <5 x i32> <i32 0, i32 0, i32 0, i32 0, i32 7>
   %0 = llvm.extractelement %arg0[%arg1 : i32] : vector<4xf32>
   %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<4xf32>
   %2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : vector<4xf32>, vector<4xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @vect_i64idx
 llvm.func @vect_i64idx(%arg0: vector<4xf32>, %arg1: i64, %arg2: f32) {
   // CHECK-NEXT: extractelement <4 x float> {{.*}}, i64
   // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i64
   %0 = llvm.extractelement %arg0[%arg1 : i64] : vector<4xf32>
   %1 = llvm.insertelement %arg2, %arg0[%arg1 : i64] : vector<4xf32>
   llvm.return
 }
 
 // CHECK-LABEL: @alloca
 llvm.func @alloca(%size : i64) {
   // Alignment automatically set by the LLVM IR builder when alignment attribute
   // is 0.
   //  CHECK: alloca {{.*}} align 4
   llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<i32>)
   // CHECK-NEXT: alloca {{.*}} align 8
   llvm.alloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
   llvm.return
 }
 
 // CHECK-LABEL: @constants
 llvm.func @constants() -> vector<4xf32> {
   // CHECK: ret <4 x float> <float 4.2{{0*}}e+01, float 0.{{0*}}e+00, float 0.{{0*}}e+00, float 0.{{0*}}e+00>
   %0 = llvm.mlir.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : vector<4xf32>
   llvm.return %0 : vector<4xf32>
 }
 
 // CHECK-LABEL: @fp_casts
 llvm.func @fp_casts(%fp1 : f32, %fp2 : f64) -> i16 {
 // CHECK:    fptrunc double {{.*}} to float
   %a = llvm.fptrunc %fp2 : f64 to f32
 // CHECK:    fpext float {{.*}} to double
   %b = llvm.fpext %fp1 : f32 to f64
 // CHECK:    fptosi double {{.*}} to i16
   %c = llvm.fptosi %b : f64 to i16
   llvm.return %c : i16
 }
 
 // CHECK-LABEL: @integer_extension_and_truncation
 llvm.func @integer_extension_and_truncation(%a : i32) {
 // CHECK:    sext i32 {{.*}} to i64
 // CHECK:    zext i32 {{.*}} to i64
 // CHECK:    trunc i32 {{.*}} to i16
   %0 = llvm.sext %a : i32 to i64
   %1 = llvm.zext %a : i32 to i64
   %2 = llvm.trunc %a : i32 to i16
   llvm.return
 }
 
 // Check that the auxiliary `null` operation is converted into a `null` value.
 // CHECK-LABEL: @null
 llvm.func @null() -> !llvm.ptr<i32> {
   %0 = llvm.mlir.null : !llvm.ptr<i32>
   // CHECK: ret i32* null
   llvm.return %0 : !llvm.ptr<i32>
 }
 
 // Check that dense elements attributes are exported properly in constants.
 // CHECK-LABEL: @elements_constant_3d_vector
 llvm.func @elements_constant_3d_vector() -> !llvm.array<2 x array<2 x vector<2 x i32>>> {
   // CHECK: ret [2 x [2 x <2 x i32>]]
   // CHECK-SAME: {{\[}}[2 x <2 x i32>] [<2 x i32> <i32 1, i32 2>, <2 x i32> <i32 3, i32 4>],
   // CHECK-SAME:       [2 x <2 x i32>] [<2 x i32> <i32 42, i32 43>, <2 x i32> <i32 44, i32 45>]]
   %0 = llvm.mlir.constant(dense<[[[1, 2], [3, 4]], [[42, 43], [44, 45]]]> : vector<2x2x2xi32>) : !llvm.array<2 x array<2 x vector<2 x i32>>>
   llvm.return %0 : !llvm.array<2 x array<2 x vector<2 x i32>>>
 }
 
 // CHECK-LABEL: @elements_constant_3d_array
 llvm.func @elements_constant_3d_array() -> !llvm.array<2 x array<2 x array<2 x i32>>> {
   // CHECK: ret [2 x [2 x [2 x i32]]]
   // CHECK-SAME: {{\[}}[2 x [2 x i32]] {{\[}}[2 x i32] [i32 1, i32 2], [2 x i32] [i32 3, i32 4]],
   // CHECK-SAME:       [2 x [2 x i32]] {{\[}}[2 x i32] [i32 42, i32 43], [2 x i32] [i32 44, i32 45]]]
   %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 i32>>>
   llvm.return %0 : !llvm.array<2 x array<2 x array<2 x i32>>>
 }
 
 // CHECK-LABEL: @atomicrmw
 llvm.func @atomicrmw(
     %f32_ptr : !llvm.ptr<f32>, %f32 : f32,
     %i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
   // CHECK: atomicrmw fadd float* %{{.*}}, float %{{.*}} monotonic
   %0 = llvm.atomicrmw fadd %f32_ptr, %f32 monotonic : f32
   // CHECK: atomicrmw fsub float* %{{.*}}, float %{{.*}} monotonic
   %1 = llvm.atomicrmw fsub %f32_ptr, %f32 monotonic : f32
   // CHECK: atomicrmw xchg float* %{{.*}}, float %{{.*}} monotonic
   %2 = llvm.atomicrmw xchg %f32_ptr, %f32 monotonic : f32
   // CHECK: atomicrmw add i32* %{{.*}}, i32 %{{.*}} acquire
   %3 = llvm.atomicrmw add %i32_ptr, %i32 acquire : i32
   // CHECK: atomicrmw sub i32* %{{.*}}, i32 %{{.*}} release
   %4 = llvm.atomicrmw sub %i32_ptr, %i32 release : i32
   // CHECK: atomicrmw and i32* %{{.*}}, i32 %{{.*}} acq_rel
   %5 = llvm.atomicrmw _and %i32_ptr, %i32 acq_rel : i32
   // CHECK: atomicrmw nand i32* %{{.*}}, i32 %{{.*}} seq_cst
   %6 = llvm.atomicrmw nand %i32_ptr, %i32 seq_cst : i32
   // CHECK: atomicrmw or i32* %{{.*}}, i32 %{{.*}} monotonic
   %7 = llvm.atomicrmw _or %i32_ptr, %i32 monotonic : i32
   // CHECK: atomicrmw xor i32* %{{.*}}, i32 %{{.*}} monotonic
   %8 = llvm.atomicrmw _xor %i32_ptr, %i32 monotonic : i32
   // CHECK: atomicrmw max i32* %{{.*}}, i32 %{{.*}} monotonic
   %9 = llvm.atomicrmw max %i32_ptr, %i32 monotonic : i32
   // CHECK: atomicrmw min i32* %{{.*}}, i32 %{{.*}} monotonic
   %10 = llvm.atomicrmw min %i32_ptr, %i32 monotonic : i32
   // CHECK: atomicrmw umax i32* %{{.*}}, i32 %{{.*}} monotonic
   %11 = llvm.atomicrmw umax %i32_ptr, %i32 monotonic : i32
   // CHECK: atomicrmw umin i32* %{{.*}}, i32 %{{.*}} monotonic
   %12 = llvm.atomicrmw umin %i32_ptr, %i32 monotonic : i32
   llvm.return
 }
 
 // CHECK-LABEL: @cmpxchg
 llvm.func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : i32, %val: i32) {
   // CHECK: cmpxchg i32* %{{.*}}, i32 %{{.*}}, i32 %{{.*}} acq_rel monotonic
   %0 = llvm.cmpxchg %ptr, %cmp, %val acq_rel monotonic : i32
   // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 0
   %1 = llvm.extractvalue %0[0] : !llvm.struct<(i32, i1)>
   // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 1
   %2 = llvm.extractvalue %0[1] : !llvm.struct<(i32, i1)>
   llvm.return
 }
 
 llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
 llvm.func @foo(!llvm.ptr<i8>)
 llvm.func @bar(!llvm.ptr<i8>) -> !llvm.ptr<i8>
 llvm.func @__gxx_personality_v0(...) -> i32
 
 // CHECK-LABEL: @invokeLandingpad
 llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {
 // CHECK: %[[a1:[0-9]+]] = alloca i8
   %0 = llvm.mlir.constant(0 : i32) : i32
   %1 = llvm.mlir.constant(dense<0> : vector<1xi8>) : !llvm.array<1 x i8>
   %2 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
   %3 = llvm.bitcast %2 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
   %4 = llvm.mlir.null : !llvm.ptr<ptr<i8>>
   %5 = llvm.mlir.constant(1 : i32) : i32
   %6 = llvm.alloca %5 x i8 : (i32) -> !llvm.ptr<i8>
 // CHECK: invoke void @foo(i8* %[[a1]])
 // CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]
   llvm.invoke @foo(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> ()
 
 // CHECK: [[unwind]]:
 ^bb1:
 // CHECK: %{{[0-9]+}} = landingpad { i8*, i32 }
 // CHECK-NEXT:             catch i8** null
 // CHECK-NEXT:             catch i8* bitcast (i8** @_ZTIi to i8*)
 // CHECK-NEXT:             filter [1 x i8] zeroinitializer
   %7 = llvm.landingpad (catch %4 : !llvm.ptr<ptr<i8>>) (catch %3 : !llvm.ptr<i8>) (filter %1 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
 // CHECK: br label %[[final:[0-9]+]]
   llvm.br ^bb3
 
 // CHECK: [[normal]]:
 // CHECK-NEXT: ret i32 1
 ^bb2: // 2 preds: ^bb0, ^bb3
   llvm.return %5 : i32
 
 // CHECK: [[final]]:
 // CHECK-NEXT: %{{[0-9]+}} = invoke i8* @bar(i8* %[[a1]])
 // CHECK-NEXT:          to label %[[normal]] unwind label %[[unwind]]
 ^bb3: // pred: ^bb1
   %8 = llvm.invoke @bar(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
 }
 
 // CHECK-LABEL: @callFreezeOp
 llvm.func @callFreezeOp(%x : i32) {
   // CHECK: freeze i32 %{{[0-9]+}}
   %0 = llvm.freeze %x : i32
   %1 = llvm.mlir.undef : i32
   // CHECK: freeze i32 undef
   %2 = llvm.freeze %1 : i32
   llvm.return
 }
 
 // CHECK-LABEL: @boolConstArg
 llvm.func @boolConstArg() -> i1 {
   // CHECK: ret i1 false
   %0 = llvm.mlir.constant(true) : i1
   %1 = llvm.mlir.constant(false) : i1
   %2 = llvm.and %0, %1 : i1
   llvm.return %2 : i1
 }
 
 // CHECK-LABEL: @callFenceInst
 llvm.func @callFenceInst() {
   // CHECK: fence syncscope("agent") release
   llvm.fence syncscope("agent") release
   // CHECK: fence release
   llvm.fence release
   // CHECK: fence release
   llvm.fence syncscope("") release
   llvm.return
 }
 
 // CHECK-LABEL: @passthrough
 // CHECK: #[[ATTR_GROUP:[0-9]*]]
 llvm.func @passthrough() attributes {passthrough = ["noinline", ["alignstack", "4"], "null_pointer_is_valid", ["foo", "bar"]]} {
   llvm.return
 }
 
 // CHECK: attributes #[[ATTR_GROUP]] = {
 // CHECK-DAG: noinline
 // CHECK-DAG: alignstack=4
 // CHECK-DAG: null_pointer_is_valid
 // CHECK-DAG: "foo"="bar"
 
 // -----
 
 // CHECK-LABEL: @constant_bf16
 llvm.func @constant_bf16() -> bf16 {
   %0 = llvm.mlir.constant(1.000000e+01 : bf16) : bf16
   llvm.return %0 : bf16
 }
 
 // CHECK: ret bfloat 0xR4120
 
 // -----
 
 llvm.func @address_taken() {
   llvm.return
 }
 
 llvm.mlir.global internal constant @taker_of_address() : !llvm.ptr<func<void ()>> {
   %0 = llvm.mlir.addressof @address_taken : !llvm.ptr<func<void ()>>
   llvm.return %0 : !llvm.ptr<func<void ()>>
 }
 
 // -----
 
 // Check that branch weight attributes are exported properly as metadata.
 llvm.func @cond_br_weights(%cond : i1, %arg0 : i32,  %arg1 : i32) -> i32 {
   // CHECK: !prof ![[NODE:[0-9]+]]
   llvm.cond_br %cond weights(dense<[5, 10]> : vector<2xi32>), ^bb1, ^bb2
 ^bb1:  // pred: ^bb0
   llvm.return %arg0 : i32
 ^bb2:  // pred: ^bb0
   llvm.return %arg1 : i32
 }
 
 // CHECK: ![[NODE]] = !{!"branch_weights", i32 5, i32 10}
 
 // -----
 
 llvm.func @volatile_store_and_load() {
   %val = llvm.mlir.constant(5 : i32) : i32
   %size = llvm.mlir.constant(1 : i64) : i64
   %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr<i32>)
   // CHECK: store volatile i32 5, i32* %{{.*}}
   llvm.store volatile %val, %0 : !llvm.ptr<i32>
   // CHECK: %{{.*}} = load volatile i32, i32* %{{.*}}
   %1 = llvm.load volatile %0: !llvm.ptr<i32>
   llvm.return
 }
 
 // -----
 
 // Check that nontemporal attribute is exported as metadata node.
 llvm.func @nontemporal_store_and_load() {
   %val = llvm.mlir.constant(5 : i32) : i32
   %size = llvm.mlir.constant(1 : i64) : i64
   %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr<i32>)
   // CHECK: !nontemporal ![[NODE:[0-9]+]]
   llvm.store %val, %0 {nontemporal} : !llvm.ptr<i32>
   // CHECK: !nontemporal ![[NODE]]
   %1 = llvm.load %0 {nontemporal} : !llvm.ptr<i32>
   llvm.return
 }
 
 // CHECK: ![[NODE]] = !{i32 1}
 
 // -----
 
 // Check that the translation does not crash in absence of a data layout.
 module {
   // CHECK: declare void @module_default_layout
   llvm.func @module_default_layout()
 }
 
 // -----
 
 // CHECK: target datalayout = "E"
 module attributes {llvm.data_layout = "E"} {
   llvm.func @module_big_endian()
 }
 
 // -----
 
 // CHECK: "CodeView", i32 1
 module attributes {llvm.target_triple = "x86_64-pc-windows-msvc"} {}
 
 // -----
 
 // CHECK-NOT: "CodeView", i32 1
 // CHECK: aarch64-linux-android
 module attributes {llvm.target_triple = "aarch64-linux-android"} {}
 
 // -----
 
 // CHECK-NOT: "CodeView", i32 1
 module attributes {} {}
 
 // -----
 
 // CHECK-LABEL: @useInlineAsm
 llvm.func @useInlineAsm(%arg0: i32) {
   // Constraints string is checked at LLVM InlineAsm instruction construction time.
   // So we can't just use "bar" everywhere, number of in/out arguments has to match.
 
   // CHECK-NEXT:  call void asm "foo", "r"(i32 {{.*}}), !dbg !7
   llvm.inline_asm "foo", "r" %arg0 : (i32) -> ()
 
   // CHECK-NEXT:  call i8 asm "foo", "=r,r"(i32 {{.*}}), !dbg !9
   %0 = llvm.inline_asm "foo", "=r,r" %arg0 : (i32) -> i8
 
   // CHECK-NEXT:  call i8 asm "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !10
   %1 = llvm.inline_asm "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
 
   // CHECK-NEXT:  call i8 asm sideeffect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !11
   %2 = llvm.inline_asm has_side_effects "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
 
   // CHECK-NEXT:  call i8 asm alignstack "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !12
   %3 = llvm.inline_asm is_align_stack "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
 
   // CHECK-NEXT:  call i8 asm inteldialect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !13
   %4 = llvm.inline_asm asm_dialect = "intel" "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
 
   // CHECK-NEXT:  call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}}), !dbg !14
   %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>
 
   llvm.return
 }
 
 // -----
 
 llvm.func @fastmathFlagsFunc(f32) -> f32
 
 // CHECK-LABEL: @fastmathFlags
 llvm.func @fastmathFlags(%arg0: f32) {
 // CHECK: {{.*}} = fadd nnan ninf float {{.*}}, {{.*}}
 // CHECK: {{.*}} = fsub nnan ninf float {{.*}}, {{.*}}
 // CHECK: {{.*}} = fmul nnan ninf float {{.*}}, {{.*}}
 // CHECK: {{.*}} = fdiv nnan ninf float {{.*}}, {{.*}}
 // CHECK: {{.*}} = frem nnan ninf float {{.*}}, {{.*}}
   %0 = llvm.fadd %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
   %1 = llvm.fsub %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
   %2 = llvm.fmul %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
   %3 = llvm.fdiv %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
   %4 = llvm.frem %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
 
 // CHECK: {{.*}} = fcmp nnan ninf oeq {{.*}}, {{.*}}
   %5 = llvm.fcmp "oeq" %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
 
 // CHECK: {{.*}} = fneg nnan ninf float {{.*}}
   %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
 
 // CHECK: {{.*}} = call float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call nnan float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call ninf float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call nsz float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call arcp float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call contract float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call afn float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call reassoc float @fastmathFlagsFunc({{.*}})
 // CHECK: {{.*}} = call fast float @fastmathFlagsFunc({{.*}})
   %8 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<>} : (f32) -> (f32)
   %9 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<nnan>} : (f32) -> (f32)
   %10 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<ninf>} : (f32) -> (f32)
   %11 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<nsz>} : (f32) -> (f32)
   %12 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<arcp>} : (f32) -> (f32)
   %13 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<contract>} : (f32) -> (f32)
   %14 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> (f32)
   %15 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<reassoc>} : (f32) -> (f32)
   %16 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> (f32)
   llvm.return
 }
 
 // -----
 
 // CHECK-LABEL: @switch_args
 llvm.func @switch_args(%arg0: i32) -> i32 {
   %0 = llvm.mlir.constant(5 : i32) : i32
   %1 = llvm.mlir.constant(7 : i32) : i32
   %2 = llvm.mlir.constant(11 : i32) : i32
   // CHECK:      switch i32 %[[SWITCH_arg0:[0-9]+]], label %[[SWITCHDEFAULT_bb1:[0-9]+]] [
   // CHECK-NEXT:   i32 -1, label %[[SWITCHCASE_bb2:[0-9]+]]
   // CHECK-NEXT:   i32 1, label %[[SWITCHCASE_bb3:[0-9]+]]
   // CHECK-NEXT: ]
   llvm.switch %arg0, ^bb1 [
     -1: ^bb2(%0 : i32),
     1: ^bb3(%1, %2 : i32, i32)
   ]
 
 // CHECK:      [[SWITCHDEFAULT_bb1]]:
 // CHECK-NEXT:   ret i32 %[[SWITCH_arg0]]
 ^bb1:  // pred: ^bb0
   llvm.return %arg0 : i32
 
 // CHECK:      [[SWITCHCASE_bb2]]:
 // CHECK-NEXT:   phi i32 [ 5, %1 ]
 // CHECK-NEXT:   ret i32
 ^bb2(%3: i32): // pred: ^bb0
   llvm.return %1 : i32
 
 // CHECK:      [[SWITCHCASE_bb3]]:
 // CHECK-NEXT:   phi i32 [ 7, %1 ]
 // CHECK-NEXT:   phi i32 [ 11, %1 ]
 // CHECK-NEXT:   ret i32
 ^bb3(%4: i32, %5: i32): // pred: ^bb0
   llvm.return %4 : i32
 }
 
 // CHECK-LABEL: @switch_weights
 llvm.func @switch_weights(%arg0: i32) -> i32 {
   %0 = llvm.mlir.constant(19 : i32) : i32
   %1 = llvm.mlir.constant(23 : i32) : i32
   %2 = llvm.mlir.constant(29 : i32) : i32
   // CHECK: !prof ![[SWITCH_WEIGHT_NODE:[0-9]+]]
   llvm.switch %arg0, ^bb1(%0 : i32) [
     9: ^bb2(%1, %2 : i32, i32),
     99: ^bb3
   ] {branch_weights = dense<[13, 17, 19]> : vector<3xi32>}
 
 ^bb1(%3: i32):  // pred: ^bb0
   llvm.return %3 : i32
 
 ^bb2(%4: i32, %5: i32): // pred: ^bb0
   llvm.return %5 : i32
 
 ^bb3: // pred: ^bb0
   llvm.return %arg0 : i32
 }
 
 // CHECK: ![[SWITCH_WEIGHT_NODE]] = !{!"branch_weights", i32 13, i32 17, i32 19}
 
 // -----
 
 module {
   llvm.func @loopOptions(%arg1 : i32, %arg2 : i32) {
       %0 = llvm.mlir.constant(0 : i32) : i32
       %4 = llvm.alloca %arg1 x i32 : (i32) -> (!llvm.ptr<i32>)
       llvm.br ^bb3(%0 : i32)
     ^bb3(%1: i32):
       %2 = llvm.icmp "slt" %1, %arg1 : i32
       // CHECK: br i1 {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
       llvm.cond_br %2, ^bb4, ^bb5 {llvm.loop = {parallel_access = [@metadata::@group1, @metadata::@group2], options = [#llvm.loopopt<disable_unroll = true>, #llvm.loopopt<disable_licm = true>, #llvm.loopopt<interleave_count = 1>]}}
     ^bb4:
       %3 = llvm.add %1, %arg2  : i32
       // CHECK: = load i32, i32* %{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE:[0-9]+]]
       %5 = llvm.load %4 { access_groups = [@metadata::@group1, @metadata::@group2] } : !llvm.ptr<i32>
       // CHECK: br label {{.*}} !llvm.loop ![[LOOP_NODE]]
       llvm.br ^bb3(%3 : i32) {llvm.loop = {parallel_access = [@metadata::@group1, @metadata::@group2], options = [#llvm.loopopt<disable_unroll = true>, #llvm.loopopt<disable_licm = true>, #llvm.loopopt<interleave_count = 1>]}}
     ^bb5:
       llvm.return
   }
 
   llvm.metadata @metadata {
     llvm.access_group @group1
     llvm.access_group @group2
     llvm.return
   }
 }
 
 // CHECK: ![[LOOP_NODE]] = distinct !{![[LOOP_NODE]], ![[PA_NODE:[0-9]+]], ![[UNROLL_DISABLE_NODE:[0-9]+]], ![[LICM_DISABLE_NODE:[0-9]+]], ![[INTERLEAVE_NODE:[0-9]+]]}
 // CHECK: ![[PA_NODE]] = !{!"llvm.loop.parallel_accesses", ![[GROUP_NODE1:[0-9]+]], ![[GROUP_NODE2:[0-9]+]]}
 // CHECK: ![[GROUP_NODE1]] = distinct !{}
 // CHECK: ![[GROUP_NODE2]] = distinct !{}
 // CHECK: ![[UNROLL_DISABLE_NODE]] = !{!"llvm.loop.unroll.disable", i1 true}
 // CHECK: ![[LICM_DISABLE_NODE]] = !{!"llvm.licm.disable", i1 true}
 // CHECK: ![[INTERLEAVE_NODE]] = !{!"llvm.loop.interleave.count", i32 1}
 // CHECK: ![[ACCESS_GROUPS_NODE]] = !{![[GROUP_NODE1]], ![[GROUP_NODE2]]}

mlir/test/Target/LLVMIR/nvvmir.mlir

 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
 llvm.func @nvvm_special_regs() -> i32 {
   // CHECK: %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
   %1 = nvvm.read.ptx.sreg.tid.x : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.y()
   %2 = nvvm.read.ptx.sreg.tid.y : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.z()
   %3 = nvvm.read.ptx.sreg.tid.z : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
   %4 = nvvm.read.ptx.sreg.ntid.x : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.y()
   %5 = nvvm.read.ptx.sreg.ntid.y : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.z()
   %6 = nvvm.read.ptx.sreg.ntid.z : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
   %7 = nvvm.read.ptx.sreg.ctaid.x : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.y()
   %8 = nvvm.read.ptx.sreg.ctaid.y : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.z()
   %9 = nvvm.read.ptx.sreg.ctaid.z : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.x()
   %10 = nvvm.read.ptx.sreg.nctaid.x : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.y()
   %11 = nvvm.read.ptx.sreg.nctaid.y : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.z()
   %12 = nvvm.read.ptx.sreg.nctaid.z : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
   %13 = nvvm.read.ptx.sreg.warpsize : i32
   // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.laneid()
   %14 = nvvm.read.ptx.sreg.laneid : i32
   llvm.return %1 : i32
 }
 
 llvm.func @llvm_nvvm_barrier0() {
   // CHECK: call void @llvm.nvvm.barrier0()
   nvvm.barrier0
   llvm.return
 }
 
 llvm.func @nvvm_shfl(
     %0 : i32, %1 : i32, %2 : i32,
     %3 : i32, %4 : f32) -> i32 {
   // CHECK: call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
   %6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 : i32
   // CHECK: call float @llvm.nvvm.shfl.sync.bfly.f32(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
   %7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 : f32
   llvm.return %6 : i32
 }
 
 llvm.func @nvvm_shfl_pred(
     %0 : i32, %1 : i32, %2 : i32,
     %3 : i32, %4 : f32) -> !llvm.struct<(i32, i1)> {
   // CHECK: call { i32, i1 } @llvm.nvvm.shfl.sync.bfly.i32p(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
   %6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 {return_value_and_is_valid} : !llvm.struct<(i32, i1)>
   // CHECK: call { float, i1 } @llvm.nvvm.shfl.sync.bfly.f32p(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
   %7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 {return_value_and_is_valid} : !llvm.struct<(f32, i1)>
   llvm.return %6 : !llvm.struct<(i32, i1)>
 }
 
 llvm.func @nvvm_vote(%0 : i32, %1 : i1) -> i32 {
   // CHECK: call i32 @llvm.nvvm.vote.ballot.sync(i32 %{{.*}}, i1 %{{.*}})
   %3 = nvvm.vote.ballot.sync %0, %1 : i32
   llvm.return %3 : i32
 }
 
 llvm.func @nvvm_mma(%a0 : vector<2xf16>, %a1 : vector<2xf16>,
                     %b0 : vector<2xf16>, %b1 : vector<2xf16>,
                     %c0 : f32, %c1 : f32, %c2 : f32, %c3 : f32,
                     %c4 : f32, %c5 : f32, %c6 : f32, %c7 : f32) -> !llvm.struct<(f32, f32, f32, f32, f32, f32, f32, f32)> {
   // CHECK: call { float, float, float, float, float, float, float, float } @llvm.nvvm.mma.m8n8k4.row.col.f32.f32
   %0 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="row", blayout="col"} : (vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, f32, f32, f32, f32, f32, f32, f32, f32) -> !llvm.struct<(f32, f32, f32, f32, f32, f32, f32, f32)>
   llvm.return %0 : !llvm.struct<(f32, f32, f32, f32, f32, f32, f32, f32)>
 }
 
 // This function has the "kernel" attribute attached and should appear in the
 // NVVM annotations after conversion.
 llvm.func @kernel_func() attributes {nvvm.kernel} {
   llvm.return
 }
 
 // CHECK:     !nvvm.annotations =
 // CHECK-NOT: {i32 ()* @nvvm_special_regs, !"kernel", i32 1}
 // CHECK:     {void ()* @kernel_func, !"kernel", i32 1}

mlir/test/Target/LLVMIR/openmp-llvm.mlir

 // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
 
 // CHECK-LABEL: define void @test_stand_alone_directives()
 llvm.func @test_stand_alone_directives() {
   // CHECK: [[OMP_THREAD:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK-NEXT:  call void @__kmpc_barrier(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD]])
   omp.barrier
 
   // CHECK: [[OMP_THREAD1:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK-NEXT:  [[RET_VAL:%.*]] = call i32 @__kmpc_omp_taskwait(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD1]])
   omp.taskwait
 
   // CHECK: [[OMP_THREAD2:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK-NEXT:  [[RET_VAL:%.*]] = call i32 @__kmpc_omp_taskyield(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD2]], i32 0)
   omp.taskyield
 
   // CHECK-NEXT:    ret void
   llvm.return
 }
 
 // CHECK-LABEL: define void @test_flush_construct(i32 %0)
 llvm.func @test_flush_construct(%arg0: i32) {
   // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
   omp.flush
 
   // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
   omp.flush (%arg0 : i32)
 
   // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
   omp.flush (%arg0, %arg0 : i32, i32)
 
   %0 = llvm.mlir.constant(1 : i64) : i64
   //  CHECK: alloca {{.*}} align 4
   %1 = llvm.alloca %0 x i32 {in_type = i32, name = "a"} : (i64) -> !llvm.ptr<i32>
   // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
   omp.flush
   //  CHECK: load i32, i32*
   %2 = llvm.load %1 : !llvm.ptr<i32>
 
   // CHECK-NEXT:    ret void
   llvm.return
 }
 
 // CHECK-LABEL: define void @test_omp_parallel_1()
 llvm.func @test_omp_parallel_1() -> () {
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_1:.*]] to {{.*}}
   omp.parallel {
     omp.barrier
     omp.terminator
   }
 
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_1]]
   // CHECK: call void @__kmpc_barrier
 
 llvm.func @body(i64)
 
 // CHECK-LABEL: define void @test_omp_parallel_2()
 llvm.func @test_omp_parallel_2() -> () {
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_2:.*]] to {{.*}}
   omp.parallel {
     ^bb0:
       %0 = llvm.mlir.constant(1 : index) : i64
       %1 = llvm.mlir.constant(42 : index) : i64
       llvm.call @body(%0) : (i64) -> ()
       llvm.call @body(%1) : (i64) -> ()
       llvm.br ^bb1
 
     ^bb1:
       %2 = llvm.add %0, %1 : i64
       llvm.call @body(%2) : (i64) -> ()
       omp.terminator
   }
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_2]]
   // CHECK-LABEL: omp.par.region:
   // CHECK: br label %omp.par.region1
   // CHECK-LABEL: omp.par.region1:
   // CHECK: call void @body(i64 1)
   // CHECK: call void @body(i64 42)
   // CHECK: br label %omp.par.region2
   // CHECK-LABEL: omp.par.region2:
   // CHECK: call void @body(i64 43)
   // CHECK: br label %omp.par.pre_finalize
 
 // CHECK: define void @test_omp_parallel_num_threads_1(i32 %[[NUM_THREADS_VAR_1:.*]])
 llvm.func @test_omp_parallel_num_threads_1(%arg0: i32) -> () {
   // CHECK: %[[GTN_NUM_THREADS_VAR_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_1:.*]])
   // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_1]], i32 %[[GTN_NUM_THREADS_VAR_1]], i32 %[[NUM_THREADS_VAR_1]])
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_1:.*]] to {{.*}}
   omp.parallel num_threads(%arg0: i32) {
     omp.barrier
     omp.terminator
   }
 
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_1]]
   // CHECK: call void @__kmpc_barrier
 
 // CHECK: define void @test_omp_parallel_num_threads_2()
 llvm.func @test_omp_parallel_num_threads_2() -> () {
   %0 = llvm.mlir.constant(4 : index) : i32
   // CHECK: %[[GTN_NUM_THREADS_VAR_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_2:.*]])
   // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_2]], i32 %[[GTN_NUM_THREADS_VAR_2]], i32 4)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_2:.*]] to {{.*}}
   omp.parallel num_threads(%0: i32) {
     omp.barrier
     omp.terminator
   }
 
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_2]]
   // CHECK: call void @__kmpc_barrier
 
 // CHECK: define void @test_omp_parallel_num_threads_3()
 llvm.func @test_omp_parallel_num_threads_3() -> () {
   %0 = llvm.mlir.constant(4 : index) : i32
   // CHECK: %[[GTN_NUM_THREADS_VAR_3_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_1:.*]])
   // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_1]], i32 %[[GTN_NUM_THREADS_VAR_3_1]], i32 4)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_1:.*]] to {{.*}}
   omp.parallel num_threads(%0: i32) {
     omp.barrier
     omp.terminator
   }
   %1 = llvm.mlir.constant(8 : index) : i32
   // CHECK: %[[GTN_NUM_THREADS_VAR_3_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_2:.*]])
   // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_2]], i32 %[[GTN_NUM_THREADS_VAR_3_2]], i32 8)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_2:.*]] to {{.*}}
   omp.parallel num_threads(%1: i32) {
     omp.barrier
     omp.terminator
   }
 
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_2]]
   // CHECK: call void @__kmpc_barrier
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_1]]
   // CHECK: call void @__kmpc_barrier
 
 // CHECK: define void @test_omp_parallel_if_1(i32 %[[IF_VAR_1:.*]])
 llvm.func @test_omp_parallel_if_1(%arg0: i32) -> () {
 
 // CHECK: %[[IF_COND_VAR_1:.*]] = icmp slt i32 %[[IF_VAR_1]], 0
   %0 = llvm.mlir.constant(0 : index) : i32
   %1 = llvm.icmp "slt" %arg0, %0 : i32
 
 // CHECK: %[[GTN_IF_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[SI_VAR_IF_1:.*]])
 // CHECK: br i1 %[[IF_COND_VAR_1]], label %[[IF_COND_TRUE_BLOCK_1:.*]], label %[[IF_COND_FALSE_BLOCK_1:.*]]
 // CHECK: [[IF_COND_TRUE_BLOCK_1]]:
 // CHECK: br label %[[OUTLINED_CALL_IF_BLOCK_1:.*]]
 // CHECK: [[OUTLINED_CALL_IF_BLOCK_1]]:
 // CHECK: call void {{.*}} @__kmpc_fork_call(%struct.ident_t* @[[SI_VAR_IF_1]], {{.*}} @[[OMP_OUTLINED_FN_IF_1:.*]] to void
 // CHECK: br label %[[OUTLINED_EXIT_IF_1:.*]]
 // CHECK: [[OUTLINED_EXIT_IF_1]]:
 // CHECK: br label %[[OUTLINED_EXIT_IF_2:.*]]
 // CHECK: [[OUTLINED_EXIT_IF_2]]:
 // CHECK: br label %[[RETURN_BLOCK_IF_1:.*]]
 // CHECK: [[IF_COND_FALSE_BLOCK_1]]:
 // CHECK: call void @__kmpc_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]])
 // CHECK: call void @[[OMP_OUTLINED_FN_IF_1]]
 // CHECK: call void @__kmpc_end_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]])
 // CHECK: br label %[[RETURN_BLOCK_IF_1]]
   omp.parallel if(%1 : i1) {
     omp.barrier
     omp.terminator
   }
 
 // CHECK: [[RETURN_BLOCK_IF_1]]:
 // CHECK: ret void
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_IF_1]]
   // CHECK: call void @__kmpc_barrier
 
 // CHECK-LABEL: define void @test_omp_parallel_3()
 llvm.func @test_omp_parallel_3() -> () {
   // CHECK: [[OMP_THREAD_3_1:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK: call void @__kmpc_push_proc_bind(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD_3_1]], i32 2)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_3_1:.*]] to {{.*}}
   omp.parallel proc_bind(master) {
     omp.barrier
     omp.terminator
   }
   // CHECK: [[OMP_THREAD_3_2:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK: call void @__kmpc_push_proc_bind(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD_3_2]], i32 3)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_3_2:.*]] to {{.*}}
   omp.parallel proc_bind(close) {
     omp.barrier
     omp.terminator
   }
   // CHECK: [[OMP_THREAD_3_3:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
   // CHECK: call void @__kmpc_push_proc_bind(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD_3_3]], i32 4)
   // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_3_3:.*]] to {{.*}}
   omp.parallel proc_bind(spread) {
     omp.barrier
     omp.terminator
   }
 
   llvm.return
 }
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_3_3]]
 // CHECK: define internal void @[[OMP_OUTLINED_FN_3_2]]
 // CHECK: define internal void @[[OMP_OUTLINED_FN_3_1]]
 
 // CHECK-LABEL: define void @test_omp_parallel_4()
 llvm.func @test_omp_parallel_4() -> () {
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @[[OMP_OUTLINED_FN_4_1:.*]] to
 // CHECK: define internal void @[[OMP_OUTLINED_FN_4_1]]
 // CHECK: call void @__kmpc_barrier
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @[[OMP_OUTLINED_FN_4_1_1:.*]] to
 // CHECK: call void @__kmpc_barrier
   omp.parallel {
     omp.barrier
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_4_1_1]]
 // CHECK: call void @__kmpc_barrier
     omp.parallel {
       omp.barrier
       omp.terminator
     }
 
     omp.barrier
     omp.terminator
   }
   llvm.return
 }
 
 llvm.func @test_omp_parallel_5() -> () {
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @[[OMP_OUTLINED_FN_5_1:.*]] to
 // CHECK: define internal void @[[OMP_OUTLINED_FN_5_1]]
 // CHECK: call void @__kmpc_barrier
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @[[OMP_OUTLINED_FN_5_1_1:.*]] to
 // CHECK: call void @__kmpc_barrier
   omp.parallel {
     omp.barrier
 
 // CHECK: define internal void @[[OMP_OUTLINED_FN_5_1_1]]
     omp.parallel {
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @[[OMP_OUTLINED_FN_5_1_1_1:.*]] to
 // CHECK: define internal void @[[OMP_OUTLINED_FN_5_1_1_1]]
 // CHECK: call void @__kmpc_barrier
       omp.parallel {
         omp.barrier
         omp.terminator
       }
       omp.terminator
     }
 
     omp.barrier
     omp.terminator
   }
   llvm.return
 }
 
 // CHECK-LABEL: define void @test_omp_master()
 llvm.func @test_omp_master() -> () {
 // CHECK: call void {{.*}}@__kmpc_fork_call{{.*}} @{{.*}} to
 // CHECK: omp.par.region1:
   omp.parallel {
     omp.master {
 // CHECK: [[OMP_THREAD_3_4:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @{{[0-9]+}})
 // CHECK: {{[0-9]+}} = call i32 @__kmpc_master(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD_3_4]])
 // CHECK: omp.master.region
 // CHECK: call void @__kmpc_end_master(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD_3_4]])
 // CHECK: br label %omp_region.end
       omp.terminator
     }
     omp.terminator
   }
   omp.parallel {
     omp.parallel {
       omp.master {
         omp.terminator
       }
       omp.terminator
     }
     omp.terminator
   }
   llvm.return
 }
 
 // -----
 
 // CHECK: %struct.ident_t = type
 // CHECK: @[[$parallel_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00"
 // CHECK: @[[$parallel_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$parallel_loc]], {{.*}}
 
 // CHECK: @[[$wsloop_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00"
 // CHECK: @[[$wsloop_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$wsloop_loc]], {{.*}}
 
 // CHECK-LABEL: @wsloop_simple
 llvm.func @wsloop_simple(%arg0: !llvm.ptr<f32>) {
   %0 = llvm.mlir.constant(42 : index) : i64
   %1 = llvm.mlir.constant(10 : index) : i64
   %2 = llvm.mlir.constant(1 : index) : i64
   omp.parallel {
     "omp.wsloop"(%1, %0, %2) ( {
     ^bb0(%arg1: i64):
       // The form of the emitted IR is controlled by OpenMPIRBuilder and
       // tested there. Just check that the right functions are called.
       // CHECK: call i32 @__kmpc_global_thread_num
       // CHECK: call void @__kmpc_for_static_init_{{.*}}(%struct.ident_t* @[[$wsloop_loc_struct]],
       %3 = llvm.mlir.constant(2.000000e+00 : f32) : f32
       %4 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
       llvm.store %3, %4 : !llvm.ptr<f32>
       omp.yield
       // CHECK: call void @__kmpc_for_static_fini(%struct.ident_t* @[[$wsloop_loc_struct]],
     }) {operand_segment_sizes = dense<[1, 1, 1, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (i64, i64, i64) -> ()
     omp.terminator
   }
   llvm.return
 }
 
 // CHECK-LABEL: @wsloop_inclusive_1
 llvm.func @wsloop_inclusive_1(%arg0: !llvm.ptr<f32>) {
   %0 = llvm.mlir.constant(42 : index) : i64
   %1 = llvm.mlir.constant(10 : index) : i64
   %2 = llvm.mlir.constant(1 : index) : i64
   // CHECK: store i64 31, i64* %{{.*}}upperbound
   "omp.wsloop"(%1, %0, %2) ( {
   ^bb0(%arg1: i64):
     %3 = llvm.mlir.constant(2.000000e+00 : f32) : f32
     %4 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
     llvm.store %3, %4 : !llvm.ptr<f32>
     omp.yield
   }) {operand_segment_sizes = dense<[1, 1, 1, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (i64, i64, i64) -> ()
   llvm.return
 }
 
 // CHECK-LABEL: @wsloop_inclusive_2
 llvm.func @wsloop_inclusive_2(%arg0: !llvm.ptr<f32>) {
   %0 = llvm.mlir.constant(42 : index) : i64
   %1 = llvm.mlir.constant(10 : index) : i64
   %2 = llvm.mlir.constant(1 : index) : i64
   // CHECK: store i64 32, i64* %{{.*}}upperbound
   "omp.wsloop"(%1, %0, %2) ( {
   ^bb0(%arg1: i64):
     %3 = llvm.mlir.constant(2.000000e+00 : f32) : f32
     %4 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
     llvm.store %3, %4 : !llvm.ptr<f32>
     omp.yield
   }) {inclusive, operand_segment_sizes = dense<[1, 1, 1, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (i64, i64, i64) -> ()
   llvm.return
 }

mlir/test/Target/LLVMIR/rocdl.mlir

 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
 llvm.func @rocdl_special_regs() -> i32 {
   // CHECK-LABEL: rocdl_special_regs
   // CHECK: call i32 @llvm.amdgcn.workitem.id.x()
   %1 = rocdl.workitem.id.x : i32
   // CHECK: call i32 @llvm.amdgcn.workitem.id.y()
   %2 = rocdl.workitem.id.y : i32
   // CHECK: call i32 @llvm.amdgcn.workitem.id.z()
   %3 = rocdl.workitem.id.z : i32
   // CHECK: call i32 @llvm.amdgcn.workgroup.id.x()
   %4 = rocdl.workgroup.id.x : i32
   // CHECK: call i32 @llvm.amdgcn.workgroup.id.y()
   %5 = rocdl.workgroup.id.y : i32
   // CHECK: call i32 @llvm.amdgcn.workgroup.id.z()
   %6 = rocdl.workgroup.id.z : i32
   // CHECK: call i64 @__ockl_get_local_size(i32 0)
   %7 = rocdl.workgroup.dim.x : i64
   // CHECK: call i64 @__ockl_get_local_size(i32 1)
   %8 = rocdl.workgroup.dim.y : i64
   // CHECK: call i64 @__ockl_get_local_size(i32 2)
   %9 = rocdl.workgroup.dim.z : i64
   // CHECK: call i64 @__ockl_get_global_size(i32 0)
   %10 = rocdl.grid.dim.x : i64
   // CHECK: call i64 @__ockl_get_global_size(i32 1)
   %11 = rocdl.grid.dim.y : i64
   // CHECK: call i64 @__ockl_get_global_size(i32 2)
   %12 = rocdl.grid.dim.z : i64
   llvm.return %1 : i32
 }
 
 llvm.func @kernel_func() attributes {rocdl.kernel} {
   // CHECK-LABEL: amdgpu_kernel void @kernel_func
   llvm.return
 }
 
 llvm.func @rocdl.barrier() {
   // CHECK:      fence syncscope("workgroup") release
   // CHECK-NEXT: call void @llvm.amdgcn.s.barrier()
   // CHECK-NEXT: fence syncscope("workgroup") acquire
   rocdl.barrier
   llvm.return
 }
 
 llvm.func @rocdl.xdlops(%arg0 : f32, %arg1 : f32,
                    %arg2 : vector<32 x f32>, %arg3: i32,
                    %arg4 : vector<16 x f32>, %arg5 : vector<4xf32>,
                    %arg6 : vector<4xf16>, %arg7 : vector<32 x i32>,
                    %arg8 : vector<16 x i32>, %arg9 : vector<4xi32>,
                    %arg10 : vector<2xi16>) -> vector<32 x f32> {
   %csti32 = llvm.mlir.constant(42 : i32) : i32
 
   // CHECK-LABEL: rocdl.xdlops
   // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x1f32(float %{{.*}}, float %{{.*}}, <32 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r0 = rocdl.mfma.f32.32x32x1f32 %arg0, %arg1, %arg2, %csti32, %csti32, %csti32 :
                             (f32, f32, vector<32 x f32>,
                             i32, i32, i32) -> vector<32 x f32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x1f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r1 = rocdl.mfma.f32.16x16x1f32 %arg0, %arg1, %arg4, %csti32, %csti32, %csti32 :
                             (f32, f32, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x4f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r2 = rocdl.mfma.f32.16x16x4f32 %arg0, %arg1, %arg5, %csti32, %csti32, %csti32 :
                             (f32, f32, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x1f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r3 = rocdl.mfma.f32.4x4x1f32 %arg0, %arg1, %arg5, %csti32, %csti32, %csti32 :
                             (f32, f32, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x2f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r4= rocdl.mfma.f32.32x32x2f32 %arg0, %arg1, %arg4, %csti32, %csti32, %csti32 :
                             (f32, f32, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <32 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r5 = rocdl.mfma.f32.32x32x4f16 %arg6, %arg6, %arg2, %csti32, %csti32, %csti32 :
                             (vector<4xf16>, vector<4xf16>, vector<32 x f32>,
                             i32, i32, i32) -> vector<32 x f32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r6 = rocdl.mfma.f32.16x16x4f16 %arg6, %arg6, %arg4, %csti32, %csti32, %csti32 :
                             (vector<4xf16>, vector<4xf16>, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r7 = rocdl.mfma.f32.4x4x4f16 %arg6, %arg6, %arg5, %csti32, %csti32, %csti32 :
                             (vector<4xf16>, vector<4xf16>, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x8f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r8 = rocdl.mfma.f32.32x32x8f16 %arg6, %arg6, %arg4, %csti32, %csti32, %csti32 :
                             (vector<4xf16>, vector<4xf16>, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x16f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r9 = rocdl.mfma.f32.16x16x16f16 %arg6, %arg6, %arg5, %csti32, %csti32, %csti32 :
                             (vector<4xf16>, vector<4xf16>, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   // CHECK: call <32 x i32> @llvm.amdgcn.mfma.i32.32x32x4i8(i32 %{{.*}}, i32 %{{.*}}, <32 x i32> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r10 = rocdl.mfma.i32.32x32x4i8 %arg3, %arg3, %arg7, %csti32, %csti32, %csti32 :
                             (i32, i32, vector<32 x i32>,
                             i32, i32, i32) -> vector<32 x i32>
 
   // CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.16x16x4i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r11 = rocdl.mfma.i32.16x16x4i8 %arg3, %arg3, %arg8, %csti32, %csti32, %csti32 :
                             (i32, i32, vector<16 x i32>,
                             i32, i32, i32) -> vector<16 x i32>
 
   // CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.4x4x4i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r12 = rocdl.mfma.i32.4x4x4i8 %arg3, %arg3, %arg9, %csti32, %csti32, %csti32 :
                             (i32, i32, vector<4xi32>,
                             i32, i32, i32) -> vector<4xi32>
 
   // CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.32x32x8i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r13 = rocdl.mfma.i32.32x32x8i8 %arg3, %arg3, %arg8, %csti32, %csti32, %csti32 :
                             (i32, i32, vector<16 x i32>,
                             i32, i32, i32) -> vector<16 x i32>
 
   // CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.16x16x16i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r14 = rocdl.mfma.i32.16x16x16i8 %arg3, %arg3, %arg9, %csti32, %csti32, %csti32 :
                             (i32, i32, vector<4xi32>,
                             i32, i32, i32) -> vector<4xi32>
 
   // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <32 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r15 = rocdl.mfma.f32.32x32x2bf16 %arg10, %arg10, %arg2, %csti32, %csti32, %csti32 :
                             (vector<2xi16>, vector<2xi16>, vector<32 x f32>,
                             i32, i32, i32) -> vector<32 x f32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r16 = rocdl.mfma.f32.16x16x2bf16 %arg10, %arg10, %arg4, %csti32, %csti32, %csti32 :
                             (vector<2xi16>, vector<2xi16>, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r17 = rocdl.mfma.f32.4x4x2bf16 %arg10, %arg10, %arg5, %csti32, %csti32, %csti32 :
                             (vector<2xi16>, vector<2xi16>, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x4bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r18 = rocdl.mfma.f32.32x32x4bf16 %arg10, %arg10, %arg4, %csti32, %csti32, %csti32 :
                             (vector<2xi16>, vector<2xi16>, vector<16 x f32>,
                             i32, i32, i32) -> vector<16 x f32>
 
   // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x8bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 {{.*}}, i32 {{.*}}, i32 {{.*}})
   %r19 = rocdl.mfma.f32.16x16x8bf16 %arg10, %arg10, %arg5, %csti32, %csti32, %csti32 :
                             (vector<2xi16>, vector<2xi16>, vector<4xf32>,
                             i32, i32, i32) -> vector<4xf32>
 
   llvm.return %r0 : vector<32 x f32>
 }
 
 llvm.func @rocdl.mubuf(%rsrc : vector<4xi32>, %vindex : i32,
                        %offset : i32, %vdata1 : vector<1xf32>,
                        %vdata2 : vector<2xf32>, %vdata4 : vector<4xf32>) {
   %glc = llvm.mlir.constant(false) : i1
   %slc = llvm.mlir.constant(true) : i1
   // CHECK-LABEL: rocdl.mubuf
   // CHECK: call <1 x float> @llvm.amdgcn.buffer.load.v1f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   %r1 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : vector<1xf32>
   // CHECK: call <2 x float> @llvm.amdgcn.buffer.load.v2f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   %r2 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : vector<2xf32>
   // CHECK: call <4 x float> @llvm.amdgcn.buffer.load.v4f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   %r4 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : vector<4xf32>
 
   // CHECK: call void @llvm.amdgcn.buffer.store.v1f32(<1 x float> %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   rocdl.buffer.store %vdata1, %rsrc, %vindex, %offset, %glc, %slc : vector<1xf32>
   // CHECK: call void @llvm.amdgcn.buffer.store.v2f32(<2 x float> %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   rocdl.buffer.store %vdata2, %rsrc, %vindex, %offset, %glc, %slc : vector<2xf32>
   // CHECK: call void @llvm.amdgcn.buffer.store.v4f32(<4 x float> %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 {{.*}}, i1 {{.*}})
   rocdl.buffer.store %vdata4, %rsrc, %vindex, %offset, %glc, %slc : vector<4xf32>
 
   llvm.return
 }
 

mlir/test/Target/LLVMIR/vector-to-llvm-ir.mlir

 // RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-to-llvm | mlir-translate -mlir-to-llvmir | FileCheck %s
 
 func @genbool_1d() -> vector<8xi1> {
   %0 = vector.constant_mask [4] : vector<8xi1>
   return %0 : vector<8xi1>
 }
 // CHECK-LABEL: @genbool_1d()
 // CHECK-NEXT: ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>
 
 func @genbool_2d() -> vector<4x4xi1> {
   %v = vector.constant_mask [2, 2] : vector<4x4xi1>
   return %v: vector<4x4xi1>
 }
 // CHECK-LABEL: @genbool_2d()
 // CHECK-NEXT: ret [4 x <4 x i1>] [<4 x i1> <i1 true, i1 true, i1 false, i1 false>, <4 x i1> <i1 true, i1 true, i1 false, i1 false>, <4 x i1> zeroinitializer, <4 x i1> zeroinitializer]
 
 func @genbool_3d() -> vector<2x3x4xi1> {
   %v = vector.constant_mask [1, 1, 3] : vector<2x3x4xi1>
   return %v: vector<2x3x4xi1>
 }
 // CHECK-LABEL: @genbool_3d()
 // CHECK-NEXT: ret [2 x [3 x <4 x i1>]] {{\[+}}3 x <4 x i1>] [<4 x i1> <i1 true, i1 true, i1 true, i1 false>, <4 x i1> zeroinitializer, <4 x i1> zeroinitializer], [3 x <4 x i1>] zeroinitializer]
 // note: awkward syntax to match [[
 
 func @genbool_1d_var_but_constant() -> vector<8xi1> {
   %i = constant 0 : index
   %v = vector.create_mask %i : vector<8xi1>
   return %v : vector<8xi1>
 }
 // CHECK-LABEL: @genbool_1d_var_but_constant()
 // CHECK-NEXT: ret <8 x i1> zeroinitializer