brintos / llvm-project-archived public Read only

1// RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s2 3// CHECK: @global_aligned32 = private global i64 42, align 324"llvm.mlir.global"() ({}) {sym_name = "global_aligned32", global_type = i64, value = 42 : i64, linkage = #llvm.linkage<private>, alignment = 32} : () -> ()5 6// CHECK: @global_aligned64 = private global i64 42, align 647llvm.mlir.global private @global_aligned64(42 : i64) {alignment = 64 : i64} : i648 9// CHECK: @global_aligned64_native = private global i64 42, align 6410llvm.mlir.global private @global_aligned64_native(42 : i64) { alignment = 64 } : i6411 12// CHECK: @i32_global = internal global i32 4213llvm.mlir.global internal @i32_global(42: i32) : i3214 15// CHECK: @i32_const = internal constant i53 5216llvm.mlir.global internal constant @i32_const(52: i53) : i5317 18// CHECK: @int_global_array = internal global [3 x i32] [i32 62, i32 62, i32 62]19llvm.mlir.global internal @int_global_array(dense<62> : vector<3xi32>) : !llvm.array<3 x i32>20 21// CHECK: @int_global_array_zero_elements = internal constant [3 x [0 x [4 x float]]] zeroinitializer22llvm.mlir.global internal constant @int_global_array_zero_elements(dense<> : tensor<3x0x4xf32>) : !llvm.array<3 x array<0 x array<4 x f32>>>23 24// CHECK: @int_global_array_zero_elements_1d = internal constant [0 x float] zeroinitializer25llvm.mlir.global internal constant @int_global_array_zero_elements_1d(dense<> : tensor<0xf32>) : !llvm.array<0 x f32>26 27// CHECK: @i32_global_addr_space = internal addrspace(7) global i32 6228llvm.mlir.global internal @i32_global_addr_space(62: i32) {addr_space = 7 : i32} : i3229 30// CHECK: @float_global = internal global float 0.000000e+0031llvm.mlir.global internal @float_global(0.0: f32) : f3232 33// CHECK: @float_global_array = internal global [1 x float] [float -5.000000e+00]34llvm.mlir.global internal @float_global_array(dense<[-5.0]> : vector<1xf32>) : !llvm.array<1 x f32>35 36// CHECK: @string_const = internal constant [6 x i8] c"foobar"37llvm.mlir.global internal constant @string_const("foobar") : !llvm.array<6 x i8>38 39// CHECK: @int_global_undef = internal global i64 undef40llvm.mlir.global internal @int_global_undef() : i6441 42// CHECK: @externally_initialized_global = internal externally_initialized global i32 043llvm.mlir.global internal @externally_initialized_global(0 : i32) {externally_initialized} : i3244 45// CHECK: @f4E2M1FN_global_as_i4 = internal global i4 346llvm.mlir.global internal @f4E2M1FN_global_as_i4(1.5 : f4E2M1FN) : i447 48// CHECK: @f6E2M3FN_global_as_i6 = internal global i6 1249llvm.mlir.global internal @f6E2M3FN_global_as_i6(1.5 : f6E2M3FN) : i650 51// CHECK: @f6E3M2FN_global_as_i6 = internal global i6 1452llvm.mlir.global internal @f6E3M2FN_global_as_i6(1.5 : f6E3M2FN) : i653 54// CHECK: @f8E3M4_global_as_i8 = internal global i8 5655llvm.mlir.global internal @f8E3M4_global_as_i8(1.5 : f8E3M4) : i856 57// CHECK: @f8E4M3_global_as_i8 = internal global i8 6058llvm.mlir.global internal @f8E4M3_global_as_i8(1.5 : f8E4M3) : i859 60// CHECK: @f8E4M3FN_global_as_i8 = internal global i8 6061llvm.mlir.global internal @f8E4M3FN_global_as_i8(1.5 : f8E4M3FN) : i862 63// CHECK: @f8E5M2_global_as_i8 = internal global i8 6264llvm.mlir.global internal @f8E5M2_global_as_i8(1.5 : f8E5M2) : i865 66// CHECK: @f8E4M3FNUZ_global_as_i8 = internal global i8 6867llvm.mlir.global internal @f8E4M3FNUZ_global_as_i8(1.5 : f8E4M3FNUZ) : i868 69// CHECK: @f8E5M2FNUZ_global_as_i8 = internal global i8 6670llvm.mlir.global internal @f8E5M2FNUZ_global_as_i8(1.5 : f8E5M2FNUZ) : i871 72// CHECK: @f8E4M3B11FNUZ_global_as_i8 = internal global i8 9273llvm.mlir.global internal @f8E4M3B11FNUZ_global_as_i8(1.5 : f8E4M3B11FNUZ) : i874 75// CHECK: @f8E8M0FNU_global_as_i8 = internal global i8 12776llvm.mlir.global internal @f8E8M0FNU_global_as_i8(1.0 : f8E8M0FNU) : i877 78// CHECK: @bf16_global_as_i16 = internal global i16 1632079llvm.mlir.global internal @bf16_global_as_i16(1.5 : bf16) : i1680 81// CHECK: @explicit_undef = global i32 undef82llvm.mlir.global external @explicit_undef() : i32 {83  %0 = llvm.mlir.undef : i3284  llvm.return %0 : i3285}86 87// CHECK: @int_gep = internal constant ptr getelementptr (i8, ptr @i32_global, i64 8)88llvm.mlir.global internal constant @int_gep() : !llvm.ptr {89  %addr = llvm.mlir.addressof @i32_global : !llvm.ptr90  %_c0 = llvm.mlir.constant(2: i32) : i3291  %gepinit = llvm.getelementptr %addr[%_c0] : (!llvm.ptr, i32) -> !llvm.ptr, i3292  llvm.return %gepinit : !llvm.ptr93}94 95// CHECK{LITERAL}: @dense_float_vector = internal global <3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>96llvm.mlir.global internal @dense_float_vector(dense<[1.0, 2.0, 3.0]> : vector<3xf32>) : vector<3xf32>97 98// CHECK{LITERAL}: @splat_float_vector = internal global <3 x float> splat (float 4.200000e+01)99llvm.mlir.global internal @splat_float_vector(dense<42.0> : vector<3xf32>) : vector<3xf32>100 101// CHECK{LITERAL}: @dense_double_vector = internal global <3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>102llvm.mlir.global internal @dense_double_vector(dense<[1.0, 2.0, 3.0]> : vector<3xf64>) : vector<3xf64>103 104// CHECK{LITERAL}: @splat_double_vector = internal global <3 x double> splat (double 4.200000e+01)105llvm.mlir.global internal @splat_double_vector(dense<42.0> : vector<3xf64>) : vector<3xf64>106 107// CHECK{LITERAL}: @dense_i64_vector = internal global <3 x i64> <i64 1, i64 2, i64 3>108llvm.mlir.global internal @dense_i64_vector(dense<[1, 2, 3]> : vector<3xi64>) : vector<3xi64>109 110// CHECK{LITERAL}: @splat_i64_vector = internal global <3 x i64> splat (i64 42)111llvm.mlir.global internal @splat_i64_vector(dense<42> : vector<3xi64>) : vector<3xi64>112 113// CHECK{LITERAL}: @dense_float_vector_2d = internal global [2 x <2 x float>] [<2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> <float 3.000000e+00, float 4.000000e+00>]114llvm.mlir.global internal @dense_float_vector_2d(dense<[[1.0, 2.0], [3.0, 4.0]]> : vector<2x2xf32>) : !llvm.array<2 x vector<2xf32>>115 116// CHECK{LITERAL}: @splat_float_vector_2d = internal global [2 x <2 x float>] [<2 x float> splat (float 4.200000e+01), <2 x float> splat (float 4.200000e+01)]117llvm.mlir.global internal @splat_float_vector_2d(dense<42.0> : vector<2x2xf32>) : !llvm.array<2 x vector<2xf32>>118 119// CHECK{LITERAL}: @dense_float_vector_3d = internal global [2 x [2 x <2 x float>]] [[2 x <2 x float>] [<2 x float> <float 1.000000e+00, float 2.000000e+00>, <2 x float> <float 3.000000e+00, float 4.000000e+00>], [2 x <2 x float>] [<2 x float> <float 5.000000e+00, float 6.000000e+00>, <2 x float> <float 7.000000e+00, float 8.000000e+00>]]120llvm.mlir.global internal @dense_float_vector_3d(dense<[[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]> : vector<2x2x2xf32>) : !llvm.array<2 x !llvm.array<2 x vector<2xf32>>>121 122// CHECK{LITERAL}: @splat_float_vector_3d = internal global [2 x [2 x <2 x float>]] [[2 x <2 x float>] [<2 x float> splat (float 4.200000e+01), <2 x float> splat (float 4.200000e+01)], [2 x <2 x float>] [<2 x float> splat (float 4.200000e+01), <2 x float> splat (float 4.200000e+01)]]123llvm.mlir.global internal @splat_float_vector_3d(dense<42.0> : vector<2x2x2xf32>) : !llvm.array<2 x !llvm.array<2 x vector<2xf32>>>124 125//126// Linkage attribute.127//128 129// CHECK: @private = private global i32 42130llvm.mlir.global private @private(42 : i32) : i32131// CHECK: @internal = internal global i32 42132llvm.mlir.global internal @internal(42 : i32) : i32133// CHECK: @available_externally = available_externally global i32 42134llvm.mlir.global available_externally @available_externally(42 : i32) : i32135// CHECK: @linkonce = linkonce global i32 42136llvm.mlir.global linkonce @linkonce(42 : i32) : i32137// CHECK: @weak = weak global i32 42138llvm.mlir.global weak @weak(42 : i32) : i32139// CHECK: @common = common global i32 0140llvm.mlir.global common @common(0 : i32) : i32141// CHECK: @appending = appending global [3 x i32] [i32 1, i32 2, i32 3]142llvm.mlir.global appending @appending(dense<[1,2,3]> : tensor<3xi32>) : !llvm.array<3 x i32>143// CHECK: @extern_weak = extern_weak global i32144llvm.mlir.global extern_weak @extern_weak() : i32145// CHECK: @linkonce_odr = linkonce_odr global i32 42146llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32147// CHECK: @weak_odr = weak_odr global i32 42148llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32149// CHECK: @external = external global i32150llvm.mlir.global external @external() : i32151 152 153//154// Visibility attribute.155//156 157// CHECK: @hidden = hidden constant [6 x i8] c"string"158llvm.mlir.global external hidden constant @hidden("string")159 160// CHECK: @protected = protected constant i64 42161llvm.mlir.global external protected constant @protected(42 : i64) : i64162 163//164// UnnamedAddr attribute.165//166 167// CHECK: @no_unnamed_addr = private constant i64 42168llvm.mlir.global private constant @no_unnamed_addr(42 : i64) : i64169// CHECK: @local_unnamed_addr = private local_unnamed_addr constant i64 42170llvm.mlir.global private local_unnamed_addr constant @local_unnamed_addr(42 : i64) : i64171// CHECK: @unnamed_addr = private unnamed_addr constant i64 42172llvm.mlir.global private unnamed_addr constant @unnamed_addr(42 : i64) : i64173 174//175// dso_local attribute.176//177 178llvm.mlir.global @has_dso_local(42 : i64) {dso_local} : i64179// CHECK: @has_dso_local = dso_local global i64 42180 181//182// thr_local attribute.183//184 185llvm.mlir.global thread_local @has_thr_local(42 : i64) : i64186// CHECK: @has_thr_local = thread_local global i64 42187 188//189// Section attribute.190//191 192// CHECK: @sectionvar = internal constant [10 x i8] c"teststring", section ".mysection"193llvm.mlir.global internal constant @sectionvar("teststring")  {section = ".mysection"}: !llvm.array<10 x i8>194 195//196// Declarations of the allocation functions to be linked against. These are197// inserted before other functions in the module.198//199 200// CHECK: declare ptr @malloc(i64)201llvm.func @malloc(i64) -> !llvm.ptr202// CHECK: declare void @free(ptr)203llvm.func @free(!llvm.ptr)204 205//206// Basic functionality: function and block conversion, function calls,207// phi nodes, scalar type conversion, arithmetic operations.208//209 210// CHECK-LABEL: define void @empty()211// CHECK-NEXT:    ret void212// CHECK-NEXT:  }213llvm.func @empty() {214  llvm.return215}216 217// CHECK-LABEL: @global_refs218llvm.func @global_refs() {219  // Check load from globals.220  // CHECK: load i32, ptr @i32_global221  %0 = llvm.mlir.addressof @i32_global : !llvm.ptr222  %1 = llvm.load %0 : !llvm.ptr -> i32223 224  // Check the contracted form of load from array constants.225  // CHECK: load i8, ptr @string_const226  %2 = llvm.mlir.addressof @string_const : !llvm.ptr227  %c0 = llvm.mlir.constant(0 : index) : i64228  %3 = llvm.getelementptr %2[%c0, %c0] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.array<6 x i8>229  %4 = llvm.load %3 : !llvm.ptr -> i8230 231  llvm.return232}233 234// CHECK-LABEL: declare void @body(i64)235llvm.func @body(i64)236 237 238// CHECK-LABEL: define void @simple_loop()239llvm.func @simple_loop() {240// CHECK: br label %[[SIMPLE_bb1:[0-9]+]]241  llvm.br ^bb1242 243// Constants are inlined in LLVM rather than a separate instruction.244// CHECK: [[SIMPLE_bb1]]:245// CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]]246^bb1:   // pred: ^bb0247  %0 = llvm.mlir.constant(1 : index) : i64248  %1 = llvm.mlir.constant(42 : index) : i64249  llvm.br ^bb2(%0 : i64)250 251// CHECK: [[SIMPLE_bb2]]:252// CHECK-NEXT:   %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %[[SIMPLE_bb3:[0-9]+]] ], [ 1, %[[SIMPLE_bb1]] ]253// CHECK-NEXT:   %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 42254// CHECK-NEXT:   br i1 %{{[0-9]+}}, label %[[SIMPLE_bb3]], label %[[SIMPLE_bb4:[0-9]+]]255^bb2(%2: i64): // 2 preds: ^bb1, ^bb3256  %3 = llvm.icmp "slt" %2, %1 : i64257  llvm.cond_br %3, ^bb3, ^bb4258 259// CHECK: [[SIMPLE_bb3]]:260// CHECK-NEXT:   call void @body(i64 %{{[0-9]+}})261// CHECK-NEXT:   %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1262// CHECK-NEXT:   br label %[[SIMPLE_bb2]]263^bb3:   // pred: ^bb2264  llvm.call @body(%2) : (i64) -> ()265  %4 = llvm.mlir.constant(1 : index) : i64266  %5 = llvm.add %2, %4 : i64267  llvm.br ^bb2(%5 : i64)268 269// CHECK: [[SIMPLE_bb4]]:270// CHECK-NEXT:    ret void271^bb4:   // pred: ^bb2272  llvm.return273}274 275// CHECK-LABEL: define void @simple_caller()276// CHECK-NEXT:   call void @simple_loop()277// CHECK-NEXT:   ret void278// CHECK-NEXT: }279llvm.func @simple_caller() {280  llvm.call @simple_loop() : () -> ()281  llvm.return282}283 284//func @simple_indirect_caller() {285//^bb0:286//  %f = constant @simple_loop : () -> ()287//  call_indirect %f() : () -> ()288//  return289//}290 291// CHECK-LABEL: define void @ml_caller()292// CHECK-NEXT:   call void @simple_loop()293// CHECK-NEXT:   call void @more_imperfectly_nested_loops()294// CHECK-NEXT:   ret void295// CHECK-NEXT: }296llvm.func @ml_caller() {297  llvm.call @simple_loop() : () -> ()298  llvm.call @more_imperfectly_nested_loops() : () -> ()299  llvm.return300}301 302// CHECK-LABEL: declare i64 @body_args(i64)303llvm.func @body_args(i64) -> i64304// CHECK-LABEL: declare i32 @other(i64, i32)305llvm.func @other(i64, i32) -> i32306 307// CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}})308// CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]]309llvm.func @func_args(%arg0: i32, %arg1: i32) -> i32 {310  %0 = llvm.mlir.constant(0 : i32) : i32311  llvm.br ^bb1312 313// CHECK: [[ARGS_bb1]]:314// CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]]315^bb1:   // pred: ^bb0316  %1 = llvm.mlir.constant(0 : index) : i64317  %2 = llvm.mlir.constant(42 : index) : i64318  llvm.br ^bb2(%1 : i64)319 320// CHECK: [[ARGS_bb2]]:321// CHECK-NEXT:   %5 = phi i64 [ %12, %[[ARGS_bb3:[0-9]+]] ], [ 0, %[[ARGS_bb1]] ]322// CHECK-NEXT:   %6 = icmp slt i64 %5, 42323// CHECK-NEXT:   br i1 %6, label %[[ARGS_bb3]], label %[[ARGS_bb4:[0-9]+]]324^bb2(%3: i64): // 2 preds: ^bb1, ^bb3325  %4 = llvm.icmp "slt" %3, %2 : i64326  llvm.cond_br %4, ^bb3, ^bb4327 328// CHECK: [[ARGS_bb3]]:329// CHECK-NEXT:   %8 = call i64 @body_args(i64 %5)330// CHECK-NEXT:   %9 = call i32 @other(i64 %8, i32 %0)331// CHECK-NEXT:   %10 = call i32 @other(i64 %8, i32 %9)332// CHECK-NEXT:   %11 = call i32 @other(i64 %8, i32 %1)333// CHECK-NEXT:   %12 = add i64 %5, 1334// CHECK-NEXT:   br label %[[ARGS_bb2]]335^bb3:   // pred: ^bb2336  %5 = llvm.call @body_args(%3) : (i64) -> i64337  %6 = llvm.call @other(%5, %arg0) : (i64, i32) -> i32338  %7 = llvm.call @other(%5, %6) : (i64, i32) -> i32339  %8 = llvm.call @other(%5, %arg1) : (i64, i32) -> i32340  %9 = llvm.mlir.constant(1 : index) : i64341  %10 = llvm.add %3, %9 : i64342  llvm.br ^bb2(%10 : i64)343 344// CHECK: [[ARGS_bb4]]:345// CHECK-NEXT:   %14 = call i32 @other(i64 0, i32 0)346// CHECK-NEXT:   ret i32 %14347^bb4:   // pred: ^bb2348  %11 = llvm.mlir.constant(0 : index) : i64349  %12 = llvm.call @other(%11, %0) : (i64, i32) -> i32350  llvm.return %12 : i32351}352 353// CHECK: declare void @pre(i64)354llvm.func @pre(i64)355 356// CHECK: declare void @body2(i64, i64)357llvm.func @body2(i64, i64)358 359// CHECK: declare void @post(i64)360llvm.func @post(i64)361 362// CHECK-LABEL: define void @imperfectly_nested_loops()363// CHECK-NEXT:   br label %[[IMPER_bb1:[0-9]+]]364llvm.func @imperfectly_nested_loops() {365  llvm.br ^bb1366 367// CHECK: [[IMPER_bb1]]:368// CHECK-NEXT:   br label %[[IMPER_bb2:[0-9]+]]369^bb1:   // pred: ^bb0370  %0 = llvm.mlir.constant(0 : index) : i64371  %1 = llvm.mlir.constant(42 : index) : i64372  llvm.br ^bb2(%0 : i64)373 374// CHECK: [[IMPER_bb2]]:375// CHECK-NEXT:   %3 = phi i64 [ %13, %[[IMPER_bb7:[0-9]+]] ], [ 0, %[[IMPER_bb1]] ]376// CHECK-NEXT:   %4 = icmp slt i64 %3, 42377// CHECK-NEXT:   br i1 %4, label %[[IMPER_bb3:[0-9]+]], label %[[IMPER_bb8:[0-9]+]]378^bb2(%2: i64): // 2 preds: ^bb1, ^bb7379  %3 = llvm.icmp "slt" %2, %1 : i64380  llvm.cond_br %3, ^bb3, ^bb8381 382// CHECK: [[IMPER_bb3]]:383// CHECK-NEXT:   call void @pre(i64 %3)384// CHECK-NEXT:   br label %[[IMPER_bb4:[0-9]+]]385^bb3:   // pred: ^bb2386  llvm.call @pre(%2) : (i64) -> ()387  llvm.br ^bb4388 389// CHECK: [[IMPER_bb4]]:390// CHECK-NEXT:   br label %[[IMPER_bb5:[0-9]+]]391^bb4:   // pred: ^bb3392  %4 = llvm.mlir.constant(7 : index) : i64393  %5 = llvm.mlir.constant(56 : index) : i64394  llvm.br ^bb5(%4 : i64)395 396// CHECK: [[IMPER_bb5]]:397// CHECK-NEXT:   %8 = phi i64 [ %11, %[[IMPER_bb6:[0-9]+]] ], [ 7, %[[IMPER_bb4]] ]398// CHECK-NEXT:   %9 = icmp slt i64 %8, 56399// CHECK-NEXT:   br i1 %9, label %[[IMPER_bb6]], label %[[IMPER_bb7]]400^bb5(%6: i64): // 2 preds: ^bb4, ^bb6401  %7 = llvm.icmp "slt" %6, %5 : i64402  llvm.cond_br %7, ^bb6, ^bb7403 404// CHECK: [[IMPER_bb6]]:405// CHECK-NEXT:   call void @body2(i64 %3, i64 %8)406// CHECK-NEXT:   %11 = add i64 %8, 2407// CHECK-NEXT:   br label %[[IMPER_bb5]]408^bb6:   // pred: ^bb5409  llvm.call @body2(%2, %6) : (i64, i64) -> ()410  %8 = llvm.mlir.constant(2 : index) : i64411  %9 = llvm.add %6, %8 : i64412  llvm.br ^bb5(%9 : i64)413 414// CHECK: [[IMPER_bb7]]:415// CHECK-NEXT:   call void @post(i64 %3)416// CHECK-NEXT:   %13 = add i64 %3, 1417// CHECK-NEXT:   br label %[[IMPER_bb2]]418^bb7:   // pred: ^bb5419  llvm.call @post(%2) : (i64) -> ()420  %10 = llvm.mlir.constant(1 : index) : i64421  %11 = llvm.add %2, %10 : i64422  llvm.br ^bb2(%11 : i64)423 424// CHECK: [[IMPER_bb8]]:425// CHECK-NEXT:   ret void426^bb8:   // pred: ^bb2427  llvm.return428}429 430// CHECK: declare void @mid(i64)431llvm.func @mid(i64)432 433// CHECK: declare void @body3(i64, i64)434llvm.func @body3(i64, i64)435 436// A complete function transformation check.437// CHECK-LABEL: define void @more_imperfectly_nested_loops()438// CHECK-NEXT:   br label %1439// CHECK: 1:                                      ; preds = %0440// CHECK-NEXT:   br label %2441// CHECK: 2:                                      ; preds = %19, %1442// CHECK-NEXT:   %3 = phi i64 [ %20, %19 ], [ 0, %1 ]443// CHECK-NEXT:   %4 = icmp slt i64 %3, 42444// CHECK-NEXT:   br i1 %4, label %5, label %21445// CHECK: 5:                                      ; preds = %2446// CHECK-NEXT:   call void @pre(i64 %3)447// CHECK-NEXT:   br label %6448// CHECK: 6:                                      ; preds = %5449// CHECK-NEXT:   br label %7450// CHECK: 7:                                      ; preds = %10, %6451// CHECK-NEXT:   %8 = phi i64 [ %11, %10 ], [ 7, %6 ]452// CHECK-NEXT:   %9 = icmp slt i64 %8, 56453// CHECK-NEXT:   br i1 %9, label %10, label %12454// CHECK: 10:                                     ; preds = %7455// CHECK-NEXT:   call void @body2(i64 %3, i64 %8)456// CHECK-NEXT:   %11 = add i64 %8, 2457// CHECK-NEXT:   br label %7458// CHECK: 12:                                     ; preds = %7459// CHECK-NEXT:   call void @mid(i64 %3)460// CHECK-NEXT:   br label %13461// CHECK: 13:                                     ; preds = %12462// CHECK-NEXT:   br label %14463// CHECK: 14:                                     ; preds = %17, %13464// CHECK-NEXT:   %15 = phi i64 [ %18, %17 ], [ 18, %13 ]465// CHECK-NEXT:   %16 = icmp slt i64 %15, 37466// CHECK-NEXT:   br i1 %16, label %17, label %19467// CHECK: 17:                                     ; preds = %14468// CHECK-NEXT:   call void @body3(i64 %3, i64 %15)469// CHECK-NEXT:   %18 = add i64 %15, 3470// CHECK-NEXT:   br label %14471// CHECK: 19:                                     ; preds = %14472// CHECK-NEXT:   call void @post(i64 %3)473// CHECK-NEXT:   %20 = add i64 %3, 1474// CHECK-NEXT:   br label %2475// CHECK: 21:                                     ; preds = %2476// CHECK-NEXT:   ret void477// CHECK-NEXT: }478llvm.func @more_imperfectly_nested_loops() {479  llvm.br ^bb1480^bb1:	// pred: ^bb0481  %0 = llvm.mlir.constant(0 : index) : i64482  %1 = llvm.mlir.constant(42 : index) : i64483  llvm.br ^bb2(%0 : i64)484^bb2(%2: i64):	// 2 preds: ^bb1, ^bb11485  %3 = llvm.icmp "slt" %2, %1 : i64486  llvm.cond_br %3, ^bb3, ^bb12487^bb3:	// pred: ^bb2488  llvm.call @pre(%2) : (i64) -> ()489  llvm.br ^bb4490^bb4:	// pred: ^bb3491  %4 = llvm.mlir.constant(7 : index) : i64492  %5 = llvm.mlir.constant(56 : index) : i64493  llvm.br ^bb5(%4 : i64)494^bb5(%6: i64):	// 2 preds: ^bb4, ^bb6495  %7 = llvm.icmp "slt" %6, %5 : i64496  llvm.cond_br %7, ^bb6, ^bb7497^bb6:	// pred: ^bb5498  llvm.call @body2(%2, %6) : (i64, i64) -> ()499  %8 = llvm.mlir.constant(2 : index) : i64500  %9 = llvm.add %6, %8 : i64501  llvm.br ^bb5(%9 : i64)502^bb7:	// pred: ^bb5503  llvm.call @mid(%2) : (i64) -> ()504  llvm.br ^bb8505^bb8:	// pred: ^bb7506  %10 = llvm.mlir.constant(18 : index) : i64507  %11 = llvm.mlir.constant(37 : index) : i64508  llvm.br ^bb9(%10 : i64)509^bb9(%12: i64):	// 2 preds: ^bb8, ^bb10510  %13 = llvm.icmp "slt" %12, %11 : i64511  llvm.cond_br %13, ^bb10, ^bb11512^bb10:	// pred: ^bb9513  llvm.call @body3(%2, %12) : (i64, i64) -> ()514  %14 = llvm.mlir.constant(3 : index) : i64515  %15 = llvm.add %12, %14 : i64516  llvm.br ^bb9(%15 : i64)517^bb11:	// pred: ^bb9518  llvm.call @post(%2) : (i64) -> ()519  %16 = llvm.mlir.constant(1 : index) : i64520  %17 = llvm.add %2, %16 : i64521  llvm.br ^bb2(%17 : i64)522^bb12:	// pred: ^bb2523  llvm.return524}525 526 527//528// Check that linkage is translated for functions. No need to check all linkage529// flags since the logic is the same as for globals.530//531 532// CHECK: define internal void @func_internal533llvm.func internal @func_internal() {534  llvm.return535}536 537//538// Visibility attribute.539//540 541// CHECK-LABEL: define hidden void @hidden_func()542llvm.func hidden @hidden_func() {543  llvm.return544}545 546// CHECK-LABEL: define protected void @protected_func()547llvm.func protected @protected_func() {548  llvm.return549}550 551//552// dso_local attribute.553//554 555// CHECK: define dso_local void @dso_local_func556llvm.func @dso_local_func() attributes {dso_local} {557  llvm.return558}559 560//561// MemRef type conversion, allocation and communication with functions.562//563 564// CHECK-LABEL: define void @memref_alloc()565llvm.func @memref_alloc() {566// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 400)567// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr } undef, ptr %{{[0-9]+}}, 0568  %0 = llvm.mlir.constant(10 : index) : i64569  %1 = llvm.mlir.constant(10 : index) : i64570  %2 = llvm.mul %0, %1 : i64571  %3 = llvm.mlir.undef : !llvm.struct<(ptr)>572  %4 = llvm.mlir.constant(4 : index) : i64573  %5 = llvm.mul %2, %4 : i64574  %6 = llvm.call @malloc(%5) : (i64) -> !llvm.ptr575  %7 = llvm.insertvalue %6, %3[0] : !llvm.struct<(ptr)>576// CHECK-NEXT: ret void577  llvm.return578}579 580// CHECK-LABEL: declare i64 @get_index()581llvm.func @get_index() -> i64582 583// CHECK-LABEL: define void @store_load_static()584llvm.func @store_load_static() {585^bb0:586// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 40)587// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr } undef, ptr %{{[0-9]+}}, 0588  %0 = llvm.mlir.constant(10 : index) : i64589  %1 = llvm.mlir.undef : !llvm.struct<(ptr)>590  %2 = llvm.mlir.constant(4 : index) : i64591  %3 = llvm.mul %0, %2 : i64592  %4 = llvm.call @malloc(%3) : (i64) -> !llvm.ptr593  %6 = llvm.insertvalue %4, %1[0] : !llvm.struct<(ptr)>594  %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32595  llvm.br ^bb1596^bb1:   // pred: ^bb0597  %8 = llvm.mlir.constant(0 : index) : i64598  %9 = llvm.mlir.constant(10 : index) : i64599  llvm.br ^bb2(%8 : i64)600// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]601^bb2(%10: i64):        // 2 preds: ^bb1, ^bb3602// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10603  %11 = llvm.icmp "slt" %10, %9 : i64604// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}605  llvm.cond_br %11, ^bb3, ^bb4606^bb3:   // pred: ^bb2607// CHECK: %{{[0-9]+}} = extractvalue { ptr } %{{[0-9]+}}, 0608// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}609// CHECK-NEXT: store float 1.000000e+00, ptr %{{[0-9]+}}610  %12 = llvm.mlir.constant(10 : index) : i64611  %13 = llvm.extractvalue %6[0] : !llvm.struct<(ptr)>612  %14 = llvm.getelementptr %13[%10] : (!llvm.ptr, i64) -> !llvm.ptr, f32613  llvm.store %7, %14 : f32, !llvm.ptr614  %15 = llvm.mlir.constant(1 : index) : i64615// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1616  %16 = llvm.add %10, %15 : i64617// CHECK-NEXT: br label %{{[0-9]+}}618  llvm.br ^bb2(%16 : i64)619^bb4:   // pred: ^bb2620  llvm.br ^bb5621^bb5:   // pred: ^bb4622  %17 = llvm.mlir.constant(0 : index) : i64623  %18 = llvm.mlir.constant(10 : index) : i64624  llvm.br ^bb6(%17 : i64)625// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]626^bb6(%19: i64):        // 2 preds: ^bb5, ^bb7627// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10628  %20 = llvm.icmp "slt" %19, %18 : i64629// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}630  llvm.cond_br %20, ^bb7, ^bb8631^bb7:   // pred: ^bb6632// CHECK:      %{{[0-9]+}} = extractvalue { ptr } %{{[0-9]+}}, 0633// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}634// CHECK-NEXT: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}635  %21 = llvm.mlir.constant(10 : index) : i64636  %22 = llvm.extractvalue %6[0] : !llvm.struct<(ptr)>637  %23 = llvm.getelementptr %22[%19] : (!llvm.ptr, i64) -> !llvm.ptr, f32638  %24 = llvm.load %23 : !llvm.ptr -> f32639  %25 = llvm.mlir.constant(1 : index) : i64640// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1641  %26 = llvm.add %19, %25 : i64642// CHECK-NEXT: br label %{{[0-9]+}}643  llvm.br ^bb6(%26 : i64)644^bb8:   // pred: ^bb6645// CHECK: ret void646  llvm.return647}648 649// CHECK-LABEL: define void @store_load_dynamic(i64 {{%.*}})650llvm.func @store_load_dynamic(%arg0: i64) {651// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4652// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})653// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } undef, ptr %{{[0-9]+}}, 0654// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1655  %0 = llvm.mlir.undef : !llvm.struct<(ptr, i64)>656  %1 = llvm.mlir.constant(4 : index) : i64657  %2 = llvm.mul %arg0, %1 : i64658  %3 = llvm.call @malloc(%2) : (i64) -> !llvm.ptr659  %5 = llvm.insertvalue %3, %0[0] : !llvm.struct<(ptr, i64)>660  %6 = llvm.insertvalue %arg0, %5[1] : !llvm.struct<(ptr, i64)>661  %7 = llvm.mlir.constant(1.000000e+00 : f32) : f32662// CHECK-NEXT: br label %{{[0-9]+}}663  llvm.br ^bb1664^bb1:   // pred: ^bb0665  %8 = llvm.mlir.constant(0 : index) : i64666  llvm.br ^bb2(%8 : i64)667// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]668^bb2(%9: i64): // 2 preds: ^bb1, ^bb3669// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}670  %10 = llvm.icmp "slt" %9, %arg0 : i64671// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}672  llvm.cond_br %10, ^bb3, ^bb4673^bb3:   // pred: ^bb2674// CHECK:      %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 1675// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 0676// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}677// CHECK-NEXT: store float 1.000000e+00, ptr %{{[0-9]+}}678  %11 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, i64)>679  %12 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, i64)>680  %13 = llvm.getelementptr %12[%9] : (!llvm.ptr, i64) -> !llvm.ptr, f32681  llvm.store %7, %13 : f32, !llvm.ptr682  %14 = llvm.mlir.constant(1 : index) : i64683// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1684  %15 = llvm.add %9, %14 : i64685// CHECK-NEXT: br label %{{[0-9]+}}686  llvm.br ^bb2(%15 : i64)687^bb4:   // pred: ^bb3688  llvm.br ^bb5689^bb5:   // pred: ^bb4690  %16 = llvm.mlir.constant(0 : index) : i64691  llvm.br ^bb6(%16 : i64)692// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]693^bb6(%17: i64):        // 2 preds: ^bb5, ^bb7694// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}695  %18 = llvm.icmp "slt" %17, %arg0 : i64696// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}697  llvm.cond_br %18, ^bb7, ^bb8698^bb7:   // pred: ^bb6699// CHECK:      %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 1700// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 0701// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}702// CHECK-NEXT: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}703  %19 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, i64)>704  %20 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, i64)>705  %21 = llvm.getelementptr %20[%17] : (!llvm.ptr, i64) -> !llvm.ptr, f32706  %22 = llvm.load %21 : !llvm.ptr -> f32707  %23 = llvm.mlir.constant(1 : index) : i64708// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1709  %24 = llvm.add %17, %23 : i64710// CHECK-NEXT: br label %{{[0-9]+}}711  llvm.br ^bb6(%24 : i64)712^bb8:   // pred: ^bb6713// CHECK: ret void714  llvm.return715}716 717// CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}})718llvm.func @store_load_mixed(%arg0: i64) {719  %0 = llvm.mlir.constant(10 : index) : i64720// CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}}721// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4722// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10723// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4724// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})725// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } undef, ptr %{{[0-9]+}}, 0726// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1727// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64, i64 } %{{[0-9]+}}, i64 10, 2728  %1 = llvm.mlir.constant(2 : index) : i64729  %2 = llvm.mlir.constant(4 : index) : i64730  %3 = llvm.mul %1, %arg0 : i64731  %4 = llvm.mul %3, %2 : i64732  %5 = llvm.mul %4, %0 : i64733  %6 = llvm.mlir.undef : !llvm.struct<(ptr, i64, i64)>734  %7 = llvm.mlir.constant(4 : index) : i64735  %8 = llvm.mul %5, %7 : i64736  %9 = llvm.call @malloc(%8) : (i64) -> !llvm.ptr737  %11 = llvm.insertvalue %9, %6[0] : !llvm.struct<(ptr, i64, i64)>738  %12 = llvm.insertvalue %arg0, %11[1] : !llvm.struct<(ptr, i64, i64)>739  %13 = llvm.insertvalue %0, %12[2] : !llvm.struct<(ptr, i64, i64)>740 741// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()742// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()743  %14 = llvm.mlir.constant(1 : index) : i64744  %15 = llvm.mlir.constant(2 : index) : i64745  %16 = llvm.call @get_index() : () -> i64746  %17 = llvm.call @get_index() : () -> i64747  %18 = llvm.mlir.constant(4.200000e+01 : f32) : f32748  %19 = llvm.mlir.constant(2 : index) : i64749// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 1750// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 2751// CHECK-NEXT: %{{[0-9]+}} = mul i64 1, %{{[0-9]+}}752// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2753// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4754// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}755// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}756// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}757// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 0758// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}759// CHECK-NEXT: store float 4.200000e+01, ptr %{{[0-9]+}}760  %20 = llvm.extractvalue %13[1] : !llvm.struct<(ptr, i64, i64)>761  %21 = llvm.mlir.constant(4 : index) : i64762  %22 = llvm.extractvalue %13[2] : !llvm.struct<(ptr, i64, i64)>763  %23 = llvm.mul %14, %20 : i64764  %24 = llvm.add %23, %15 : i64765  %25 = llvm.mul %24, %21 : i64766  %26 = llvm.add %25, %16 : i64767  %27 = llvm.mul %26, %22 : i64768  %28 = llvm.add %27, %17 : i64769  %29 = llvm.extractvalue %13[0] : !llvm.struct<(ptr, i64, i64)>770  %30 = llvm.getelementptr %29[%28] : (!llvm.ptr, i64) -> !llvm.ptr, f32771  llvm.store %18, %30 : f32, !llvm.ptr772// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 1773// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 2774// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}775// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}776// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4777// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2778// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}779// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1780// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64, i64 } %{{[0-9]+}}, 0781// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}782// CHECK-NEXT: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}783  %31 = llvm.mlir.constant(2 : index) : i64784  %32 = llvm.extractvalue %13[1] : !llvm.struct<(ptr, i64, i64)>785  %33 = llvm.mlir.constant(4 : index) : i64786  %34 = llvm.extractvalue %13[2] : !llvm.struct<(ptr, i64, i64)>787  %35 = llvm.mul %17, %32 : i64788  %36 = llvm.add %35, %16 : i64789  %37 = llvm.mul %36, %33 : i64790  %38 = llvm.add %37, %15 : i64791  %39 = llvm.mul %38, %34 : i64792  %40 = llvm.add %39, %14 : i64793  %41 = llvm.extractvalue %13[0] : !llvm.struct<(ptr, i64, i64)>794  %42 = llvm.getelementptr %41[%40] : (!llvm.ptr, i64) -> !llvm.ptr, f32795  %43 = llvm.load %42 : !llvm.ptr -> f32796// CHECK-NEXT: ret void797  llvm.return798}799 800// CHECK-LABEL: define { ptr, i64 } @memref_args_rets({ ptr } {{%.*}}, { ptr, i64 } {{%.*}}, { ptr, i64 } {{%.*}})801llvm.func @memref_args_rets(%arg0: !llvm.struct<(ptr)>, %arg1: !llvm.struct<(ptr, i64)>, %arg2: !llvm.struct<(ptr, i64)>) -> !llvm.struct<(ptr, i64)> {802  %0 = llvm.mlir.constant(7 : index) : i64803// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()804  %1 = llvm.call @get_index() : () -> i64805  %2 = llvm.mlir.constant(4.200000e+01 : f32) : f32806// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr } %{{[0-9]+}}, 0807// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 7808// CHECK-NEXT: store float 4.200000e+01, ptr %{{[0-9]+}}809  %3 = llvm.mlir.constant(10 : index) : i64810  %4 = llvm.extractvalue %arg0[0] : !llvm.struct<(ptr)>811  %5 = llvm.getelementptr %4[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32812  llvm.store %2, %5 : f32, !llvm.ptr813// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 1814// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 0815// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 7816// CHECK-NEXT: store float 4.200000e+01, ptr %{{[0-9]+}}817  %6 = llvm.extractvalue %arg1[1] : !llvm.struct<(ptr, i64)>818  %7 = llvm.extractvalue %arg1[0] : !llvm.struct<(ptr, i64)>819  %8 = llvm.getelementptr %7[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32820  llvm.store %2, %8 : f32, !llvm.ptr821// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 1822// CHECK-NEXT: %{{[0-9]+}} = mul i64 7, %{{[0-9]+}}823// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}824// CHECK-NEXT: %{{[0-9]+}} = extractvalue { ptr, i64 } %{{[0-9]+}}, 0825// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}826// CHECK-NEXT: store float 4.200000e+01, ptr %{{[0-9]+}}827  %9 = llvm.mlir.constant(10 : index) : i64828  %10 = llvm.extractvalue %arg2[1] : !llvm.struct<(ptr, i64)>829  %11 = llvm.mul %0, %10 : i64830  %12 = llvm.add %11, %1 : i64831  %13 = llvm.extractvalue %arg2[0] : !llvm.struct<(ptr, i64)>832  %14 = llvm.getelementptr %13[%12] : (!llvm.ptr, i64) -> !llvm.ptr, f32833  llvm.store %2, %14 : f32, !llvm.ptr834// CHECK-NEXT: %{{[0-9]+}} = mul i64 10, %{{[0-9]+}}835// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4836// CHECK-NEXT: %{{[0-9]+}} = call ptr @malloc(i64 %{{[0-9]+}})837// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } undef, ptr %{{[0-9]+}}, 0838// CHECK-NEXT: %{{[0-9]+}} = insertvalue { ptr, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1839  %15 = llvm.mlir.constant(10 : index) : i64840  %16 = llvm.mul %15, %1 : i64841  %17 = llvm.mlir.undef : !llvm.struct<(ptr, i64)>842  %18 = llvm.mlir.constant(4 : index) : i64843  %19 = llvm.mul %16, %18 : i64844  %20 = llvm.call @malloc(%19) : (i64) -> !llvm.ptr845  %22 = llvm.insertvalue %20, %17[0] : !llvm.struct<(ptr, i64)>846  %23 = llvm.insertvalue %1, %22[1] : !llvm.struct<(ptr, i64)>847// CHECK-NEXT: ret { ptr, i64 } %{{[0-9]+}}848  llvm.return %23 : !llvm.struct<(ptr, i64)>849}850 851 852// CHECK-LABEL: define i64 @memref_dim({ ptr, i64, i64 } {{%.*}})853llvm.func @memref_dim(%arg0: !llvm.struct<(ptr, i64, i64)>) -> i64 {854// Expecting this to create an LLVM constant.855  %0 = llvm.mlir.constant(42 : index) : i64856// CHECK-NEXT: %2 = extractvalue { ptr, i64, i64 } %0, 1857  %1 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr, i64, i64)>858// Expecting this to create an LLVM constant.859  %2 = llvm.mlir.constant(10 : index) : i64860// CHECK-NEXT: %3 = extractvalue { ptr, i64, i64 } %0, 2861  %3 = llvm.extractvalue %arg0[2] : !llvm.struct<(ptr, i64, i64)>862// Checking that the constant for d0 has been created.863// CHECK-NEXT: %4 = add i64 42, %2864  %4 = llvm.add %0, %1 : i64865// Checking that the constant for d2 has been created.866// CHECK-NEXT: %5 = add i64 10, %3867  %5 = llvm.add %2, %3 : i64868// CHECK-NEXT: %6 = add i64 %4, %5869  %6 = llvm.add %4, %5 : i64870// CHECK-NEXT: ret i64 %6871  llvm.return %6 : i64872}873 874llvm.func @get_i64() -> i64875llvm.func @get_f32() -> f32876llvm.func @get_memref() -> !llvm.struct<(ptr, i64, i64)>877 878// CHECK-LABEL: define { i64, float, { ptr, i64, i64 } } @multireturn()879llvm.func @multireturn() -> !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)> {880  %0 = llvm.call @get_i64() : () -> i64881  %1 = llvm.call @get_f32() : () -> f32882  %2 = llvm.call @get_memref() : () -> !llvm.struct<(ptr, i64, i64)>883// CHECK:        %{{[0-9]+}} = insertvalue { i64, float, { ptr, i64, i64 } } undef, i64 %{{[0-9]+}}, 0884// CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { ptr, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1885// CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { ptr, i64, i64 } } %{{[0-9]+}}, { ptr, i64, i64 } %{{[0-9]+}}, 2886// CHECK-NEXT:   ret { i64, float, { ptr, i64, i64 } } %{{[0-9]+}}887  %3 = llvm.mlir.undef : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>888  %4 = llvm.insertvalue %0, %3[0] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>889  %5 = llvm.insertvalue %1, %4[1] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>890  %6 = llvm.insertvalue %2, %5[2] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>891  llvm.return %6 : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>892}893 894 895// CHECK-LABEL: define void @multireturn_caller()896llvm.func @multireturn_caller() {897// CHECK-NEXT:   %1 = call { i64, float, { ptr, i64, i64 } } @multireturn()898// CHECK-NEXT:   [[ret0:%[0-9]+]] = extractvalue { i64, float, { ptr, i64, i64 } } %1, 0899// CHECK-NEXT:   [[ret1:%[0-9]+]] = extractvalue { i64, float, { ptr, i64, i64 } } %1, 1900// CHECK-NEXT:   [[ret2:%[0-9]+]] = extractvalue { i64, float, { ptr, i64, i64 } } %1, 2901  %0 = llvm.call @multireturn() : () -> !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>902  %1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>903  %2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>904  %3 = llvm.extractvalue %0[2] : !llvm.struct<(i64, f32, struct<(ptr, i64, i64)>)>905  %4 = llvm.mlir.constant(42) : i64906// CHECK:   add i64 [[ret0]], 42907  %5 = llvm.add %1, %4 : i64908  %6 = llvm.mlir.constant(4.200000e+01 : f32) : f32909// CHECK:   fadd float [[ret1]], 4.200000e+01910  %7 = llvm.fadd %2, %6 : f32911  %8 = llvm.mlir.constant(0 : index) : i64912  %9 = llvm.mlir.constant(42 : index) : i64913// CHECK:   extractvalue { ptr, i64, i64 } [[ret2]], 0914  %10 = llvm.extractvalue %3[1] : !llvm.struct<(ptr, i64, i64)>915  %11 = llvm.mlir.constant(10 : index) : i64916  %12 = llvm.extractvalue %3[2] : !llvm.struct<(ptr, i64, i64)>917  %13 = llvm.mul %8, %10 : i64918  %14 = llvm.add %13, %8 : i64919  %15 = llvm.mul %14, %11 : i64920  %16 = llvm.add %15, %8 : i64921  %17 = llvm.mul %16, %12 : i64922  %18 = llvm.add %17, %8 : i64923  %19 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, i64, i64)>924  %20 = llvm.getelementptr %19[%18] : (!llvm.ptr, i64) -> !llvm.ptr, f32925  %21 = llvm.load %20 : !llvm.ptr -> f32926  llvm.return927}928 929// CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}})930llvm.func @vector_ops(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>) -> vector<4xf32> {931  %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : vector<4xf32>932// CHECK-NEXT: %4 = fadd <4 x float> %0, splat (float 4.200000e+01)933  %1 = llvm.fadd %arg0, %0 : vector<4xf32>934// CHECK-NEXT: %5 = select <4 x i1> %1, <4 x float> %4, <4 x float> %0935  %2 = llvm.select %arg1, %1, %arg0 : vector<4xi1>, vector<4xf32>936// CHECK-NEXT: %6 = sdiv <4 x i64> %2, %2937  %3 = llvm.sdiv %arg2, %arg2 : vector<4xi64>938// CHECK-NEXT: %7 = udiv <4 x i64> %2, %2939  %4 = llvm.udiv %arg2, %arg2 : vector<4xi64>940// CHECK-NEXT: %8 = srem <4 x i64> %2, %2941  %5 = llvm.srem %arg2, %arg2 : vector<4xi64>942// CHECK-NEXT: %9 = urem <4 x i64> %2, %2943  %6 = llvm.urem %arg2, %arg2 : vector<4xi64>944// CHECK-NEXT: %10 = fdiv <4 x float> %0, splat (float 4.200000e+01)945  %7 = llvm.fdiv %arg0, %0 : vector<4xf32>946// CHECK-NEXT: %11 = frem <4 x float> %0, splat (float 4.200000e+01)947  %8 = llvm.frem %arg0, %0 : vector<4xf32>948// CHECK-NEXT: %12 = and <4 x i64> %2, %2949  %9 = llvm.and %arg2, %arg2 : vector<4xi64>950// CHECK-NEXT: %13 = or <4 x i64> %2, %2951  %10 = llvm.or %arg2, %arg2 : vector<4xi64>952// CHECK-NEXT: %14 = xor <4 x i64> %2, %2953  %11 = llvm.xor %arg2, %arg2 : vector<4xi64>954// CHECK-NEXT: %15 = shl <4 x i64> %2, %2955  %12 = llvm.shl %arg2, %arg2 : vector<4xi64>956// CHECK-NEXT: %16 = lshr <4 x i64> %2, %2957  %13 = llvm.lshr %arg2, %arg2 : vector<4xi64>958// CHECK-NEXT: %17 = ashr <4 x i64> %2, %2959  %14 = llvm.ashr %arg2, %arg2 : vector<4xi64>960// CHECK-NEXT:    ret <4 x float> %4961  llvm.return %1 : vector<4xf32>962}963 964// CHECK-LABEL: @vector_splat_1d965llvm.func @vector_splat_1d() -> vector<4xf32> {966  // CHECK: ret <4 x float> zeroinitializer967  %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4xf32>) : vector<4xf32>968  llvm.return %0 : vector<4xf32>969}970 971// CHECK-LABEL: @vector_splat_1d_scalable972llvm.func @vector_splat_1d_scalable() -> vector<[4]xf32> {973  // CHECK: ret <vscale x 4 x float> zeroinitializer974  %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>975  llvm.return %0 : vector<[4]xf32>976}977 978// CHECK-LABEL: @vector_splat_2d979llvm.func @vector_splat_2d() -> !llvm.array<4 x vector<16 x f32>> {980  // CHECK: ret [4 x <16 x float>] zeroinitializer981  %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4x16xf32>) : !llvm.array<4 x vector<16 x f32>>982  llvm.return %0 : !llvm.array<4 x vector<16 x f32>>983}984 985// CHECK-LABEL: @vector_splat_3d986llvm.func @vector_splat_3d() -> !llvm.array<4 x array<16 x vector<4 x f32>>> {987  // CHECK: ret [4 x [16 x <4 x float>]] zeroinitializer988  %0 = llvm.mlir.constant(dense<0.000000e+00> : vector<4x16x4xf32>) : !llvm.array<4 x array<16 x vector<4 x f32>>>989  llvm.return %0 : !llvm.array<4 x array<16 x vector<4 x f32>>>990}991 992// CHECK-LABEL: @vector_splat_nonzero993llvm.func @vector_splat_nonzero() -> vector<4xf32> {994  // CHECK: ret <4 x float> splat (float 1.000000e+00)995  %0 = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>996  llvm.return %0 : vector<4xf32>997}998 999// CHECK-LABEL: @vector_splat_nonzero_scalable1000llvm.func @vector_splat_nonzero_scalable() -> vector<[4]xf32> {1001  // CHECK: ret <vscale x 4 x float> splat (float 1.000000e+00)1002  %0 = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>1003  llvm.return %0 : vector<[4]xf32>1004}1005 1006// CHECK-LABEL: @ops1007llvm.func @ops(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32) -> !llvm.struct<(f32, i32)> {1008// CHECK-NEXT: fsub float %0, %11009  %0 = llvm.fsub %arg0, %arg1 : f321010// CHECK-NEXT: %6 = sub i32 %2, %31011  %1 = llvm.sub %arg2, %arg3 : i321012// CHECK-NEXT: %7 = icmp slt i32 %2, %61013  %2 = llvm.icmp "slt" %arg2, %1 : i321014// CHECK-NEXT: %8 = select i1 %7, i32 %2, i32 %61015  %3 = llvm.select %2, %arg2, %1 : i1, i321016// CHECK-NEXT: %9 = sdiv i32 %2, %31017  %4 = llvm.sdiv %arg2, %arg3 : i321018// CHECK-NEXT: %10 = udiv i32 %2, %31019  %5 = llvm.udiv %arg2, %arg3 : i321020// CHECK-NEXT: %11 = srem i32 %2, %31021  %6 = llvm.srem %arg2, %arg3 : i321022// CHECK-NEXT: %12 = urem i32 %2, %31023  %7 = llvm.urem %arg2, %arg3 : i321024 1025  %8 = llvm.mlir.undef : !llvm.struct<(f32, i32)>1026  %9 = llvm.insertvalue %0, %8[0] : !llvm.struct<(f32, i32)>1027  %10 = llvm.insertvalue %3, %9[1] : !llvm.struct<(f32, i32)>1028 1029// CHECK: %15 = fdiv float %0, %11030  %11 = llvm.fdiv %arg0, %arg1 : f321031// CHECK-NEXT: %16 = frem float %0, %11032  %12 = llvm.frem %arg0, %arg1 : f321033 1034// CHECK-NEXT: %17 = and i32 %2, %31035  %13 = llvm.and %arg2, %arg3 : i321036// CHECK-NEXT: %18 = or i32 %2, %31037  %14 = llvm.or %arg2, %arg3 : i321038// CHECK-NEXT: %19 = xor i32 %2, %31039  %15 = llvm.xor %arg2, %arg3 : i321040// CHECK-NEXT: %20 = shl i32 %2, %31041  %16 = llvm.shl %arg2, %arg3 : i321042// CHECK-NEXT: %21 = lshr i32 %2, %31043  %17 = llvm.lshr %arg2, %arg3 : i321044// CHECK-NEXT: %22 = ashr i32 %2, %31045  %18 = llvm.ashr %arg2, %arg3 : i321046 1047// CHECK-NEXT: fneg float %01048  %19 = llvm.fneg %arg0 : f321049 1050  llvm.return %10 : !llvm.struct<(f32, i32)>1051}1052 1053// CHECK-LABEL: @gep1054llvm.func @gep(%ptr: !llvm.ptr, %idx: i64,1055               %ptr2: !llvm.ptr) {1056  // CHECK: = getelementptr { i32, { i32, float } }, ptr %{{.*}}, i64 %{{.*}}, i32 1, i32 01057  llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, struct<(i32, f32)>)>1058  // CHECK: = getelementptr inbounds { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}1059  llvm.getelementptr inbounds %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>1060  // CHECK: = getelementptr inbounds nuw { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}1061  llvm.getelementptr inbounds | nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>1062  // CHECK: = getelementptr nusw { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}1063  llvm.getelementptr nusw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>1064  // CHECK: = getelementptr nusw nuw { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}1065  llvm.getelementptr nusw | nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>1066  // CHECK: = getelementptr nuw { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}1067  llvm.getelementptr nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>1068  llvm.return1069}1070 1071//1072// Indirect function calls1073//1074 1075// CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}})1076llvm.func @indirect_const_call(%arg0: i64) {1077// CHECK-NEXT:  call void @body(i64 %0)1078  %0 = llvm.mlir.addressof @body : !llvm.ptr1079  llvm.call %0(%arg0) : !llvm.ptr, (i64) -> ()1080// CHECK-NEXT:  ret void1081  llvm.return1082}1083 1084// CHECK-LABEL: define i32 @indirect_call(ptr addrspace(42) {{%.*}}, float {{%.*}})1085llvm.func @indirect_call(%arg0: !llvm.ptr<42>, %arg1: f32) -> i32 {1086// CHECK-NEXT:  %3 = call addrspace(42) i32 %0(float %1)1087  %0 = llvm.call %arg0(%arg1) : !llvm.ptr<42>, (f32) -> i321088// CHECK-NEXT:  ret i32 %31089  llvm.return %0 : i321090}1091 1092//1093// Check that we properly construct phi nodes in the blocks that have the same1094// predecessor more than once.1095//1096 1097// CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}})1098llvm.func @cond_br_arguments(%arg0: i1, %arg1: i1) {1099// CHECK-NEXT:   br i1 %0, label %3, label %51100  llvm.cond_br %arg0, ^bb1(%arg0 : i1), ^bb21101 1102// CHECK:      3:1103// CHECK-NEXT:   %4 = phi i1 [ %1, %5 ], [ %0, %2 ]1104^bb1(%0 : i1):1105// CHECK-NEXT:   ret void1106  llvm.return1107 1108// CHECK:      5:1109^bb2:1110// CHECK-NEXT:   br label %31111  llvm.br ^bb1(%arg1 : i1)1112}1113 1114// CHECK-LABEL: define void @llvm_noalias(ptr noalias {{%*.}})1115llvm.func @llvm_noalias(%arg0: !llvm.ptr {llvm.noalias}) {1116  llvm.return1117}1118 1119// CHECK-LABEL: declare void @llvm_noalias_decl(ptr noalias)1120llvm.func @llvm_noalias_decl(!llvm.ptr {llvm.noalias})1121 1122// CHECK-LABEL: define void @byrefattr(ptr byref(i32) %1123llvm.func @byrefattr(%arg0: !llvm.ptr {llvm.byref = i32}) {1124  llvm.return1125}1126 1127// CHECK-LABEL: declare void @byrefattr_decl(ptr byref(i32))1128llvm.func @byrefattr_decl(!llvm.ptr {llvm.byref = i32})1129 1130// CHECK-LABEL: define void @byvalattr(ptr byval(i32) %1131llvm.func @byvalattr(%arg0: !llvm.ptr {llvm.byval = i32}) {1132  llvm.return1133}1134 1135// CHECK-LABEL: declare void @byvalattr_decl(ptr byval(i32))1136llvm.func @byvalattr_decl(!llvm.ptr {llvm.byval = i32})1137 1138// CHECK-LABEL: define void @sretattr(ptr sret(i32) %1139llvm.func @sretattr(%arg0: !llvm.ptr {llvm.sret = i32}) {1140  llvm.return1141}1142 1143// CHECK-LABEL: declare void @sretattr_decl(ptr sret(i32))1144llvm.func @sretattr_decl(!llvm.ptr {llvm.sret = i32})1145 1146// CHECK-LABEL: define void @nestattr(ptr nest %1147llvm.func @nestattr(%arg0: !llvm.ptr {llvm.nest}) {1148  llvm.return1149}1150 1151// CHECK-LABEL: declare void @nestattr_decl(ptr nest)1152llvm.func @nestattr_decl(!llvm.ptr {llvm.nest})1153 1154// CHECK-LABEL: define void @noundefattr(i32 noundef %1155llvm.func @noundefattr(%arg0: i32 {llvm.noundef}) {1156  llvm.return1157}1158 1159// CHECK-LABEL: declare void @noundefattr_decl(i32 noundef)1160llvm.func @noundefattr_decl(i32 {llvm.noundef})1161 1162// CHECK-LABEL: define void @llvm_align(ptr align 4 {{%*.}})1163llvm.func @llvm_align(%arg0: !llvm.ptr {llvm.align = 4}) {1164  llvm.return1165}1166 1167// CHECK-LABEL: declare void @llvm_align_decl(ptr align 4)1168llvm.func @llvm_align_decl(!llvm.ptr {llvm.align = 4})1169 1170// CHECK-LABEL: define void @inallocaattr(ptr inalloca(i32) %1171llvm.func @inallocaattr(%arg0: !llvm.ptr {llvm.inalloca = i32}) {1172  llvm.return1173}1174 1175// CHECK-LABEL: declare void @inallocaattr_decl(ptr inalloca(i32))1176llvm.func @inallocaattr_decl(!llvm.ptr {llvm.inalloca = i32})1177 1178// CHECK-LABEL: define void @signextattr(i1 signext %1179llvm.func @signextattr(%arg0: i1 {llvm.signext}) {1180  llvm.return1181}1182 1183// CHECK-LABEL: declare void @signextattr_decl(i1 signext)1184llvm.func @signextattr_decl(i1 {llvm.signext})1185 1186// CHECK-LABEL: define void @zeroextattr(i1 zeroext %1187llvm.func @zeroextattr(%arg0: i1 {llvm.zeroext}) {1188  llvm.return1189}1190 1191// CHECK-LABEL: declare void @zeroextattr_decl(i1 zeroext)1192llvm.func @zeroextattr_decl(i1 {llvm.zeroext})1193 1194// CHECK-LABEL: declare void @alignattr_decl(ptr align 64)1195llvm.func @alignattr_decl(!llvm.ptr {llvm.align = 64 : i64})1196 1197// CHECK-LABEL: declare void @dereferenceableattr_decl(ptr dereferenceable(32))1198llvm.func @dereferenceableattr_decl(!llvm.ptr {llvm.dereferenceable = 32 : i64})1199 1200// CHECK-LABEL: declare void @dereferenceableornullattr_decl(ptr dereferenceable_or_null(32))1201llvm.func @dereferenceableornullattr_decl(!llvm.ptr {llvm.dereferenceable_or_null = 32 : i64})1202 1203// CHECK-LABEL: declare void @inregattr_decl(ptr inreg)1204llvm.func @inregattr_decl(!llvm.ptr {llvm.inreg})1205 1206// CHECK-LABEL: declare void @nocaptureattr_decl(ptr captures(none))1207llvm.func @nocaptureattr_decl(!llvm.ptr {llvm.nocapture})1208 1209// CHECK-LABEL: declare void @nofreeattr_decl(ptr nofree)1210llvm.func @nofreeattr_decl(!llvm.ptr {llvm.nofree})1211 1212// CHECK-LABEL: declare void @nonnullattr_decl(ptr nonnull)1213llvm.func @nonnullattr_decl(!llvm.ptr {llvm.nonnull})1214 1215// CHECK-LABEL: declare void @preallocatedattr_decl(ptr preallocated(float))1216llvm.func @preallocatedattr_decl(!llvm.ptr {llvm.preallocated = f32})1217 1218// CHECK-LABEL: declare ptr @returnedattr_decl(ptr returned)1219llvm.func @returnedattr_decl(!llvm.ptr {llvm.returned}) -> !llvm.ptr1220 1221// CHECK-LABEL: declare void @alignstackattr_decl(ptr alignstack(32))1222llvm.func @alignstackattr_decl(!llvm.ptr {llvm.alignstack = 32 : i64})1223 1224// CHECK-LABEL: declare void @writeonlyattr_decl(ptr writeonly)1225llvm.func @writeonlyattr_decl(!llvm.ptr {llvm.writeonly})1226 1227// CHECK-LABEL: declare align 4 ptr @alignattr_ret_decl()1228llvm.func @alignattr_ret_decl() -> (!llvm.ptr {llvm.align = 4})1229 1230// CHECK-LABEL: declare noalias ptr @noaliasattr_ret_decl()1231llvm.func @noaliasattr_ret_decl() -> (!llvm.ptr {llvm.noalias})1232 1233// CHECK-LABEL: declare noundef ptr @noundefattr_ret_decl()1234llvm.func @noundefattr_ret_decl() -> (!llvm.ptr {llvm.noundef})1235 1236// CHECK-LABEL: declare signext i1 @signextattr_ret_decl()1237llvm.func @signextattr_ret_decl() -> (i1 {llvm.signext})1238 1239// CHECK-LABEL: declare zeroext i1 @zeroextattr_ret_decl()1240llvm.func @zeroextattr_ret_decl() -> (i1 {llvm.zeroext})1241 1242// CHECK-LABEL: declare nonnull ptr @nonnullattr_ret_decl()1243llvm.func @nonnullattr_ret_decl() -> (!llvm.ptr {llvm.nonnull})1244 1245// CHECK-LABEL: declare dereferenceable(32) ptr @dereferenceableattr_ret_decl()1246llvm.func @dereferenceableattr_ret_decl() -> (!llvm.ptr {llvm.dereferenceable = 32 : i64})1247 1248// CHECK-LABEL: declare dereferenceable_or_null(16) ptr @dereferenceableornullattr_ret_decl()1249llvm.func @dereferenceableornullattr_ret_decl() -> (!llvm.ptr {llvm.dereferenceable_or_null = 16 : i64})1250 1251// CHECK-LABEL: declare inreg ptr @inregattr_ret_decl()1252llvm.func @inregattr_ret_decl() -> (!llvm.ptr {llvm.inreg})1253 1254// CHECK-LABEL: @varargs(...)1255llvm.func @varargs(...) -> f321256 1257// CHECK-LABEL: define void @varargs_call1258llvm.func @varargs_call(%arg0 : i32) {1259// CHECK:  call float (...) @varargs(i32 %{{.*}})1260// CHECK:  call nnan float (...) @varargs(i32 %{{.*}})1261  llvm.call @varargs(%arg0) vararg(!llvm.func<f32 (...)>) : (i32) -> (f32)1262  llvm.call @varargs(%arg0) vararg(!llvm.func<f32 (...)>) {fastmathFlags = #llvm.fastmath<nnan>} : (i32) -> (f32)1263  llvm.return1264}1265 1266// CHECK-LABEL: define void @indirect_varargs_call(ptr %0, i32 %1)1267llvm.func @indirect_varargs_call(%arg0 : !llvm.ptr, %arg1 : i32) {1268// CHECK:  call float (...) %0(i32 %1)1269// CHECK:  call nnan float (...) %0(i32 %1)1270  llvm.call %arg0(%arg1) vararg(!llvm.func<f32 (...)>) : !llvm.ptr, (i32) -> (f32)1271  llvm.call %arg0(%arg1) vararg(!llvm.func<f32 (...)>) {fastmathFlags = #llvm.fastmath<nnan>} : !llvm.ptr, (i32) -> (f32)1272  llvm.return1273}1274 1275llvm.func @intpointerconversion(%arg0 : i32) -> i32 {1276// CHECK:      %2 = inttoptr i32 %0 to ptr1277// CHECK-NEXT: %3 = ptrtoint ptr %2 to i321278  %1 = llvm.inttoptr %arg0 : i32 to !llvm.ptr1279  %2 = llvm.ptrtoint %1 : !llvm.ptr to i321280  llvm.return %2 : i321281}1282 1283llvm.func @fpconversion(%arg0 : i32) -> i32 {1284// CHECK:      %2 = sitofp i32 %0 to float1285// CHECK-NEXT: %3 = fptosi float %2 to i321286// CHECK-NEXT: %4 = uitofp i32 %3 to float1287// CHECK-NEXT: %5 = fptoui float %4 to i321288  %1 = llvm.sitofp %arg0 : i32 to f321289  %2 = llvm.fptosi %1 : f32 to i321290  %3 = llvm.uitofp %2 : i32 to f321291  %4 = llvm.fptoui %3 : f32 to i321292  llvm.return %4 : i321293}1294 1295// CHECK-LABEL: @addrspace1296llvm.func @addrspace(%arg0 : !llvm.ptr) -> !llvm.ptr<2> {1297// CHECK: %2 = addrspacecast ptr %0 to ptr addrspace(2)1298  %1 = llvm.addrspacecast %arg0 : !llvm.ptr to !llvm.ptr<2>1299  llvm.return %1 : !llvm.ptr<2>1300}1301 1302llvm.func @stringconstant() -> !llvm.array<12 x i8> {1303  %1 = llvm.mlir.constant("Hello world!") : !llvm.array<12 x i8>1304  // CHECK: ret [12 x i8] c"Hello world!"1305  llvm.return %1 : !llvm.array<12 x i8>1306}1307 1308llvm.func @complexfpconstant() -> !llvm.struct<(f32, f32)> {1309  %1 = llvm.mlir.constant([-1.000000e+00 : f32, 0.000000e+00 : f32]) : !llvm.struct<(f32, f32)>1310  // CHECK: ret { float, float } { float -1.000000e+00, float 0.000000e+00 }1311  llvm.return %1 : !llvm.struct<(f32, f32)>1312}1313 1314llvm.func @complexintconstant() -> !llvm.struct<(i32, i32)> {1315  %1 = llvm.mlir.constant([-1 : i32, 0 : i32]) : !llvm.struct<(i32, i32)>1316  // CHECK: ret { i32, i32 } { i32 -1, i32 0 }1317  llvm.return %1 : !llvm.struct<(i32, i32)>1318}1319 1320llvm.func @complexintconstantsplat() -> !llvm.array<2 x !llvm.struct<(i32, i32)>> {1321  %1 = llvm.mlir.constant(dense<(0, 1)> : tensor<2xcomplex<i32>>) : !llvm.array<2 x !llvm.struct<(i32, i32)>>1322  // CHECK: ret [2 x { i32, i32 }] [{ i32, i32 } { i32 0, i32 1 }, { i32, i32 } { i32 0, i32 1 }]1323  llvm.return %1 : !llvm.array<2 x !llvm.struct<(i32, i32)>>1324}1325 1326llvm.func @complexintconstantsingle() -> !llvm.array<1 x !llvm.struct<(i32, i32)>> {1327  %1 = llvm.mlir.constant(dense<(0, 1)> : tensor<complex<i32>>) : !llvm.array<1 x !llvm.struct<(i32, i32)>>1328  // CHECK: ret [1 x { i32, i32 }] [{ i32, i32 } { i32 0, i32 1 }]1329  llvm.return %1 : !llvm.array<1 x !llvm.struct<(i32, i32)>>1330}1331 1332llvm.func @complexintconstantarray() -> !llvm.array<2 x !llvm.array<2 x !llvm.struct<(i32, i32)>>> {1333  %1 = llvm.mlir.constant(dense<[[(0, 1), (2, 3)], [(4, 5), (6, 7)]]> : tensor<2x2xcomplex<i32>>) : !llvm.array<2 x!llvm.array<2 x !llvm.struct<(i32, i32)>>>1334  // CHECK{LITERAL}: ret [2 x [2 x { i32, i32 }]] [[2 x { i32, i32 }] [{ i32, i32 } { i32 0, i32 1 }, { i32, i32 } { i32 2, i32 3 }], [2 x { i32, i32 }] [{ i32, i32 } { i32 4, i32 5 }, { i32, i32 } { i32 6, i32 7 }]]1335  llvm.return %1 : !llvm.array<2 x !llvm.array<2 x !llvm.struct<(i32, i32)>>>1336}1337 1338llvm.func @structconstant() -> !llvm.struct<(i32, f32)> {1339  %1 = llvm.mlir.constant([1 : i32, 2.000000e+00 : f32]) : !llvm.struct<(i32, f32)>1340  // CHECK: ret { i32, float } { i32 1, float 2.000000e+00 }1341  llvm.return %1 : !llvm.struct<(i32, f32)>1342}1343 1344// CHECK-LABEL: @indexconstantsplat1345llvm.func @indexconstantsplat() -> vector<3xi32> {1346  %1 = llvm.mlir.constant(dense<42> : vector<3xindex>) : vector<3xi32>1347  // CHECK: ret <3 x i32> splat (i32 42)1348  llvm.return %1 : vector<3xi32>1349}1350 1351// CHECK-LABEL: @indexconstantarray1352llvm.func @indexconstantarray() -> vector<3xi32> {1353  %1 = llvm.mlir.constant(dense<[0, 1, 2]> : vector<3xindex>) : vector<3xi32>1354  // CHECK: ret <3 x i32> <i32 0, i32 1, i32 2>1355  llvm.return %1 : vector<3xi32>1356}1357 1358llvm.func @noreach() {1359// CHECK:    unreachable1360  llvm.unreachable1361}1362 1363// CHECK-LABEL: define void @fcmp1364llvm.func @fcmp(%arg0: f32, %arg1: f32) {1365  // CHECK: fcmp oeq float %0, %11366  // CHECK-NEXT: fcmp ogt float %0, %11367  // CHECK-NEXT: fcmp oge float %0, %11368  // CHECK-NEXT: fcmp olt float %0, %11369  // CHECK-NEXT: fcmp ole float %0, %11370  // CHECK-NEXT: fcmp one float %0, %11371  // CHECK-NEXT: fcmp ord float %0, %11372  // CHECK-NEXT: fcmp ueq float %0, %11373  // CHECK-NEXT: fcmp ugt float %0, %11374  // CHECK-NEXT: fcmp uge float %0, %11375  // CHECK-NEXT: fcmp ult float %0, %11376  // CHECK-NEXT: fcmp ule float %0, %11377  // CHECK-NEXT: fcmp une float %0, %11378  // CHECK-NEXT: fcmp uno float %0, %11379  %0 = llvm.fcmp "oeq" %arg0, %arg1 : f321380  %1 = llvm.fcmp "ogt" %arg0, %arg1 : f321381  %2 = llvm.fcmp "oge" %arg0, %arg1 : f321382  %3 = llvm.fcmp "olt" %arg0, %arg1 : f321383  %4 = llvm.fcmp "ole" %arg0, %arg1 : f321384  %5 = llvm.fcmp "one" %arg0, %arg1 : f321385  %6 = llvm.fcmp "ord" %arg0, %arg1 : f321386  %7 = llvm.fcmp "ueq" %arg0, %arg1 : f321387  %8 = llvm.fcmp "ugt" %arg0, %arg1 : f321388  %9 = llvm.fcmp "uge" %arg0, %arg1 : f321389  %10 = llvm.fcmp "ult" %arg0, %arg1 : f321390  %11 = llvm.fcmp "ule" %arg0, %arg1 : f321391  %12 = llvm.fcmp "une" %arg0, %arg1 : f321392  %13 = llvm.fcmp "uno" %arg0, %arg1 : f321393  llvm.return1394}1395 1396// CHECK-LABEL: @vect1397llvm.func @vect(%arg0: vector<4xf32>, %arg1: i32, %arg2: f32) {1398  // CHECK-NEXT: extractelement <4 x float> {{.*}}, i321399  // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i321400  // CHECK-NEXT: shufflevector <4 x float> {{.*}}, <4 x float> {{.*}}, <5 x i32> <i32 0, i32 0, i32 0, i32 0, i32 7>1401  %0 = llvm.extractelement %arg0[%arg1 : i32] : vector<4xf32>1402  %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<4xf32>1403  %2 = llvm.shufflevector %arg0, %arg0 [0, 0, 0, 0, 7] : vector<4xf32>1404  llvm.return1405}1406 1407// CHECK-LABEL: @vect_i64idx1408llvm.func @vect_i64idx(%arg0: vector<4xf32>, %arg1: i64, %arg2: f32) {1409  // CHECK-NEXT: extractelement <4 x float> {{.*}}, i641410  // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i641411  %0 = llvm.extractelement %arg0[%arg1 : i64] : vector<4xf32>1412  %1 = llvm.insertelement %arg2, %arg0[%arg1 : i64] : vector<4xf32>1413  llvm.return1414}1415 1416// CHECK-LABEL: @scalable_vect1417llvm.func @scalable_vect(%arg0: vector<[4]xf32>, %arg1: i32, %arg2: f32) {1418  // CHECK-NEXT: extractelement <vscale x 4 x float> {{.*}}, i321419  // CHECK-NEXT: insertelement <vscale x 4 x float> {{.*}}, float %2, i321420  // CHECK-NEXT: shufflevector <vscale x 4 x float> %0, <vscale x 4 x float> %0, <vscale x 4 x i32> zeroinitializer1421  %0 = llvm.extractelement %arg0[%arg1 : i32] : vector<[4]xf32>1422  %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<[4]xf32>1423  %2 = llvm.shufflevector %arg0, %arg0 [0, 0, 0, 0] : vector<[4]xf32>1424  llvm.return1425}1426 1427// CHECK-LABEL: @scalable_vect_i64idx1428llvm.func @scalable_vect_i64idx(%arg0: vector<[4]xf32>, %arg1: i64, %arg2: f32) {1429  // CHECK-NEXT: extractelement <vscale x 4 x float> {{.*}}, i641430  // CHECK-NEXT: insertelement <vscale x 4 x float> {{.*}}, float %2, i641431  %0 = llvm.extractelement %arg0[%arg1 : i64] : vector<[4]xf32>1432  %1 = llvm.insertelement %arg2, %arg0[%arg1 : i64] : vector<[4]xf32>1433  llvm.return1434}1435 1436// CHECK-LABEL: @alloca1437llvm.func @alloca(%size : i64) {1438  // Alignment automatically set by the LLVM IR builder when alignment attribute1439  // is 0.1440  //  CHECK: alloca {{.*}} align 41441  llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr)1442  // CHECK-NEXT: alloca {{.*}} align 81443  llvm.alloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr)1444  // CHECK-NEXT: alloca {{.*}} addrspace(3)1445  llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<3>)1446  // CHECK-NEXT: alloca inalloca {{.*}} align 41447  llvm.alloca inalloca %size x i32 : (i64) -> !llvm.ptr1448  llvm.return1449}1450 1451// CHECK-LABEL: @constants1452llvm.func @constants() -> vector<4xf32> {1453  // 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>1454  %0 = llvm.mlir.constant(sparse<[0], [4.2e+01]> : vector<4xf32>) : vector<4xf32>1455  llvm.return %0 : vector<4xf32>1456}1457 1458// CHECK-LABEL: @fp_casts1459llvm.func @fp_casts(%fp1 : f32, %fp2 : f64) -> i16 {1460// CHECK:    fptrunc double {{.*}} to float1461  %a = llvm.fptrunc %fp2 : f64 to f321462// CHECK:    fpext float {{.*}} to double1463  %b = llvm.fpext %fp1 : f32 to f641464// CHECK:    fptosi double {{.*}} to i161465  %c = llvm.fptosi %b : f64 to i161466  llvm.return %c : i161467}1468 1469// CHECK-LABEL: @integer_extension_and_truncation1470llvm.func @integer_extension_and_truncation(%a : i32) {1471// CHECK:    sext i32 {{.*}} to i641472// CHECK:    zext i32 {{.*}} to i641473// CHECK:    trunc i32 {{.*}} to i161474  %0 = llvm.sext %a : i32 to i641475  %1 = llvm.zext %a : i32 to i641476  %2 = llvm.trunc %a : i32 to i161477  llvm.return1478}1479 1480// Check that the auxiliary `null` operation is converted into a `null` value.1481// CHECK-LABEL: @null1482llvm.func @null() -> !llvm.ptr {1483  %0 = llvm.mlir.zero : !llvm.ptr1484  // CHECK: ret ptr null1485  llvm.return %0 : !llvm.ptr1486}1487 1488// Check that dense elements attributes are exported properly in constants.1489// CHECK-LABEL: @elements_constant_3d_vector1490llvm.func @elements_constant_3d_vector() -> !llvm.array<2 x array<2 x vector<2 x i32>>> {1491  // CHECK: ret [2 x [2 x <2 x i32>]]1492  // CHECK-SAME: {{\[}}[2 x <2 x i32>] [<2 x i32> <i32 1, i32 2>, <2 x i32> <i32 3, i32 4>],1493  // CHECK-SAME:       [2 x <2 x i32>] [<2 x i32> <i32 42, i32 43>, <2 x i32> <i32 44, i32 45>]]1494  %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>>>1495  llvm.return %0 : !llvm.array<2 x array<2 x vector<2 x i32>>>1496}1497 1498// CHECK-LABEL: @elements_constant_3d_array1499llvm.func @elements_constant_3d_array() -> !llvm.array<2 x array<2 x array<2 x i32>>> {1500  // CHECK: ret [2 x [2 x [2 x i32]]]1501  // CHECK-SAME: {{\[}}[2 x [2 x i32]] {{\[}}[2 x i32] [i32 1, i32 2], [2 x i32] [i32 3, i32 4]],1502  // CHECK-SAME:       [2 x [2 x i32]] {{\[}}[2 x i32] [i32 42, i32 43], [2 x i32] [i32 44, i32 45]]]1503  %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>>>1504  llvm.return %0 : !llvm.array<2 x array<2 x array<2 x i32>>>1505}1506 1507// CHECK-LABEL: @atomicrmw1508llvm.func @atomicrmw(1509    %f32_ptr : !llvm.ptr, %f32 : f32,1510    %i32_ptr : !llvm.ptr, %i32 : i32,1511    %f16_vec_ptr : !llvm.ptr, %f16_vec : vector<2xf16>) {1512  // CHECK: atomicrmw fadd ptr %{{.*}}, float %{{.*}} monotonic1513  %0 = llvm.atomicrmw fadd %f32_ptr, %f32 monotonic : !llvm.ptr, f321514  // CHECK: atomicrmw fsub ptr %{{.*}}, float %{{.*}} monotonic1515  %1 = llvm.atomicrmw fsub %f32_ptr, %f32 monotonic : !llvm.ptr, f321516  // CHECK: atomicrmw fmax ptr %{{.*}}, float %{{.*}} monotonic1517  %2 = llvm.atomicrmw fmax %f32_ptr, %f32 monotonic : !llvm.ptr, f321518  // CHECK: atomicrmw fmin ptr %{{.*}}, float %{{.*}} monotonic1519  %3 = llvm.atomicrmw fmin %f32_ptr, %f32 monotonic : !llvm.ptr, f321520  // CHECK: atomicrmw xchg ptr %{{.*}}, float %{{.*}} monotonic1521  %4 = llvm.atomicrmw xchg %f32_ptr, %f32 monotonic : !llvm.ptr, f321522  // CHECK: atomicrmw add ptr %{{.*}}, i32 %{{.*}} acquire1523  %5 = llvm.atomicrmw add %i32_ptr, %i32 acquire : !llvm.ptr, i321524  // CHECK: atomicrmw sub ptr %{{.*}}, i32 %{{.*}} release1525  %6 = llvm.atomicrmw sub %i32_ptr, %i32 release : !llvm.ptr, i321526  // CHECK: atomicrmw and ptr %{{.*}}, i32 %{{.*}} acq_rel1527  %7 = llvm.atomicrmw _and %i32_ptr, %i32 acq_rel : !llvm.ptr, i321528  // CHECK: atomicrmw nand ptr %{{.*}}, i32 %{{.*}} seq_cst1529  %8 = llvm.atomicrmw nand %i32_ptr, %i32 seq_cst : !llvm.ptr, i321530  // CHECK: atomicrmw or ptr %{{.*}}, i32 %{{.*}} monotonic1531  %9 = llvm.atomicrmw _or %i32_ptr, %i32 monotonic : !llvm.ptr, i321532  // CHECK: atomicrmw xor ptr %{{.*}}, i32 %{{.*}} monotonic1533  %10 = llvm.atomicrmw _xor %i32_ptr, %i32 monotonic : !llvm.ptr, i321534  // CHECK: atomicrmw max ptr %{{.*}}, i32 %{{.*}} monotonic1535  %11 = llvm.atomicrmw max %i32_ptr, %i32 monotonic : !llvm.ptr, i321536  // CHECK: atomicrmw min ptr %{{.*}}, i32 %{{.*}} monotonic1537  %12 = llvm.atomicrmw min %i32_ptr, %i32 monotonic : !llvm.ptr, i321538  // CHECK: atomicrmw umax ptr %{{.*}}, i32 %{{.*}} monotonic1539  %13 = llvm.atomicrmw umax %i32_ptr, %i32 monotonic : !llvm.ptr, i321540  // CHECK: atomicrmw umin ptr %{{.*}}, i32 %{{.*}} monotonic1541  %14 = llvm.atomicrmw umin %i32_ptr, %i32 monotonic : !llvm.ptr, i321542  // CHECK: atomicrmw uinc_wrap ptr %{{.*}}, i32 %{{.*}} monotonic1543  %15 = llvm.atomicrmw uinc_wrap %i32_ptr, %i32 monotonic : !llvm.ptr, i321544  // CHECK: atomicrmw udec_wrap ptr %{{.*}}, i32 %{{.*}} monotonic1545  %16 = llvm.atomicrmw udec_wrap %i32_ptr, %i32 monotonic : !llvm.ptr, i321546  // CHECK: atomicrmw usub_cond ptr %{{.*}}, i32 %{{.*}} monotonic1547  %17 = llvm.atomicrmw usub_cond %i32_ptr, %i32 monotonic : !llvm.ptr, i321548  // CHECK: atomicrmw usub_sat ptr %{{.*}}, i32 %{{.*}} monotonic1549  %18 = llvm.atomicrmw usub_sat %i32_ptr, %i32 monotonic : !llvm.ptr, i321550  // CHECK: atomicrmw fadd ptr %{{.*}}, <2 x half> %{{.*}} monotonic1551  %19 = llvm.atomicrmw fadd %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1552  // CHECK: atomicrmw fsub ptr %{{.*}}, <2 x half> %{{.*}} monotonic1553  %20 = llvm.atomicrmw fsub %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1554  // CHECK: atomicrmw fmax ptr %{{.*}}, <2 x half> %{{.*}} monotonic1555  %21 = llvm.atomicrmw fmax %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1556  // CHECK: atomicrmw fmin ptr %{{.*}}, <2 x half> %{{.*}} monotonic1557  %22 = llvm.atomicrmw fmin %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1558  // CHECK: atomicrmw fmaximum ptr %{{.*}}, float %{{.*}} monotonic1559  %23 = llvm.atomicrmw fmaximum %f32_ptr, %f32 monotonic : !llvm.ptr, f321560  // CHECK: atomicrmw fminimum ptr %{{.*}}, float %{{.*}} monotonic1561  %24 = llvm.atomicrmw fminimum %f32_ptr, %f32 monotonic : !llvm.ptr, f321562  // CHECK: atomicrmw fmaximum ptr %{{.*}}, <2 x half> %{{.*}} monotonic1563  %25 = llvm.atomicrmw fmaximum %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1564  // CHECK: atomicrmw fminimum ptr %{{.*}}, <2 x half> %{{.*}} monotonic1565  %26 = llvm.atomicrmw fminimum %f16_vec_ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>1566 1567  // CHECK: atomicrmw volatile1568  // CHECK-SAME:  syncscope("singlethread")1569  // CHECK-SAME:  align 81570  %27 = llvm.atomicrmw volatile udec_wrap %i32_ptr, %i32 syncscope("singlethread") monotonic {alignment = 8 : i64} : !llvm.ptr, i321571  llvm.return1572}1573 1574// CHECK-LABEL: @cmpxchg1575llvm.func @cmpxchg(%ptr : !llvm.ptr, %cmp : i32, %val: i32) {1576  // CHECK: cmpxchg ptr %{{.*}}, i32 %{{.*}}, i32 %{{.*}} acq_rel monotonic1577  %0 = llvm.cmpxchg %ptr, %cmp, %val acq_rel monotonic : !llvm.ptr, i321578  // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 01579  %1 = llvm.extractvalue %0[0] : !llvm.struct<(i32, i1)>1580  // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 11581  %2 = llvm.extractvalue %0[1] : !llvm.struct<(i32, i1)>1582 1583  // CHECK:  cmpxchg weak volatile1584  // CHECK-SAME:  syncscope("singlethread")1585  // CHECK-SAME:  align 81586  %3 = llvm.cmpxchg weak volatile %ptr, %cmp, %val syncscope("singlethread") acq_rel monotonic {alignment = 8 : i64} : !llvm.ptr, i321587  llvm.return1588}1589 1590llvm.mlir.global external constant @_ZTIi() : !llvm.ptr1591llvm.func @foo(!llvm.ptr)1592llvm.func @vararg_foo(!llvm.ptr, ...)1593llvm.func @bar(!llvm.ptr) -> !llvm.ptr1594llvm.func @__gxx_personality_v0(...) -> i321595 1596// CHECK-LABEL: @invokeLandingpad1597llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {1598// CHECK: %[[a1:[0-9]+]] = alloca i81599  %0 = llvm.mlir.constant(0 : i32) : i321600  %1 = llvm.mlir.constant(dense<0> : vector<1xi8>) : !llvm.array<1 x i8>1601  %2 = llvm.mlir.addressof @_ZTIi : !llvm.ptr1602  %4 = llvm.mlir.zero : !llvm.ptr1603  %5 = llvm.mlir.constant(1 : i32) : i321604  %6 = llvm.alloca %5 x i8 : (i32) -> !llvm.ptr1605// CHECK: invoke void @foo(ptr %[[a1]])1606// CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]1607  llvm.invoke @foo(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> ()1608 1609// CHECK: [[unwind]]:1610^bb1:1611// CHECK: %{{[0-9]+}} = landingpad { ptr, i32 }1612// CHECK-NEXT:             catch ptr null1613// CHECK-NEXT:             catch ptr @_ZTIi1614// CHECK-NEXT:             filter [1 x i8] zeroinitializer1615  %7 = llvm.landingpad (catch %4 : !llvm.ptr) (catch %2 : !llvm.ptr) (filter %1 : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>1616// CHECK: br label %[[final:[0-9]+]]1617  llvm.br ^bb31618 1619// CHECK: [[normal]]:1620// CHECK-NEXT: ret i32 11621^bb2:	// 2 preds: ^bb0, ^bb31622  llvm.return %5 : i321623 1624// CHECK: [[final]]:1625// CHECK-NEXT: %{{[0-9]+}} = invoke ptr @bar(ptr %[[a1]])1626// CHECK-NEXT:          to label %[[normal]] unwind label %[[unwind]]1627^bb3:	// pred: ^bb11628  %8 = llvm.invoke @bar(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> !llvm.ptr1629 1630// CHECK: [[BB4:.*]]:1631// CHECK: invoke void (ptr, ...) @vararg_foo(ptr %[[a1]], i32 0)1632^bb4:1633  llvm.invoke @vararg_foo(%6, %0) to ^bb2 unwind ^bb1 vararg(!llvm.func<void (ptr, ...)>) : (!llvm.ptr, i32) -> ()1634 1635// CHECK: [[BB5:.*]]:1636// CHECK: invoke void (ptr, ...) undef(ptr %[[a1]], i32 0)1637^bb5:1638  %9 = llvm.mlir.undef : !llvm.ptr1639  llvm.invoke %9(%6, %0) to ^bb2 unwind ^bb1 vararg(!llvm.func<void (ptr, ...)>) : !llvm.ptr, (!llvm.ptr, i32) -> ()1640}1641 1642// -----1643 1644llvm.func @foo() -> i81645llvm.func @__gxx_personality_v0(...) -> i321646 1647// CHECK-LABEL: @invoke_result1648// CHECK-SAME: %[[a0:[0-9]+]]1649llvm.func @invoke_result(%arg0 : !llvm.ptr) attributes { personality = @__gxx_personality_v0 } {1650// CHECK: %[[a1:[0-9]+]] = invoke i8 @foo()1651// CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]1652    %0 = llvm.invoke @foo() to ^bb1 unwind ^bb2 : () -> i81653 1654// CHECK: [[normal]]:1655// CHECK-NEXT: store i8 %[[a1]], ptr %[[a0]]1656// CHECK-NEXT: ret void1657^bb1:1658    llvm.store %0, %arg0 : i8, !llvm.ptr1659    llvm.return1660 1661// CHECK: [[unwind]]:1662// CHECK-NEXT: landingpad { ptr, i32 }1663// CHECK-NEXT: cleanup1664// CHECK-NEXT: ret void1665^bb2:1666    %7 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>1667    llvm.return1668}1669 1670// -----1671 1672llvm.func @foo()1673llvm.func @__gxx_personality_v0(...) -> i321674 1675// CHECK-LABEL: @invoke_phis1676llvm.func @invoke_phis() -> i32 attributes { personality = @__gxx_personality_v0 } {1677// CHECK: invoke void @foo()1678// CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]1679    %0 = llvm.mlir.constant(0 : i32) : i321680    llvm.invoke @foo() to ^bb1(%0 : i32) unwind ^bb2 : () -> ()1681 1682// CHECK: [[normal]]:1683// CHECK-NEXT: %[[a1:[0-9]+]] = phi i32 [ 1, %[[unwind]] ], [ 0, %0 ]1684// CHECK-NEXT: ret i32 %[[a1]]1685^bb1(%1 : i32):1686    llvm.return %1 : i321687 1688// CHECK: [[unwind]]:1689// CHECK-NEXT: landingpad { ptr, i32 }1690// CHECK-NEXT: cleanup1691// CHECK-NEXT: br label %[[normal]]1692^bb2:1693    %2 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>1694    %3 = llvm.mlir.constant(1 : i32) : i321695    llvm.br ^bb1(%3 : i32)1696}1697 1698// -----1699 1700// CHECK-LABEL: @hasGCFunction1701// CHECK-SAME: gc "statepoint-example"1702llvm.func @hasGCFunction() attributes { garbageCollector = "statepoint-example" } {1703    llvm.return1704}1705 1706// -----1707 1708// CHECK-LABEL: @gc_decl1709// CHECK-SAME: gc "statepoint-example"1710llvm.func @gc_decl() attributes { garbageCollector = "statepoint-example" }1711 1712// -----1713 1714// CHECK-LABEL: @section_func1715// CHECK-SAME: section ".section.name"1716llvm.func @section_func() attributes { section = ".section.name" } {1717    llvm.return1718}1719 1720// -----1721 1722// CHECK-LABEL: @local_unnamed_addr_func1723// CHECK-SAME: local_unnamed_addr1724llvm.func local_unnamed_addr @local_unnamed_addr_func() {1725    llvm.return1726}1727 1728// -----1729 1730// CHECK-LABEL: @unnamed_addr_func1731// CHECK-SAME: unnamed_addr1732llvm.func unnamed_addr @unnamed_addr_func()1733 1734// -----1735 1736// CHECK-LABEL: @align_func1737// CHECK-SAME: align 21738llvm.func @align_func() attributes {alignment = 2 : i64} {1739    llvm.return1740}1741 1742// -----1743 1744// CHECK-LABEL: @align_decl1745// CHECK-SAME: align 641746llvm.func @align_decl() attributes {alignment = 64 : i64}1747 1748// -----1749 1750// CHECK-LABEL: @callFreezeOp1751llvm.func @callFreezeOp(%x : i32) {1752  // CHECK: freeze i32 %{{[0-9]+}}1753  %0 = llvm.freeze %x : i321754  %1 = llvm.mlir.undef : i321755  // CHECK: freeze i32 undef1756  %2 = llvm.freeze %1 : i321757  %3 = llvm.mlir.poison : i321758  // CHECK: freeze i32 poison1759  %4 = llvm.freeze %3 : i321760  llvm.return1761}1762 1763// CHECK-LABEL: @freezeUsed1764llvm.func @freezeUsed(%x : i32) -> i64 {1765  // CHECK: %[[frozen:.*]] = freeze i321766  %frozen = llvm.freeze %x : i321767  // CHECK: %[[ext:.*]] = sext i32 %[[frozen]] to i641768  %ext = llvm.sext %frozen : i32 to i641769  // CHECK: ret i64 %[[ext]]1770  llvm.return %ext : i641771}1772 1773// CHECK-LABEL: @boolConstArg1774llvm.func @boolConstArg() -> i1 {1775  // CHECK: ret i1 false1776  %0 = llvm.mlir.constant(true) : i11777  %1 = llvm.mlir.constant(false) : i11778  %2 = llvm.and %0, %1 : i11779  llvm.return %2 : i11780}1781 1782// CHECK-LABEL: @callFenceInst1783llvm.func @callFenceInst() {1784  // CHECK: fence syncscope("agent") release1785  llvm.fence syncscope("agent") release1786  // CHECK: fence release1787  llvm.fence release1788  // CHECK: fence release1789  llvm.fence syncscope("") release1790  llvm.return1791}1792 1793// CHECK-LABEL: @passthrough1794// CHECK: #[[ATTR_GROUP:[0-9]*]]1795llvm.func @passthrough() attributes {passthrough = [["alignstack", "4"], "null_pointer_is_valid", ["foo", "bar"]]} {1796  llvm.return1797}1798 1799// CHECK: attributes #[[ATTR_GROUP]] = {1800// CHECK-DAG: alignstack=41801// CHECK-DAG: null_pointer_is_valid1802// CHECK-DAG: "foo"="bar"1803 1804// -----1805 1806// CHECK-LABEL: @my_allocator1807// CHECK: #[[ALLOC_ATTRS:[0-9]*]]1808llvm.func @my_allocator(i64) attributes {passthrough = [["allocsize", "4294967295"]]}1809 1810// CHECK: attributes #[[ALLOC_ATTRS]] = {1811// CHECK-DAG: allocsize(0)1812 1813// -----1814 1815// CHECK-LABEL: @functionEntryCount1816// CHECK-SAME: !prof ![[PROF_ID:[0-9]*]]1817llvm.func @functionEntryCount() attributes {function_entry_count = 4242 : i64} {1818  llvm.return1819}1820 1821// CHECK: ![[PROF_ID]] = !{!"function_entry_count", i64 4242}1822 1823// -----1824 1825// CHECK-LABEL: @constant_bf161826llvm.func @constant_bf16() -> bf16 {1827  %0 = llvm.mlir.constant(1.000000e+01 : bf16) : bf161828  llvm.return %0 : bf161829}1830 1831// CHECK: ret bfloat 0xR41201832 1833// -----1834 1835llvm.func @address_taken() {1836  llvm.return1837}1838 1839llvm.mlir.global internal constant @taker_of_address() : !llvm.ptr {1840  %0 = llvm.mlir.addressof @address_taken : !llvm.ptr1841  llvm.return %0 : !llvm.ptr1842}1843 1844// -----1845 1846// CHECK: @forward_use_of_address = linkonce global ptr @address_declared_after_use1847llvm.mlir.global linkonce @forward_use_of_address() : !llvm.ptr {1848  %0 = llvm.mlir.addressof @address_declared_after_use : !llvm.ptr1849  llvm.return %0 : !llvm.ptr1850}1851 1852llvm.mlir.global linkonce @address_declared_after_use() : f321853 1854// -----1855 1856// CHECK: @take_self_address = linkonce global { i32, ptr } {{.*}} ptr @take_self_address1857llvm.mlir.global linkonce @take_self_address() : !llvm.struct<(i32, !llvm.ptr)> {1858  %z32 = llvm.mlir.constant(0 : i32) : i321859  %0 = llvm.mlir.undef : !llvm.struct<(i32, !llvm.ptr)>1860  %1 = llvm.mlir.addressof @take_self_address : !llvm.ptr1861  %2 = llvm.getelementptr %1[%z32, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<(i32, !llvm.ptr)>1862  %3 = llvm.insertvalue %z32, %0[0] : !llvm.struct<(i32, !llvm.ptr)>1863  %4 = llvm.insertvalue %2, %3[1] : !llvm.struct<(i32, !llvm.ptr)>1864  llvm.return %4 : !llvm.struct<(i32, !llvm.ptr)>1865}1866 1867// -----1868 1869// CHECK: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }]1870llvm.mlir.global_ctors ctors = [@foo], priorities = [0 : i32], data = [#llvm.zero]1871 1872llvm.func @foo() {1873  llvm.return1874}1875 1876// -----1877 1878// CHECK: @llvm.global_ctors = appending global [0 x { i32, ptr, ptr }] zeroinitializer1879llvm.mlir.global_ctors ctors = [], priorities = [], data = []1880 1881// CHECK: @llvm.global_dtors = appending global [0 x { i32, ptr, ptr }] zeroinitializer1882llvm.mlir.global_dtors dtors = [], priorities = [], data = []1883 1884// -----1885 1886// CHECK: @llvm.global_dtors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 0, ptr @foo, ptr null }]1887llvm.mlir.global_dtors dtors = [@foo], priorities = [0 : i32], data = [#llvm.zero]1888 1889llvm.func @foo() {1890  llvm.return1891}1892 1893// -----1894 1895// Check that branch weight attributes are exported properly as metadata.1896llvm.func @cond_br_weights(%cond : i1, %arg0 : i32,  %arg1 : i32) -> i32 {1897  // CHECK: !prof ![[NODE:[0-9]+]]1898  llvm.cond_br %cond weights([5, 10]), ^bb1, ^bb21899^bb1:  // pred: ^bb01900  llvm.return %arg0 : i321901^bb2:  // pred: ^bb01902  llvm.return %arg1 : i321903}1904 1905// CHECK: ![[NODE]] = !{!"branch_weights", i32 5, i32 10}1906 1907// -----1908 1909llvm.func @foo()1910llvm.func @__gxx_personality_v0(...) -> i321911 1912// CHECK-LABEL: @invoke_branch_weights1913llvm.func @invoke_branch_weights() -> i32 attributes {personality = @__gxx_personality_v0} {1914  %0 = llvm.mlir.constant(1 : i32) : i321915  // CHECK: !prof ![[NODE:[0-9]+]]1916  llvm.invoke @foo() to ^bb2 unwind ^bb1 {branch_weights = array<i32 : 42, 99>} : () -> ()1917^bb1:  // pred: ^bb01918  %1 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>1919  llvm.br ^bb21920^bb2:  // 2 preds: ^bb0, ^bb11921  llvm.return %0 : i321922}1923 1924// CHECK: ![[NODE]] = !{!"branch_weights", i32 42, i32 99}1925 1926// -----1927 1928llvm.func @volatile_store_and_load() {1929  %val = llvm.mlir.constant(5 : i32) : i321930  %size = llvm.mlir.constant(1 : i64) : i641931  %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr)1932  // CHECK: store volatile i32 5, ptr %{{.*}}1933  llvm.store volatile %val, %0 : i32, !llvm.ptr1934  // CHECK: %{{.*}} = load volatile i32, ptr %{{.*}}1935  %1 = llvm.load volatile %0: !llvm.ptr -> i321936  llvm.return1937}1938 1939// -----1940 1941// Check that nontemporal attribute is exported as metadata node.1942llvm.func @nontemporal_store_and_load() {1943  %val = llvm.mlir.constant(5 : i32) : i321944  %size = llvm.mlir.constant(1 : i64) : i641945  %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr)1946  // CHECK: !nontemporal ![[NODE:[0-9]+]]1947  llvm.store %val, %0 {nontemporal} : i32, !llvm.ptr1948  // CHECK: !nontemporal ![[NODE]]1949  %1 = llvm.load %0 {nontemporal} : !llvm.ptr -> i321950  llvm.return1951}1952 1953// CHECK: ![[NODE]] = !{i32 1}1954 1955// -----1956 1957// Check that invariantLoad attribute is exported as metadata node.1958llvm.func @nontemporal_store_and_load(%ptr : !llvm.ptr) -> i32 {1959  // CHECK: !invariant.load ![[NODE:[0-9]+]]1960  %1 = llvm.load %ptr invariant : !llvm.ptr -> i321961  llvm.return %1 : i321962}1963 1964// CHECK: ![[NODE]] = !{}1965 1966// -----1967 1968// Check that invariant group attribute is exported as metadata node.1969llvm.func @nontemporal_store_and_load(%ptr : !llvm.ptr) -> i32 {1970  %val = llvm.mlir.constant(42 : i32) : i321971  // CHECK: store i32 42, ptr %{{.*}} !invariant.group ![[NODE:[0-9]+]]1972  llvm.store %val, %ptr invariant_group : i32, !llvm.ptr1973  // CHECK: %{{.*}} = load i32, ptr %{{.*}} !invariant.group ![[NODE]]1974  %1 = llvm.load %ptr invariant_group : !llvm.ptr -> i321975  llvm.return %1 : i321976}1977 1978// CHECK: ![[NODE]] = !{}1979 1980// -----1981 1982llvm.func @atomic_store_and_load(%ptr : !llvm.ptr) {1983  // CHECK: load atomic1984  // CHECK-SAME:  acquire, align 41985  %1 = llvm.load %ptr atomic acquire {alignment = 4 : i64} : !llvm.ptr -> f321986  // CHECK: load atomic1987  // CHECK-SAME:  syncscope("singlethread") acquire, align 41988  %2 = llvm.load %ptr atomic syncscope("singlethread") acquire {alignment = 4 : i64} : !llvm.ptr -> f321989 1990  // CHECK: store atomic1991  // CHECK-SAME:  release, align 41992  llvm.store %1, %ptr atomic release {alignment = 4 : i64} : f32, !llvm.ptr1993  // CHECK: store atomic1994  // CHECK-SAME:  syncscope("singlethread") release, align 41995  llvm.store %2, %ptr atomic syncscope("singlethread") release {alignment = 4 : i64} : f32, !llvm.ptr1996  llvm.return1997}1998 1999// -----2000 2001// Check that the translation does not crash in absence of a data layout.2002module {2003  // CHECK: declare void @module_default_layout2004  llvm.func @module_default_layout()2005}2006 2007// -----2008 2009// CHECK: target datalayout = "E"2010module attributes {llvm.data_layout = "E"} {2011  llvm.func @module_big_endian()2012}2013 2014// -----2015 2016// CHECK: "CodeView", i32 12017module attributes {llvm.target_triple = "x86_64-pc-windows-msvc"} {}2018 2019// -----2020 2021// CHECK-NOT: "CodeView", i32 12022// CHECK: aarch64-linux-android2023module attributes {llvm.target_triple = "aarch64-linux-android"} {}2024 2025// -----2026 2027// CHECK-NOT: "CodeView", i32 12028module attributes {} {}2029 2030// -----2031 2032// CHECK-LABEL: @useInlineAsm2033llvm.func @useInlineAsm(%arg0: i32, %arg1 : !llvm.ptr) {2034  // Constraints string is checked at LLVM InlineAsm instruction construction time.2035  // So we can't just use "bar" everywhere, number of in/out arguments has to match.2036 2037  // CHECK-NEXT:  call void asm "foo", "r"(i32 {{.*}})2038  llvm.inline_asm "foo", "r" %arg0 : (i32) -> ()2039 2040  // CHECK-NEXT:  call i8 asm "foo", "=r,r"(i32 {{.*}})2041  %0 = llvm.inline_asm "foo", "=r,r" %arg0 : (i32) -> i82042 2043  // CHECK-NEXT:  call i8 asm "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}})2044  %1 = llvm.inline_asm "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i82045 2046  // CHECK-NEXT:  call i8 asm sideeffect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}})2047  %2 = llvm.inline_asm has_side_effects "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i82048 2049  // CHECK-NEXT:  call i8 asm alignstack "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}})2050  %3 = llvm.inline_asm is_align_stack "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i82051 2052  // CHECK-NEXT:  call i8 asm inteldialect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}})2053  %4 = llvm.inline_asm asm_dialect = "intel" "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i82054 2055  // CHECK-NEXT:  call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}})2056  %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>2057 2058  // CHECK-NEXT:  tail call void asm sideeffect "", "*m,~{memory}"(ptr elementtype(ptr) %1)2059  %6 = llvm.inline_asm has_side_effects tail_call_kind = <tail> operand_attrs = [{elementtype = !llvm.ptr}] "", "*m,~{memory}" %arg1 : (!llvm.ptr) -> !llvm.void2060 2061  // CHECK-NEXT:  = call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}})2062  %7 = llvm.inline_asm tail_call_kind = <none> "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>2063 2064  // CHECK-NEXT:  notail call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}})2065  %8 = llvm.inline_asm tail_call_kind = <notail> "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>2066 2067  llvm.return2068}2069 2070// -----2071 2072// CHECK: @useInlineAsm2(ptr %[[A0:.*]], i64 %[[A1:.*]], ptr %[[A2:.*]], i64 %[[A3:.*]]) {2073llvm.func @useInlineAsm2(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64) {2074  // CHECK:  call { i64, ptr, ptr } asm sideeffect2075  // CHECK-SAME: "ldr x4, [$2], #8   \0A\09ldr x5, [$1]       \0A\09mul x6, x4, $4     \0A\09",2076  // CHECK-SAME: "=r,=r,=r,=*m,r,*m,0,1,2,*m,~{x4},~{x5},~{x6},~{x7},~{cc}"2077  // CHECK-SAME:(ptr elementtype([16 x i64]) %[[A0]], i64 %[[A1]], ptr elementtype([16 x i64]) %[[A2]],2078  // CHECK-SAME: i64 %[[A3]], ptr %[[A0]], ptr %[[A2]], ptr elementtype([16 x i64]) %[[A0]])2079  %0 = llvm.inline_asm has_side_effects operand_attrs = [2080    {elementtype = !llvm.array<16 x i64>}, {}, {elementtype = !llvm.array<16 x i64>},2081    {}, {}, {}, {elementtype = !llvm.array<16 x i64>}]2082    "ldr x4, [$2], #8   \0A\09ldr x5, [$1]       \0A\09mul x6, x4, $4     \0A\09",2083    "=r,=r,=r,=*m,r,*m,0,1,2,*m,~{x4},~{x5},~{x6},~{x7},~{cc}"2084    %arg0, %arg1, %arg2, %arg3, %arg0, %arg2, %arg0 :2085      (!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.struct<(i64, ptr, ptr)>2086  llvm.return2087}2088 2089// -----2090 2091llvm.func @fastmathFlagsFunc(f32) -> f322092 2093// CHECK-LABEL: @fastmathFlags2094llvm.func @fastmathFlags(%arg0: f32, %arg1 : vector<2xf32>) {2095// CHECK: {{.*}} = fadd nnan ninf float {{.*}}, {{.*}}2096// CHECK: {{.*}} = fsub nnan ninf float {{.*}}, {{.*}}2097// CHECK: {{.*}} = fmul nnan ninf float {{.*}}, {{.*}}2098// CHECK: {{.*}} = fdiv nnan ninf float {{.*}}, {{.*}}2099// CHECK: {{.*}} = frem nnan ninf float {{.*}}, {{.*}}2100  %0 = llvm.fadd %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322101  %1 = llvm.fsub %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322102  %2 = llvm.fmul %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322103  %3 = llvm.fdiv %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322104  %4 = llvm.frem %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322105 2106// CHECK: {{.*}} = fcmp nnan ninf oeq {{.*}}, {{.*}}2107  %5 = llvm.fcmp "oeq" %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322108 2109// CHECK: {{.*}} = fneg nnan ninf float {{.*}}2110  %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f322111 2112// CHECK: {{.*}} = call float @fastmathFlagsFunc({{.*}})2113// CHECK: {{.*}} = call nnan float @fastmathFlagsFunc({{.*}})2114// CHECK: {{.*}} = call ninf float @fastmathFlagsFunc({{.*}})2115// CHECK: {{.*}} = call nsz float @fastmathFlagsFunc({{.*}})2116// CHECK: {{.*}} = call arcp float @fastmathFlagsFunc({{.*}})2117// CHECK: {{.*}} = call contract float @fastmathFlagsFunc({{.*}})2118// CHECK: {{.*}} = call afn float @fastmathFlagsFunc({{.*}})2119// CHECK: {{.*}} = call reassoc float @fastmathFlagsFunc({{.*}})2120// CHECK: {{.*}} = call fast float @fastmathFlagsFunc({{.*}})2121  %8 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<none>} : (f32) -> (f32)2122  %9 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<nnan>} : (f32) -> (f32)2123  %10 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<ninf>} : (f32) -> (f32)2124  %11 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<nsz>} : (f32) -> (f32)2125  %12 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<arcp>} : (f32) -> (f32)2126  %13 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<contract>} : (f32) -> (f32)2127  %14 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> (f32)2128  %15 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<reassoc>} : (f32) -> (f32)2129  %16 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> (f32)2130 2131// CHECK: call fast float @llvm.copysign.f32(float {{.*}}, float {{.*}})2132  %17 = "llvm.intr.copysign"(%arg0, %arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f322133// CHECK: call afn float @llvm.copysign.f32(float {{.*}}, float {{.*}})2134  %18 = "llvm.intr.copysign"(%arg0, %arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32, f32) -> f322135 2136// CHECK: call fast float @llvm.powi.f32.i32(float {{.*}}, i32 {{.*}})2137  %exp = llvm.mlir.constant(1 : i32) : i322138  %19 = "llvm.intr.powi"(%arg0, %exp) {fastmathFlags = #llvm.fastmath<fast>} : (f32, i32) -> f322139// CHECK: call afn float @llvm.powi.f32.i32(float {{.*}}, i32 {{.*}})2140  %20 = "llvm.intr.powi"(%arg0, %exp) {fastmathFlags = #llvm.fastmath<afn>} : (f32, i32) -> f322141 2142// CHECK: call nnan float @llvm.vector.reduce.fmax.v2f32(<2 x float> {{.*}})2143// CHECK: call nnan float @llvm.vector.reduce.fmin.v2f32(<2 x float> {{.*}})2144  %21 = llvm.intr.vector.reduce.fmax(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f322145  %22 = llvm.intr.vector.reduce.fmin(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f322146 2147// CHECK: call nnan float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> {{.*}})2148// CHECK: call nnan float @llvm.vector.reduce.fminimum.v2f32(<2 x float> {{.*}})2149  %23 = llvm.intr.vector.reduce.fmaximum(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f322150  %24 = llvm.intr.vector.reduce.fminimum(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f322151 2152  %25 = llvm.mlir.constant(true) : i12153// CHECK: select contract i12154  %26 = llvm.select %25, %arg0, %20 {fastmathFlags = #llvm.fastmath<contract>} : i1, f322155  llvm.return2156}2157 2158// -----2159 2160// CHECK-LABEL: @switch_empty2161llvm.func @switch_empty(%arg0 : i32) -> i32 {2162  // CHECK:      switch i32 %[[SWITCH_arg0:[0-9]+]], label %[[SWITCHDEFAULT_bb1:[0-9]+]] [2163  // CHECK-NEXT: ]2164  llvm.switch %arg0 : i32, ^bb1 [2165  ]2166 2167  // CHECK:      [[SWITCHDEFAULT_bb1]]:2168  // CHECK-NEXT:   ret i32 %[[SWITCH_arg0]]2169^bb1:2170  llvm.return %arg0 : i322171}2172 2173// -----2174 2175// CHECK-LABEL: @switch_args2176llvm.func @switch_args(%arg0: i32) -> i32 {2177  %0 = llvm.mlir.constant(5 : i32) : i322178  %1 = llvm.mlir.constant(7 : i32) : i322179  %2 = llvm.mlir.constant(11 : i32) : i322180  // CHECK:      switch i32 %[[SWITCH_arg0:[0-9]+]], label %[[SWITCHDEFAULT_bb1:[0-9]+]] [2181  // CHECK-NEXT:   i32 -1, label %[[SWITCHCASE_bb2:[0-9]+]]2182  // CHECK-NEXT:   i32 1, label %[[SWITCHCASE_bb3:[0-9]+]]2183  // CHECK-NEXT: ]2184  llvm.switch %arg0 : i32, ^bb1 [2185    -1: ^bb2(%0 : i32),2186    1: ^bb3(%1, %2 : i32, i32)2187  ]2188 2189// CHECK:      [[SWITCHDEFAULT_bb1]]:2190// CHECK-NEXT:   ret i32 %[[SWITCH_arg0]]2191^bb1:  // pred: ^bb02192  llvm.return %arg0 : i322193 2194// CHECK:      [[SWITCHCASE_bb2]]:2195// CHECK-NEXT:   phi i32 [ 5, %1 ]2196// CHECK-NEXT:   ret i322197^bb2(%3: i32): // pred: ^bb02198  llvm.return %1 : i322199 2200// CHECK:      [[SWITCHCASE_bb3]]:2201// CHECK-NEXT:   phi i32 [ 7, %1 ]2202// CHECK-NEXT:   phi i32 [ 11, %1 ]2203// CHECK-NEXT:   ret i322204^bb3(%4: i32, %5: i32): // pred: ^bb02205  llvm.return %4 : i322206}2207 2208// CHECK-LABEL: @switch_weights2209llvm.func @switch_weights(%arg0: i32) -> i32 {2210  %0 = llvm.mlir.constant(19 : i32) : i322211  %1 = llvm.mlir.constant(23 : i32) : i322212  %2 = llvm.mlir.constant(29 : i32) : i322213  // CHECK: !prof ![[SWITCH_WEIGHT_NODE:[0-9]+]]2214  llvm.switch %arg0 : i32, ^bb1(%0 : i32) [2215    9: ^bb2(%1, %2 : i32, i32),2216    99: ^bb32217  ] {branch_weights = array<i32 : 13, 17, 19>}2218 2219^bb1(%3: i32):  // pred: ^bb02220  llvm.return %3 : i322221 2222^bb2(%4: i32, %5: i32): // pred: ^bb02223  llvm.return %5 : i322224 2225^bb3: // pred: ^bb02226  llvm.return %arg0 : i322227}2228 2229// CHECK: ![[SWITCH_WEIGHT_NODE]] = !{!"branch_weights", i32 13, i32 17, i32 19}2230 2231// -----2232 2233// It is okay to have repeated successors if they have no arguments.2234 2235// CHECK-LABEL: @duplicate_block_in_switch2236// CHECK-SAME: float %[[FIRST:.*]],2237// CHECK-SAME: float %[[SECOND:.*]])2238// CHECK:   switch i32 %{{.*}}, label %[[DEFAULT:.*]] [2239// CHECK:     i32 105, label %[[DUPLICATE:.*]]2240// CHECK:     i32 108, label %[[BLOCK:.*]]2241// CHECK:     i32 106, label %[[DUPLICATE]]2242// CHECK:   ]2243 2244// CHECK: [[DEFAULT]]:2245// CHECK:   phi float [ %[[FIRST]], %{{.*}} ]2246// CHECK:   call void @bar2247 2248// CHECK: [[DUPLICATE]]:2249// CHECK:   call void @baz2250 2251// CHECK: [[BLOCK]]:2252// CHECK:   phi float [ %[[SECOND]], %{{.*}} ]2253// CHECK:   call void @qux2254 2255llvm.func @duplicate_block_in_switch(%cond : i32, %arg1: f32, %arg2: f32) {2256  llvm.switch %cond : i32, ^bb1(%arg1: f32) [2257    105: ^bb2,2258    108: ^bb3(%arg2: f32),2259    106: ^bb22260  ]2261 2262^bb1(%arg3: f32):2263  llvm.call @bar(%arg3): (f32) -> ()2264  llvm.return2265 2266^bb2:2267  llvm.call @baz() : () -> ()2268  llvm.return2269 2270^bb3(%arg4: f32):2271  llvm.call @qux(%arg4) : (f32) -> ()2272  llvm.return2273}2274 2275// If there are repeated successors with arguments, a new block must be created2276// for repeated successors to ensure PHI can disambiguate values based on the2277// predecessor they come from.2278 2279// CHECK-LABEL: @duplicate_block_with_args_in_switch2280// CHECK-SAME: float %[[FIRST:.*]],2281// CHECK-SAME: float %[[SECOND:.*]])2282// CHECK:   switch i32 %{{.*}}, label %[[DEFAULT:.*]] [2283// CHECK:     i32 106, label %[[DUPLICATE:.*]]2284// CHECK:     i32 105, label %[[BLOCK:.*]]2285// CHECK:     i32 108, label %[[DEDUPLICATED:.*]]2286// CHECK:   ]2287 2288// CHECK: [[DEFAULT]]:2289// CHECK:   phi float [ %[[FIRST]], %{{.*}} ]2290// CHECK:   call void @bar2291 2292// CHECK: [[BLOCK]]:2293// CHECK:   call void @baz2294 2295// CHECK: [[DUPLICATE]]:2296// CHECK:   phi float [ %[[PHI:.*]], %[[DEDUPLICATED]] ], [ %[[FIRST]], %{{.*}} ]2297// CHECK:   call void @qux2298 2299// CHECK: [[DEDUPLICATED]]:2300// CHECK:   %[[PHI]] = phi float [ %[[SECOND]], %{{.*}} ]2301// CHECK:   br label %[[DUPLICATE]]2302 2303llvm.func @duplicate_block_with_args_in_switch(%cond : i32, %arg1: f32, %arg2: f32) {2304  llvm.switch %cond : i32, ^bb1(%arg1: f32) [2305    106: ^bb3(%arg1: f32),2306    105: ^bb2,2307    108: ^bb3(%arg2: f32)2308  ]2309 2310^bb1(%arg3: f32):2311  llvm.call @bar(%arg3): (f32) -> ()2312  llvm.return2313 2314^bb2:2315  llvm.call @baz() : () -> ()2316  llvm.return2317 2318^bb3(%arg4: f32):2319  llvm.call @qux(%arg4) : (f32) -> ()2320  llvm.return2321}2322 2323llvm.func @bar(f32)2324llvm.func @baz()2325llvm.func @qux(f32)2326 2327// -----2328 2329// Varaidic function definition2330 2331// CHECK: %struct.va_list = type { ptr }2332 2333// CHECK: define i32 @vararg_function(i32 %{{.*}}, ...)2334llvm.func @vararg_function(%arg0: i32, ...) -> i32 {2335  %0 = llvm.mlir.constant(1 : i32) : i322336  %1 = llvm.mlir.constant(1 : i32) : i322337  // CHECK: %[[ALLOCA0:.+]] = alloca %struct.va_list, align 82338  %2 = llvm.alloca %1 x !llvm.struct<"struct.va_list", (ptr)> {alignment = 8 : i64} : (i32) -> !llvm.ptr2339  // CHECK: call void @llvm.va_start.p0(ptr %[[ALLOCA0]])2340  llvm.intr.vastart %2 : !llvm.ptr2341  // CHECK: %[[ALLOCA1:.+]] = alloca ptr, align 82342  %4 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr2343  // CHECK: call void @llvm.va_copy.p0(ptr %[[ALLOCA1]], ptr %[[ALLOCA0]])2344  llvm.intr.vacopy %2 to %4 : !llvm.ptr, !llvm.ptr2345  // CHECK: %[[RET:.+]] = va_arg ptr %[[ALLOCA1]], i322346  %ret = llvm.va_arg %4 : (!llvm.ptr) -> i322347  // CHECK: call void @llvm.va_end.p0(ptr %[[ALLOCA1]])2348  // CHECK: call void @llvm.va_end.p0(ptr %[[ALLOCA0]])2349  llvm.intr.vaend %4 : !llvm.ptr2350  llvm.intr.vaend %2 : !llvm.ptr2351  // CHECK: ret i32 %[[RET]]2352  llvm.return %ret : i322353}2354 2355// -----2356 2357// CHECK: declare void @range_arg_function(i64 range(i64 0, 4097))2358llvm.func @range_arg_function(%arg0: i64 {llvm.range = #llvm.constant_range<i64, 0, 4097>})2359 2360// -----2361 2362// CHECK: declare range(i64 0, 4097) i64 @range_res_function()2363llvm.func @range_res_function() -> (i64 {llvm.range = #llvm.constant_range<i64, 0, 4097>})2364 2365// -----2366 2367// CHECK: declare void @readonly_function([[PTR:.+]] readonly)2368llvm.func @readonly_function(%arg0: !llvm.ptr {llvm.readonly})2369 2370// -----2371 2372// CHECK: declare void @arg_mem_none_func() #[[ATTR:[0-9]+]]2373llvm.func @arg_mem_none_func() attributes {2374  memory_effects = #llvm.memory_effects<other = readwrite, argMem = none, inaccessibleMem = readwrite, errnoMem = none, targetMem0 = none, targetMem1 = none>}2375 2376// CHECK: attributes #[[ATTR]] = { memory(readwrite, argmem: none, errnomem: none, target_mem0: none, target_mem1: none) }2377 2378// -----2379 2380// CHECK: declare void @readwrite_func() #[[ATTR:[0-9]+]]2381llvm.func @readwrite_func() attributes {2382  memory_effects = #llvm.memory_effects<other = readwrite, argMem = readwrite, inaccessibleMem = readwrite, errnoMem = none, targetMem0 = none, targetMem1 = none>}2383 2384// CHECK: attributes #[[ATTR]] = { memory(readwrite, errnomem: none, target_mem0: none, target_mem1: none) }2385 2386// -----2387 2388//2389// target-features attribute.2390//2391 2392// CHECK-LABEL: @tf2393// CHECK-SAME: #[[TargetFeat:.*]]2394llvm.func @tf(!llvm.ptr) attributes {target_features = #llvm.target_features<["+fix-cortex-a53-835769", "+fp-armv8", "+neon", "+outline-atomics", "+v8a"]>}2395 2396// CHECK: attributes #[[TargetFeat]] = { "target-features"="+fix-cortex-a53-835769,+fp-armv8,+neon,+outline-atomics,+v8a" }2397 2398// -----2399 2400//2401// arm_streaming attribute.2402//2403 2404// CHECK-LABEL: @streaming_func2405// CHECK: #[[ATTR:[0-9]*]]2406llvm.func @streaming_func() attributes {arm_streaming} {2407  llvm.return2408}2409 2410// CHECK: attributes #[[ATTR]] = { "aarch64_pstate_sm_enabled" }2411 2412// -----2413 2414//2415// arm_locally_streaming attribute.2416//2417 2418// CHECK-LABEL: @locally_streaming_func2419// CHECK: #[[ATTR:[0-9]*]]2420llvm.func @locally_streaming_func() attributes {arm_locally_streaming} {2421  llvm.return2422}2423 2424// CHECK: attributes #[[ATTR]] = { "aarch64_pstate_sm_body" }2425 2426// -----2427 2428//2429// arm_streaming_compatible attribute.2430//2431 2432// CHECK-LABEL: @streaming_compatible_func2433// CHECK: #[[ATTR:[0-9]*]]2434llvm.func @streaming_compatible_func() attributes {arm_streaming_compatible} {2435  llvm.return2436}2437 2438// CHECK: attributes #[[ATTR]] = { "aarch64_pstate_sm_compatible" }2439 2440// -----2441 2442// CHECK-LABEL: @new_za_func2443// CHECK-SAME: #[[ATTR:[0-9]*]]2444llvm.func @new_za_func() attributes {arm_new_za} {2445  llvm.return2446}2447// CHECK: #[[ATTR]] = { "aarch64_new_za" }2448 2449// -----2450 2451// CHECK-LABEL: @in_za_func2452// CHECK-SAME: #[[ATTR:[0-9]*]]2453llvm.func @in_za_func() attributes {arm_in_za } {2454  llvm.return2455}2456// CHECK: #[[ATTR]] = { "aarch64_in_za" }2457 2458// -----2459 2460// CHECK-LABEL: @out_za_func2461// CHECK-SAME: #[[ATTR:[0-9]*]]2462llvm.func @out_za_func() attributes {arm_out_za } {2463  llvm.return2464}2465// CHECK: #[[ATTR]] = { "aarch64_out_za" }2466 2467// -----2468 2469// CHECK-LABEL: @inout_za_func2470// CHECK-SAME: #[[ATTR:[0-9]*]]2471llvm.func @inout_za_func() attributes {arm_inout_za } {2472  llvm.return2473}2474// CHECK: #[[ATTR]] = { "aarch64_inout_za" }2475 2476// -----2477 2478// CHECK-LABEL: @preserves_za_func2479// CHECK-SAME: #[[ATTR:[0-9]*]]2480llvm.func @preserves_za_func() attributes {arm_preserves_za} {2481  llvm.return2482}2483// CHECK: #[[ATTR]] = { "aarch64_preserves_za" }2484 2485// -----2486 2487//2488// frame pointer attribute.2489//2490 2491// CHECK-LABEL: @t2492// CHECK-SAME: #[[FP:.*]]2493llvm.func @t(!llvm.ptr) attributes {frame_pointer = #llvm.framePointerKind<"non-leaf">}2494 2495// CHECK: attributes #[[FP]] = { "frame-pointer"="non-leaf" }2496 2497// -----2498 2499//2500// Zero-initialize operation.2501//2502 2503// CHECK: @partially_zeroinit_aggregate = linkonce global { i32, i64, [3 x i8] } { i32 0, i64 1, [3 x i8] zeroinitializer }2504llvm.mlir.global linkonce @partially_zeroinit_aggregate() : !llvm.struct<(i32, i64, !llvm.array<3 x i8>)> {2505  %0 = llvm.mlir.zero : !llvm.struct<(i32, i64, !llvm.array<3 x i8>)>2506  %1 = llvm.mlir.constant(1 : i64) : i642507  %2 = llvm.insertvalue %1, %0[1] : !llvm.struct<(i32, i64, !llvm.array<3 x i8>)>2508  llvm.return %2 : !llvm.struct<(i32, i64, !llvm.array<3 x i8>)>2509}2510 2511llvm.func @zeroinit_complex_local_aggregate() {2512  // CHECK: %[[#VAR:]] = alloca [1000 x { i32, [3 x { double, <4 x ptr>, [2 x ptr] }], [6 x ptr] }], i64 1, align 322513  %0 = llvm.mlir.constant(1 : i64) : i642514  %1 = llvm.alloca %0 x !llvm.array<1000 x !llvm.struct<(i32, !llvm.array<3 x !llvm.struct<(f64, vector<4 x !llvm.ptr>, !llvm.array<2 x ptr>)>>, !llvm.array<6 x ptr>)>> : (i64) -> !llvm.ptr2515 2516  // CHECK: store [1000 x { i32, [3 x { double, <4 x ptr>, [2 x ptr] }], [6 x ptr] }] zeroinitializer, ptr %[[#VAR]], align 322517  %2 = llvm.mlir.zero : !llvm.array<1000 x !llvm.struct<(i32, !llvm.array<3 x !llvm.struct<(f64, vector<4 x !llvm.ptr>, !llvm.array<2 x ptr>)>>, !llvm.array<6 x ptr>)>>2518  llvm.store %2, %1 : !llvm.array<1000 x !llvm.struct<(i32, !llvm.array<3 x !llvm.struct<(f64, vector<4 x !llvm.ptr>, !llvm.array<2 x ptr>)>>, !llvm.array<6 x ptr>)>>, !llvm.ptr2519 2520  llvm.return2521}2522 2523//CHECK: !llvm.linker.options = !{![[MD0:[0-9]+]], ![[MD1:[0-9]+]]}2524//CHECK: ![[MD0]] = !{!"/DEFAULTLIB:", !"libcmt"}2525llvm.linker_options ["/DEFAULTLIB:", "libcmt"]2526//CHECK: ![[MD1]] = !{!"/DEFAULTLIB:", !"libcmtd"}2527llvm.linker_options ["/DEFAULTLIB:", "libcmtd"]2528 2529// -----2530 2531// CHECK: @big_ = common global [4294967296 x i8] zeroinitializer2532llvm.mlir.global common @big_(dense<0> : vector<4294967296xi8>) {addr_space = 0 : i32} : !llvm.array<4294967296 x i8>2533 2534// -----2535 2536// CHECK-LABEL: @no_inline2537// CHECK-SAME: #[[ATTRS:[0-9]+]]2538llvm.func @no_inline() attributes { no_inline } {2539  llvm.return2540}2541 2542// CHECK: #[[ATTRS]]2543// CHECK-SAME: noinline2544 2545// -----2546 2547// CHECK-LABEL: @always_inline2548// CHECK-SAME: #[[ATTRS:[0-9]+]]2549llvm.func @always_inline() attributes { always_inline } {2550  llvm.return2551}2552 2553// CHECK: #[[ATTRS]]2554// CHECK-SAME: alwaysinline2555 2556// -----2557 2558// CHECK-LABEL: @inline_hint2559// CHECK-SAME: #[[ATTRS:[0-9]+]]2560llvm.func @inline_hint() attributes { inline_hint } {2561  llvm.return2562}2563 2564// CHECK: #[[ATTRS]]2565// CHECK-SAME: inlinehint2566 2567// -----2568 2569// CHECK-LABEL: @optimize_none2570// CHECK-SAME: #[[ATTRS:[0-9]+]]2571llvm.func @optimize_none() attributes { no_inline, optimize_none } {2572  llvm.return2573}2574 2575// CHECK: #[[ATTRS]]2576// CHECK-SAME: optnone2577 2578// -----2579 2580// CHECK-LABEL: @convergent2581// CHECK-SAME: #[[ATTRS:[0-9]+]]2582llvm.func @convergent() attributes { convergent } {2583  llvm.return2584}2585 2586// CHECK: #[[ATTRS]]2587// CHECK-SAME: convergent2588 2589// -----2590 2591// CHECK-LABEL: define void @function_entry_instrument_test()2592// CHECK-SAME: #[[ATTRS:[0-9]+]]2593llvm.func @function_entry_instrument_test() attributes {instrument_function_entry = "__cyg_profile_func_enter"}  {2594  llvm.return2595}2596// CHECK: attributes #[[ATTRS]] = { "instrument-function-entry"="__cyg_profile_func_enter" }2597 2598// -----2599 2600// CHECK-LABEL: define void @function_exit_instrument_test()2601// CHECK-SAME: #[[ATTRS:[0-9]+]]2602llvm.func @function_exit_instrument_test() attributes {instrument_function_exit = "__cyg_profile_func_exit"}  {2603  llvm.return2604}2605// CHECK: attributes #[[ATTRS]] = { "instrument-function-exit"="__cyg_profile_func_exit" }2606 2607// -----2608 2609// CHECK-LABEL: @nounwind2610// CHECK-SAME: #[[ATTRS:[0-9]+]]2611llvm.func @nounwind() attributes { no_unwind } {2612  llvm.return2613}2614 2615// CHECK: #[[ATTRS]]2616// CHECK-SAME: nounwind2617 2618// -----2619 2620// CHECK-LABEL: @willreturn2621// CHECK-SAME: #[[ATTRS:[0-9]+]]2622llvm.func @willreturn() attributes { will_return } {2623  llvm.return2624}2625 2626// CHECK: #[[ATTRS]]2627// CHECK-SAME: willreturn2628 2629// -----2630 2631llvm.func @f()2632 2633// CHECK-LABEL: @convergent_call2634// CHECK: call void @f() #[[ATTRS:[0-9]+]]2635llvm.func @convergent_call() {2636  llvm.call @f() {convergent} : () -> ()2637  llvm.return2638}2639 2640// CHECK: #[[ATTRS]]2641// CHECK-SAME: convergent2642 2643// -----2644 2645llvm.func @f()2646 2647// CHECK-LABEL: @nounwind_call2648// CHECK: call void @f() #[[ATTRS:[0-9]+]]2649llvm.func @nounwind_call() {2650  llvm.call @f() {no_unwind} : () -> ()2651  llvm.return2652}2653 2654// CHECK: #[[ATTRS]]2655// CHECK-SAME: nounwind2656 2657// -----2658 2659llvm.func @f()2660 2661// CHECK-LABEL: @willreturn_call2662// CHECK: call void @f() #[[ATTRS:[0-9]+]]2663llvm.func @willreturn_call() {2664  llvm.call @f() {will_return} : () -> ()2665  llvm.return2666}2667 2668// CHECK: #[[ATTRS]]2669// CHECK-SAME: willreturn2670 2671// -----2672 2673llvm.func @f()2674 2675// CHECK-LABEL: @no_inline_call2676// CHECK: call void @f() #[[ATTRS:[0-9]+]]2677llvm.func @no_inline_call() {2678  llvm.call @f() {no_inline} : () -> ()2679  llvm.return2680}2681 2682// CHECK: #[[ATTRS]]2683// CHECK-SAME: noinline2684 2685// -----2686 2687llvm.func @f()2688 2689// CHECK-LABEL: @always_inline_call2690// CHECK: call void @f() #[[ATTRS:[0-9]+]]2691llvm.func @always_inline_call() {2692  llvm.call @f() {always_inline} : () -> ()2693  llvm.return2694}2695 2696// CHECK: #[[ATTRS]]2697// CHECK-SAME: alwaysinline2698 2699// -----2700 2701llvm.func @f()2702 2703// CHECK-LABEL: @inline_hint_call2704// CHECK: call void @f() #[[ATTRS:[0-9]+]]2705llvm.func @inline_hint_call() {2706  llvm.call @f() {inline_hint} : () -> ()2707  llvm.return2708}2709 2710// CHECK: #[[ATTRS]]2711// CHECK-SAME: inlinehint2712 2713// -----2714 2715llvm.func @fa()2716llvm.func @fb()2717llvm.func @fc()2718llvm.func @fd()2719 2720// CHECK-LABEL: @mem_effects_call2721// CHECK: call void @fa() #[[ATTRS_0:[0-9]+]]2722// CHECK: call void @fb() #[[ATTRS_1:[0-9]+]]2723// CHECK: call void @fc() #[[ATTRS_2:[0-9]+]]2724// CHECK: call void @fd() #[[ATTRS_3:[0-9]+]]2725llvm.func @mem_effects_call() {2726  llvm.call @fa() {memory_effects = #llvm.memory_effects<other = none, argMem = none, inaccessibleMem = none, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()2727  llvm.call @fb() {memory_effects = #llvm.memory_effects<other = read, argMem = none, inaccessibleMem = write, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()2728  llvm.call @fc() {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = write, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()2729  llvm.call @fd() {memory_effects = #llvm.memory_effects<other = readwrite, argMem = read, inaccessibleMem = readwrite, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()2730  llvm.return2731 2732}2733 2734// CHECK: #[[ATTRS_0]]2735// CHECK-SAME: memory(none)2736// CHECK: #[[ATTRS_1]]2737// CHECK-SAME: memory(read, argmem: none, inaccessiblemem: write, errnomem: none, target_mem0: none, target_mem1: none)2738// CHECK: #[[ATTRS_2]]2739// CHECK-SAME: memory(read, inaccessiblemem: write, errnomem: none, target_mem0: none, target_mem1: none)2740// CHECK: #[[ATTRS_3]]2741// CHECK-SAME: memory(readwrite, argmem: read, errnomem: none, target_mem0: none, target_mem1: none)2742 2743// -----2744 2745// CHECK: declare !vec_type_hint ![[#VEC_TYPE_HINT:]] void @vec_type_hint()2746llvm.func @vec_type_hint() attributes {vec_type_hint = #llvm.vec_type_hint<hint = i32>}2747 2748// CHECK: declare !vec_type_hint ![[#VEC_TYPE_HINT_SIGNED:]] void @vec_type_hint_signed()2749llvm.func @vec_type_hint_signed() attributes {vec_type_hint = #llvm.vec_type_hint<hint = i32, is_signed = true>}2750 2751// CHECK: declare !vec_type_hint ![[#VEC_TYPE_HINT_SIGNED_VEC:]] void @vec_type_hint_signed_vec()2752llvm.func @vec_type_hint_signed_vec() attributes {vec_type_hint = #llvm.vec_type_hint<hint = vector<2xi32>, is_signed = true>}2753 2754// CHECK: declare !vec_type_hint ![[#VEC_TYPE_HINT_FVEC:]] void @vec_type_hint_float_vec()2755llvm.func @vec_type_hint_float_vec() attributes {vec_type_hint = #llvm.vec_type_hint<hint = vector<3xf32>>}2756 2757// CHECK: declare !vec_type_hint ![[#VEC_TYPE_HINT_BFVEC:]] void @vec_type_hint_bfloat_vec()2758llvm.func @vec_type_hint_bfloat_vec() attributes {vec_type_hint = #llvm.vec_type_hint<hint = vector<8xbf16>>}2759 2760// CHECK: ![[#VEC_TYPE_HINT]] = !{i32 undef, i32 0}2761// CHECK: ![[#VEC_TYPE_HINT_SIGNED]] = !{i32 undef, i32 1}2762// CHECK: ![[#VEC_TYPE_HINT_SIGNED_VEC]] = !{<2 x i32> undef, i32 1}2763// CHECK: ![[#VEC_TYPE_HINT_FVEC]] = !{<3 x float> undef, i32 0}2764// CHECK: ![[#VEC_TYPE_HINT_BFVEC]] = !{<8 x bfloat> undef, i32 0}2765 2766// -----2767 2768// CHECK: declare !work_group_size_hint ![[#WORK_GROUP_SIZE_HINT:]] void @work_group_size_hint()2769llvm.func @work_group_size_hint() attributes {work_group_size_hint = array<i32: 128, 128, 128>}2770 2771// CHECK: ![[#WORK_GROUP_SIZE_HINT]] = !{i32 128, i32 128, i32 128}2772 2773// -----2774 2775// CHECK: declare !reqd_work_group_size ![[#REQD_WORK_GROUP_SIZE:]] void @reqd_work_group_size()2776llvm.func @reqd_work_group_size() attributes {reqd_work_group_size = array<i32: 128, 256, 128>}2777 2778// CHECK: ![[#REQD_WORK_GROUP_SIZE]] = !{i32 128, i32 256, i32 128}2779 2780// -----2781 2782// CHECK: declare !intel_reqd_sub_group_size ![[#INTEL_REQD_SUB_GROUP_SIZE:]] void @intel_reqd_sub_group_size()2783llvm.func @intel_reqd_sub_group_size() attributes {intel_reqd_sub_group_size = 32 : i32}2784 2785// CHECK: ![[#INTEL_REQD_SUB_GROUP_SIZE]] = !{i32 32}2786 2787// -----2788 2789llvm.func @foo()2790 2791llvm.func @call_with_empty_opbundle() {2792  llvm.call @foo() [] : () -> ()2793  llvm.return2794}2795 2796//      CHECK: define void @call_with_empty_opbundle() {2797// CHECK-NEXT:   call void @foo()2798// CHECK-NEXT:   ret void2799// CHECK-NEXT: }2800 2801llvm.func @call_with_empty_opbundle_operands() {2802  llvm.call @foo() ["tag"()] : () -> ()2803  llvm.return2804}2805 2806//      CHECK: define void @call_with_empty_opbundle_operands() {2807// CHECK-NEXT:   call void @foo() [ "tag"() ]2808// CHECK-NEXT:   ret void2809// CHECK-NEXT: }2810 2811llvm.func @call_with_opbundle() {2812  %0 = llvm.mlir.constant(1 : i32) : i322813  %1 = llvm.mlir.constant(2 : i32) : i322814  %2 = llvm.mlir.constant(3 : i32) : i322815  llvm.call @foo() ["tag1"(%0, %1 : i32, i32), "tag2"(%2 : i32)] : () -> ()2816  llvm.return2817}2818 2819//      CHECK: define void @call_with_opbundle() {2820// CHECK-NEXT:   call void @foo() [ "tag1"(i32 1, i32 2), "tag2"(i32 3) ]2821// CHECK-NEXT:   ret void2822// CHECK-NEXT: }2823 2824llvm.func @__gxx_personality_v0(...) -> i322825llvm.func @invoke_with_opbundle() attributes { personality = @__gxx_personality_v0 } {2826  %0 = llvm.mlir.constant(1 : i32) : i322827  %1 = llvm.mlir.constant(2 : i32) : i322828  %2 = llvm.mlir.constant(3 : i32) : i322829  llvm.invoke @foo() to ^bb2 unwind ^bb1 ["tag1"(%0, %1 : i32, i32), "tag2"(%2 : i32)] : () -> ()2830 2831^bb1:2832  %3 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>2833  llvm.return2834 2835^bb2:2836  llvm.return2837}2838 2839//      CHECK: define void @invoke_with_opbundle() personality ptr @__gxx_personality_v0 {2840// CHECK-NEXT:   invoke void @foo() [ "tag1"(i32 1, i32 2), "tag2"(i32 3) ]2841// CHECK-NEXT:           to label %{{.+}} unwind label %{{.+}}2842//      CHECK: }2843 2844llvm.func @call_intrin_with_opbundle(%arg0 : !llvm.ptr) {2845  %0 = llvm.mlir.constant(1 : i1) : i12846  %1 = llvm.mlir.constant(16 : i32) : i322847  llvm.call_intrinsic "llvm.assume"(%0) ["align"(%arg0, %1 : !llvm.ptr, i32)] : (i1) -> ()2848  llvm.return2849}2850 2851//      CHECK: define void @call_intrin_with_opbundle(ptr %0) {2852// CHECK-NEXT:   call void @llvm.assume(i1 true) [ "align"(ptr %0, i32 16) ]2853// CHECK-NEXT:   ret void2854// CHECK-NEXT: }2855 2856// -----2857 2858module {2859  llvm.module_flags [#llvm.mlir.module_flag<error, "wchar_size", 4 : i32>,2860                     #llvm.mlir.module_flag<min, "PIC Level", 2 : i32>,2861                     #llvm.mlir.module_flag<max, "PIE Level", 2 : i32>,2862                     #llvm.mlir.module_flag<max, "uwtable", 2 : i32>,2863                     #llvm.mlir.module_flag<max, "frame-pointer", 1 : i32>]2864}2865 2866// CHECK: !llvm.module.flags = !{![[#WCHAR:]], ![[#PIC:]], ![[#PIE:]], ![[#UWTABLE:]], ![[#FrameP:]], ![[#DBG:]]}2867 2868// CHECK: ![[#WCHAR]] = !{i32 1, !"wchar_size", i32 4}2869// CHECK: ![[#PIC]] = !{i32 8, !"PIC Level", i32 2}2870// CHECK: ![[#PIE]] = !{i32 7, !"PIE Level", i32 2}2871// CHECK: ![[#UWTABLE]] = !{i32 7, !"uwtable", i32 2}2872// CHECK: ![[#FrameP]] = !{i32 7, !"frame-pointer", i32 1}2873// CHECK: ![[#DBG]] = !{i32 2, !"Debug Info Version", i32 3}2874 2875// -----2876 2877// Verifies that the debug info version is not added twice, if it's already present initially.2878 2879module {2880  llvm.module_flags [#llvm.mlir.module_flag<warning, "Debug Info Version", 3 : i32>]2881}2882 2883// CHECK: !llvm.module.flags = !{![[#DBG:]]}2884// CHECK: ![[#DBG]] = !{i32 2, !"Debug Info Version", i32 3}2885 2886// -----2887 2888llvm.module_flags [#llvm.mlir.module_flag<append, "CG Profile", [2889  #llvm.cgprofile_entry<from = @from, to = @to, count = 222>,2890  #llvm.cgprofile_entry<from = @from, count = 222>,2891  #llvm.cgprofile_entry<from = @to, to = @from, count = 222>2892]>]2893llvm.func @from(i32)2894llvm.func @to()2895 2896// CHECK: !llvm.module.flags = !{![[#CGPROF:]], ![[#DBG:]]}2897 2898// CHECK: ![[#CGPROF]] = !{i32 5, !"CG Profile", ![[#LIST:]]}2899// CHECK: ![[#LIST]] = distinct !{![[#ENTRY_A:]], ![[#ENTRY_B:]], ![[#ENTRY_C:]]}2900// CHECK: ![[#ENTRY_A]] = !{ptr @from, ptr @to, i64 222}2901// CHECK: ![[#ENTRY_B]] = !{ptr @from, null, i64 222}2902// CHECK: ![[#ENTRY_C]] = !{ptr @to, ptr @from, i64 222}2903// CHECK: ![[#DBG]] = !{i32 2, !"Debug Info Version", i32 3}2904 2905// -----2906 2907llvm.module_flags [#llvm.mlir.module_flag<error, "ProfileSummary",2908                       #llvm.profile_summary<format = InstrProf, total_count = 263646, max_count = 86427,2909                         max_internal_count = 86427, max_function_count = 4691,2910                         num_counts = 3712, num_functions = 796,2911                         is_partial_profile = 0,2912                         partial_profile_ratio = 0.000000e+00 : f64,2913                         detailed_summary =2914                           <cut_off = 10000, min_count = 86427, num_counts = 1>,2915                           <cut_off = 100000, min_count = 86427, num_counts = 1>2916                  >>]2917 2918// CHECK: !llvm.module.flags = !{![[#PSUM:]], {{.*}}}2919 2920// CHECK: ![[#PSUM]] = !{i32 1, !"ProfileSummary", ![[#SUMLIST:]]}2921// CHECK: ![[#SUMLIST]] = !{![[#FMT:]], ![[#TC:]], ![[#MC:]], ![[#MIC:]], ![[#MFC:]], ![[#NC:]], ![[#NF:]], ![[#IPP:]], ![[#PPR:]], ![[#DS:]]}2922// CHECK: ![[#FMT]] = !{!"ProfileFormat", !"InstrProf"}2923// CHECK: ![[#TC]] = !{!"TotalCount", i64 263646}2924// CHECK: ![[#MC]] = !{!"MaxCount", i64 86427}2925// CHECK: ![[#MIC]] = !{!"MaxInternalCount", i64 86427}2926// CHECK: ![[#MFC]] = !{!"MaxFunctionCount", i64 4691}2927// CHECK: ![[#NC]] = !{!"NumCounts", i64 3712}2928// CHECK: ![[#NF]] = !{!"NumFunctions", i64 796}2929// CHECK: ![[#IPP]] = !{!"IsPartialProfile", i64 0}2930// CHECK: ![[#PPR]] = !{!"PartialProfileRatio", double 0.000000e+00}2931// CHECK: ![[#DS]] = !{!"DetailedSummary", ![[#DETAILED:]]}2932// CHECK: ![[#DETAILED]] = !{![[#DS0:]], ![[#DS1:]]}2933// CHECK: ![[#DS0:]] = !{i64 10000, i64 86427, i64 1}2934// CHECK: ![[#DS1:]] = !{i64 100000, i64 86427, i64 1}2935 2936// -----2937 2938module attributes {llvm.dependent_libraries = ["foo", "bar"]} {}2939 2940// CHECK: !llvm.dependent-libraries =  !{![[#LIBFOO:]], ![[#LIBBAR:]]}2941// CHECK: ![[#LIBFOO]] = !{!"foo"}2942// CHECK: ![[#LIBBAR]] = !{!"bar"}2943 2944// -----2945 2946llvm.mlir.global external constant @const() {addr_space = 0 : i32, dso_local} : i32 {2947  %0 = llvm.mlir.addressof @const : !llvm.ptr2948  %1 = llvm.ptrtoint %0 : !llvm.ptr to i642949  %2 = llvm.dso_local_equivalent @extern_func : !llvm.ptr2950  %3 = llvm.ptrtoint %2 : !llvm.ptr to i642951  %4 = llvm.sub %3, %1 : i642952  %5 = llvm.trunc %4 : i64 to i322953  llvm.return %5 : i322954}2955 2956llvm.func @extern_func()2957 2958// CHECK: @const = dso_local constant i32 trunc2959// CHECK-SAME: (i64 sub (i64 ptrtoint2960// CHECK-SAME: (ptr dso_local_equivalent @extern_func to i64),2961// CHECK-SAME: i64 ptrtoint (ptr @const to i64)) to i32)2962 2963// -----2964 2965llvm.func @extern_func() -> i322966llvm.func @call_extern_func() {2967  %0 = llvm.dso_local_equivalent @extern_func : !llvm.ptr2968  %1 = llvm.call %0() : !llvm.ptr, () -> (i32 {llvm.noundef})2969  llvm.return2970}2971 2972// CHECK-LABEL: @call_extern_func()2973// CHECK: call noundef i32 dso_local_equivalent @extern_func()2974 2975// -----2976 2977llvm.mlir.alias external @alias_func : !llvm.func<void ()> {2978  %0 = llvm.mlir.addressof @aliasee_func : !llvm.ptr2979  llvm.return %0 : !llvm.ptr2980}2981llvm.func @aliasee_func() {2982  llvm.return2983}2984llvm.func @call_alias_func() {2985  %0 = llvm.dso_local_equivalent @alias_func : !llvm.ptr2986  llvm.call %0() : !llvm.ptr, () -> ()2987  llvm.return2988}2989 2990// CHECK-LABEL: @call_alias_func2991// CHECK: call void dso_local_equivalent @alias_func()2992 2993// -----2994 2995llvm.func local_unnamed_addr @testfn(!llvm.array<2 x f32> {llvm.alignstack = 8 : i64})2996llvm.func internal @g(%arg0: !llvm.array<2 x f32>) attributes {dso_local} {2997  // CHECK-LABEL: @g2998  // CHECK: call void @testfn([2 x float] alignstack(8) %0)2999  llvm.call @testfn(%arg0) : (!llvm.array<2 x f32> {llvm.alignstack = 8 : i64}) -> ()3000  llvm.return3001}3002llvm.func local_unnamed_addr @testfn2(!llvm.struct<(i8, i8)> {llvm.alignstack = 8 : i64})3003llvm.func internal @h(%arg0: !llvm.struct<(i8, i8)>) attributes {dso_local} {3004  // CHECK-LABEL: @h3005  // CHECK: call void @testfn2({ i8, i8 } alignstack(8) %0)3006  llvm.call @testfn2(%arg0) : (!llvm.struct<(i8, i8)> {llvm.alignstack = 8 : i64}) -> ()3007  llvm.return3008}3009llvm.func local_unnamed_addr @testfn3(i32 {llvm.alignstack = 8 : i64})3010llvm.func internal @i(%arg0: i32) attributes {dso_local} {3011  // CHECK-LABEL: @i3012  // CHECK: call void @testfn3(i32 alignstack(8) %0)3013  llvm.call @testfn3(%arg0) : (i32 {llvm.alignstack = 8 : i64}) -> ()3014  llvm.return3015}3016 3017// -----3018 3019// CHECK: @test_array_attr_2 = global [2 x { i32, float }] [{ i32, float } { i32 42, float 1.000000e+00 }, { i32, float } { i32 42, float 1.000000e+00 }]3020llvm.mlir.global @test_array_attr_2() : !llvm.array<2 x !llvm.struct<(i32, f32)>> {3021  %0 = llvm.mlir.constant([[42 : i32, 1.000000e+00 : f32],[42 : i32, 1.000000e+00 : f32]]) : !llvm.array<2 x !llvm.struct<(i32, f32)>>3022  llvm.return %0 : !llvm.array<2 x !llvm.struct<(i32, f32)>>3023}3024 3025// CHECK: @test_array_attr_3 = global [2 x [3 x { i32, float }]{{.*}}[3 x { i32, float }] [{ i32, float } { i32 1, float 1.000000e+00 }, { i32, float } { i32 2, float 1.000000e+00 }, { i32, float } { i32 3, float 1.000000e+00 }], [3 x { i32, float }] [{ i32, float } { i32 4, float 1.000000e+00 }, { i32, float } { i32 5, float 1.000000e+00 }, { i32, float } { i32 6, float 1.000000e+00 }3026llvm.mlir.global @test_array_attr_3() : !llvm.array<2 x !llvm.array<3 x !llvm.struct<(i32, f32)>>> {3027  %0 = llvm.mlir.constant([[[1 : i32, 1.000000e+00 : f32], [2 : i32, 1.000000e+00 : f32], [3 : i32, 1.000000e+00 : f32]], [[4 : i32, 1.000000e+00 : f32], [5 : i32, 1.000000e+00 : f32], [6 : i32, 1.000000e+00 : f32]]]) : !llvm.array<2 x !llvm.array<3 x !llvm.struct<(i32, f32)>>>3028  llvm.return %0 : !llvm.array<2 x !llvm.array<3 x !llvm.struct<(i32, f32)>>>3029}3030 3031// CHECK: @test_array_attr_struct_with_ptr = internal constant [2 x { ptr }] [{ ptr } zeroinitializer, { ptr } undef]3032llvm.mlir.global internal constant @test_array_attr_struct_with_ptr() : !llvm.array<2 x struct<(ptr)>> {3033  %0 = llvm.mlir.constant([[#llvm.zero], [#llvm.undef]]) : !llvm.array<2 x struct<(ptr)>>3034  llvm.return %0 : !llvm.array<2 x struct<(ptr)>>3035}3036 3037// CHECK: @test_array_attr_struct_with_struct = internal constant [3 x { i32, float }] [{ i32, float } zeroinitializer, { i32, float } { i32 2, float 1.000000e+00 }, { i32, float } undef]3038llvm.mlir.global internal constant @test_array_attr_struct_with_struct() : !llvm.array<3 x struct<(i32, f32)>> {3039  %0 = llvm.mlir.constant([#llvm.zero, [2 : i32, 1.0 : f32], #llvm.undef]) : !llvm.array<3 x struct<(i32, f32)>>3040  llvm.return %0 : !llvm.array<3 x struct<(i32, f32)>>3041}3042 3043// -----3044 3045// CHECK: @target_specific_attrs_only = external global double #[[ATTRS:[0-9]+]]3046// CHECK: attributes #[[ATTRS]] = { memory(none) "int-attr"="4" "no-enum-attr" "string-attr"="string" }3047llvm.mlir.global external @target_specific_attrs_only() {target_specific_attrs = [["memory", "0"], ["int-attr", "4"], "no-enum-attr", ["string-attr", "string"]]} : f643048 3049// -----3050 3051// CHECK: @target_specific_attrs_combined = global i32 2, section "mysection", align 4 #[[ATTRS:[0-9]+]]3052// CHECK: attributes #[[ATTRS]] = { norecurse "bss-section"="my_bss.1" }3053llvm.mlir.global external @target_specific_attrs_combined(2 : i32) {alignment = 4 : i64, section = "mysection", target_specific_attrs = ["norecurse", ["bss-section", "my_bss.1"]]} : i323054