1056 lines · plain
1// RUN: mlir-opt -verify-roundtrip %s2 3 4// CHECK-LABEL: func @baz5// something to call6llvm.func @baz()7 8// CHECK-LABEL: func @ops9// CHECK-SAME: (%[[I32:.*]]: i32, %[[FLOAT:.*]]: f32, %[[PTR1:.*]]: !llvm.ptr, %[[PTR2:.*]]: !llvm.ptr, %[[BOOL:.*]]: i1, %[[VPTR1:.*]]: vector<2x!llvm.ptr>)10func.func @ops(%arg0: i32, %arg1: f32,11 %arg2: !llvm.ptr, %arg3: !llvm.ptr,12 %arg4: i1, %arg5 : vector<2x!llvm.ptr>) {13// Integer arithmetic binary operations.14//15// CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] : i3216// CHECK: {{.*}} = llvm.sub %[[I32]], %[[I32]] : i3217// CHECK: {{.*}} = llvm.mul %[[I32]], %[[I32]] : i3218// CHECK: {{.*}} = llvm.udiv %[[I32]], %[[I32]] : i3219// CHECK: {{.*}} = llvm.sdiv %[[I32]], %[[I32]] : i3220// CHECK: {{.*}} = llvm.urem %[[I32]], %[[I32]] : i3221// CHECK: {{.*}} = llvm.srem %[[I32]], %[[I32]] : i3222// CHECK: %[[SCALAR_PRED0:.+]] = llvm.icmp "ne" %[[I32]], %[[I32]] : i3223// CHECK: {{.*}} = llvm.add %[[SCALAR_PRED0]], %[[SCALAR_PRED0]] : i124// CHECK: %[[SCALAR_PRED1:.+]] = llvm.icmp "ne" %[[PTR1]], %[[PTR1]] : !llvm.ptr25// CHECK: {{.*}} = llvm.add %[[SCALAR_PRED1]], %[[SCALAR_PRED1]] : i126// CHECK: %[[VEC_PRED:.+]] = llvm.icmp "ne" %[[VPTR1]], %[[VPTR1]] : vector<2x!llvm.ptr>27// CHECK: {{.*}} = llvm.add %[[VEC_PRED]], %[[VEC_PRED]] : vector<2xi1>28 %0 = llvm.add %arg0, %arg0 : i3229 %1 = llvm.sub %arg0, %arg0 : i3230 %2 = llvm.mul %arg0, %arg0 : i3231 %3 = llvm.udiv %arg0, %arg0 : i3232 %4 = llvm.sdiv %arg0, %arg0 : i3233 %5 = llvm.urem %arg0, %arg0 : i3234 %6 = llvm.srem %arg0, %arg0 : i3235 %7 = llvm.icmp "ne" %arg0, %arg0 : i3236 %typecheck_7 = llvm.add %7, %7 : i137 %ptrcmp = llvm.icmp "ne" %arg2, %arg2 : !llvm.ptr38 %typecheck_ptrcmp = llvm.add %ptrcmp, %ptrcmp : i139 %vptrcmp = llvm.icmp "ne" %arg5, %arg5 : vector<2x!llvm.ptr>40 %typecheck_vptrcmp = llvm.add %vptrcmp, %vptrcmp : vector<2 x i1>41 42// Integer overflow flags43// CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] overflow<nsw> : i3244// CHECK: {{.*}} = llvm.sub %[[I32]], %[[I32]] overflow<nuw> : i3245// CHECK: {{.*}} = llvm.mul %[[I32]], %[[I32]] overflow<nsw, nuw> : i3246// CHECK: {{.*}} = llvm.shl %[[I32]], %[[I32]] overflow<nsw, nuw> : i3247 %add_flag = llvm.add %arg0, %arg0 overflow<nsw> : i3248 %sub_flag = llvm.sub %arg0, %arg0 overflow<nuw> : i3249 %mul_flag = llvm.mul %arg0, %arg0 overflow<nsw, nuw> : i3250 %shl_flag = llvm.shl %arg0, %arg0 overflow<nuw, nsw> : i3251 52// Integer exact flag.53// CHECK: {{.*}} = llvm.sdiv exact %[[I32]], %[[I32]] : i3254// CHECK: {{.*}} = llvm.udiv exact %[[I32]], %[[I32]] : i3255// CHECK: {{.*}} = llvm.ashr exact %[[I32]], %[[I32]] : i3256// CHECK: {{.*}} = llvm.lshr exact %[[I32]], %[[I32]] : i3257 %sdiv_flag = llvm.sdiv exact %arg0, %arg0 : i3258 %udiv_flag = llvm.udiv exact %arg0, %arg0 : i3259 %ashr_flag = llvm.ashr exact %arg0, %arg0 : i3260 %lshr_flag = llvm.lshr exact %arg0, %arg0 : i3261 62// Integer disjoint flag.63// CHECK: {{.*}} = llvm.or disjoint %[[I32]], %[[I32]] : i3264 %or_flag = llvm.or disjoint %arg0, %arg0 : i3265 66// Floating point binary operations.67//68// CHECK: {{.*}} = llvm.fadd %[[FLOAT]], %[[FLOAT]] : f3269// CHECK: {{.*}} = llvm.fsub %[[FLOAT]], %[[FLOAT]] : f3270// CHECK: {{.*}} = llvm.fmul %[[FLOAT]], %[[FLOAT]] : f3271// CHECK: {{.*}} = llvm.fdiv %[[FLOAT]], %[[FLOAT]] : f3272// CHECK: {{.*}} = llvm.frem %[[FLOAT]], %[[FLOAT]] : f3273 %8 = llvm.fadd %arg1, %arg1 : f3274 %9 = llvm.fsub %arg1, %arg1 : f3275 %10 = llvm.fmul %arg1, %arg1 : f3276 %11 = llvm.fdiv %arg1, %arg1 : f3277 %12 = llvm.frem %arg1, %arg1 : f3278 79// Memory-related operations.80//81// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x f64 : (i32) -> !llvm.ptr82// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]]] : (!llvm.ptr, i32) -> !llvm.ptr, f6483// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> f6484// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : f64, !llvm.ptr85 %13 = llvm.alloca %arg0 x f64 : (i32) -> !llvm.ptr86 %14 = llvm.getelementptr %13[%arg0] : (!llvm.ptr, i32) -> !llvm.ptr, f6487 %15 = llvm.load %14 : !llvm.ptr -> f6488 llvm.store %15, %13 : f64, !llvm.ptr89 90// Function call-related operations.91//92// CHECK: %[[STRUCT:.*]] = llvm.call @foo(%[[I32]]) : (i32) -> !llvm.struct<(i32, f64, i32)>93// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<(i32, f64, i32)>94// CHECK: %[[NEW_STRUCT:.*]] = llvm.insertvalue %[[VALUE]], %[[STRUCT]][2] : !llvm.struct<(i32, f64, i32)>95// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr96// CHECK: %{{.*}} = llvm.call %[[FUNC]](%[[I32]]) : !llvm.ptr, (i32) -> !llvm.struct<(i32, f64, i32)>97 %17 = llvm.call @foo(%arg0) : (i32) -> !llvm.struct<(i32, f64, i32)>98 %18 = llvm.extractvalue %17[0] : !llvm.struct<(i32, f64, i32)>99 %19 = llvm.insertvalue %18, %17[2] : !llvm.struct<(i32, f64, i32)>100 %20 = llvm.mlir.addressof @foo : !llvm.ptr101 %21 = llvm.call %20(%arg0) : !llvm.ptr, (i32) -> !llvm.struct<(i32, f64, i32)>102 103// Variadic calls104// CHECK: llvm.call @vararg_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) : (i32, i32) -> ()105// CHECK: llvm.call @vararg_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) {fastmathFlags = #llvm.fastmath<fast>} : (i32, i32) -> ()106// CHECK: %[[VARIADIC_FUNC:.*]] = llvm.mlir.addressof @vararg_func : !llvm.ptr107// CHECK: llvm.call %[[VARIADIC_FUNC]](%[[I32]], %[[I32]]) vararg(!llvm.func<void (i32, ...)>) : !llvm.ptr, (i32, i32) -> ()108// CHECK: llvm.call %[[VARIADIC_FUNC]](%[[I32]], %[[I32]]) vararg(!llvm.func<void (i32, ...)>) {fastmathFlags = #llvm.fastmath<fast>} : !llvm.ptr, (i32, i32) -> ()109 llvm.call @vararg_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) : (i32, i32) -> ()110 llvm.call @vararg_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) {fastmathFlags = #llvm.fastmath<fast>} : (i32, i32) -> ()111 %variadic_func = llvm.mlir.addressof @vararg_func : !llvm.ptr112 llvm.call %variadic_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) : !llvm.ptr, (i32, i32) -> ()113 llvm.call %variadic_func(%arg0, %arg0) vararg(!llvm.func<void (i32, ...)>) {fastmathFlags = #llvm.fastmath<fast>} : !llvm.ptr, (i32, i32) -> ()114 115// Function call attributes116// CHECK: llvm.call @baz() {convergent} : () -> ()117 llvm.call @baz() {convergent} : () -> ()118 119// CHECK: llvm.call @baz() {no_unwind} : () -> ()120 llvm.call @baz() {no_unwind} : () -> ()121 122// CHECK: llvm.call @baz() {will_return} : () -> ()123 llvm.call @baz() {will_return} : () -> ()124 125// CHECK: llvm.call @baz() {memory = #llvm.memory_effects<other = none, argMem = read, inaccessibleMem = write, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()126 llvm.call @baz() {memory = #llvm.memory_effects<other = none, argMem = read, inaccessibleMem = write, errnoMem = none, targetMem0 = none, targetMem1 = none>} : () -> ()127 128// Terminator operations and their successors.129//130// CHECK: llvm.br ^[[BB1:.*]]131 llvm.br ^bb1132 133// CHECK: ^[[BB1]]134^bb1:135// CHECK: llvm.cond_br %7, ^[[BB2:.*]], ^[[BB3:.*]]136 llvm.cond_br %7, ^bb2, ^bb3137 138// CHECK: ^[[BB2]]139^bb2:140// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>141// CHECK: %{{.*}} = llvm.mlir.constant(42 : i64) : i47142 %22 = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>143 %23 = llvm.mlir.constant(42) : i47144 // CHECK: llvm.switch %0 : i32, ^[[BB3]] [145 // CHECK-NEXT: 1: ^[[BB4:.*]],146 // CHECK-NEXT: 2: ^[[BB5:.*]],147 // CHECK-NEXT: 3: ^[[BB6:.*]],148 // CHECK-NEXT: -3: ^[[BB6:.*]]149 // CHECK-NEXT: ]150 llvm.switch %0 : i32, ^bb3 [151 1: ^bb4,152 2: ^bb5,153 3: ^bb6,154 -3: ^bb6155 ]156 157// CHECK: ^[[BB3]]158^bb3:159// CHECK: llvm.switch %0 : i32, ^[[BB7:.*]] [160// CHECK-NEXT: ]161 llvm.switch %0 : i32, ^bb7 [162 ]163 164// CHECK: ^[[BB4]]165^bb4:166 llvm.switch %0 : i32, ^bb7 [167 ]168 169// CHECK: ^[[BB5]]170^bb5:171 llvm.switch %0 : i32, ^bb7 [172 ]173 174// CHECK: ^[[BB6]]175^bb6:176 llvm.switch %0 : i32, ^bb7 [177 ]178 179// CHECK: ^[[BB7]]180^bb7:181// Misc operations.182// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, i32183 %24 = llvm.select %7, %0, %1 : i1, i32184 185// Integer to pointer and pointer to integer conversions.186//187// CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : i32 to !llvm.ptr188// CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr to i32189 %25 = llvm.inttoptr %arg0 : i32 to !llvm.ptr190 %26 = llvm.ptrtoint %25 : !llvm.ptr to i32191 192// Extended and Quad floating point193//194// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to f80195// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : f32 to f128196 %27 = llvm.fpext %arg1 : f32 to f80197 %28 = llvm.fpext %arg1 : f32 to f128198 199// CHECK: %{{.*}} = llvm.fneg %[[FLOAT]] : f32200 %29 = llvm.fneg %arg1 : f32201 202// CHECK: llvm.intr.sin(%[[FLOAT]]) : (f32) -> f32203 %30 = llvm.intr.sin(%arg1) : (f32) -> f32204 205// CHECK: llvm.intr.pow(%[[FLOAT]], %[[FLOAT]]) : (f32, f32) -> f32206 %31 = llvm.intr.pow(%arg1, %arg1) : (f32, f32) -> f32207 208// CHECK: llvm.intr.powi(%[[FLOAT]], %[[I32]]) : (f32, i32) -> f32209 %a31 = llvm.intr.powi(%arg1, %arg0) : (f32, i32) -> f32210 211// CHECK: llvm.intr.bitreverse(%{{.*}}) : (i32) -> i32212 %32 = llvm.intr.bitreverse(%arg0) : (i32) -> i32213 214// CHECK: llvm.intr.ctpop(%{{.*}}) : (i32) -> i32215 %33 = llvm.intr.ctpop(%arg0) : (i32) -> i32216 217// CHECK: llvm.intr.round(%[[FLOAT]]) : (f32) -> f32218 %34 = llvm.intr.round(%arg1) : (f32) -> f32219 220// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()221 "llvm.intr.memcpy"(%arg2, %arg3, %arg0) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()222 223// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()224 "llvm.intr.memcpy"(%arg2, %arg3, %arg0) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()225 226// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}) <{isVolatile = false, len = 10 : i64}> : (!llvm.ptr, !llvm.ptr) -> ()227 "llvm.intr.memcpy.inline"(%arg2, %arg3) <{isVolatile = false, len = 10 : i64}> : (!llvm.ptr, !llvm.ptr) -> ()228 229// CHECK: llvm.return230 llvm.return231}232 233// CHECK-LABEL: @gep234llvm.func @gep(%ptr: !llvm.ptr, %idx: i64, %ptr2: !llvm.ptr) {235 // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 1, 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, struct<(i32, f32)>)>236 llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, struct<(i32, f32)>)>237 // CHECK: llvm.getelementptr inbounds %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>238 llvm.getelementptr inbounds %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>239 // CHECK: llvm.getelementptr inbounds|nuw %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>240 llvm.getelementptr inbounds | nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>241 // CHECK: llvm.getelementptr inbounds %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>242 llvm.getelementptr inbounds | nusw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>243 // CHECK: llvm.getelementptr nusw %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>244 llvm.getelementptr nusw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>245 // CHECK: llvm.getelementptr nusw|nuw %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>246 llvm.getelementptr nusw | nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>247 // CHECK: llvm.getelementptr nuw %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>248 llvm.getelementptr nuw %ptr2[%idx, 0, %idx] : (!llvm.ptr, i64, i64) -> !llvm.ptr, !llvm.struct<(array<10 x f32>)>249 llvm.return250}251 252llvm.func @vararg_foo(i32, ...) -> !llvm.struct<(i32, f64, i32)>253 254// An larger self-contained function.255// CHECK-LABEL: llvm.func @foo(%{{.*}}: i32) -> !llvm.struct<(i32, f64, i32)> {256llvm.func @foo(%arg0: i32) -> !llvm.struct<(i32, f64, i32)> {257// CHECK: %[[V0:.*]] = llvm.mlir.constant(3 : i64) : i32258// CHECK: %[[V1:.*]] = llvm.mlir.constant(3 : i64) : i32259// CHECK: %[[V2:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : f64260// CHECK: %[[V3:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : f64261// CHECK: %[[V4:.*]] = llvm.add %[[V0]], %[[V1]] : i32262// CHECK: %[[V5:.*]] = llvm.mul %[[V4]], %[[V1]] : i32263// CHECK: %[[V6:.*]] = llvm.fadd %[[V2]], %[[V3]] : f64264// CHECK: %[[V7:.*]] = llvm.fsub %[[V3]], %[[V6]] : f64265// CHECK: %[[V8:.*]] = llvm.mlir.constant(1 : i64) : i1266// CHECK: llvm.cond_br %[[V8]], ^[[BB1:.*]](%[[V4]] : i32), ^[[BB2:.*]](%[[V4]] : i32)267 %0 = llvm.mlir.constant(3) : i32268 %1 = llvm.mlir.constant(3) : i32269 %2 = llvm.mlir.constant(4.200000e+01) : f64270 %3 = llvm.mlir.constant(4.200000e+01) : f64271 %4 = llvm.add %0, %1 : i32272 %5 = llvm.mul %4, %1 : i32273 %6 = llvm.fadd %2, %3 : f64274 %7 = llvm.fsub %3, %6 : f64275 %8 = llvm.mlir.constant(1) : i1276 llvm.cond_br %8, ^bb1(%4 : i32), ^bb2(%4 : i32)277 278// CHECK:^[[BB1]](%[[V9:.*]]: i32):279// CHECK: %[[V10:.*]] = llvm.call @foo(%[[V9]]) : (i32) -> !llvm.struct<(i32, f64, i32)>280// CHECK: %[[V11:.*]] = llvm.extractvalue %[[V10]][0] : !llvm.struct<(i32, f64, i32)>281// CHECK: %[[V12:.*]] = llvm.extractvalue %[[V10]][1] : !llvm.struct<(i32, f64, i32)>282// CHECK: %[[V13:.*]] = llvm.extractvalue %[[V10]][2] : !llvm.struct<(i32, f64, i32)>283// CHECK: %[[V14:.*]] = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>284// CHECK: %[[V15:.*]] = llvm.insertvalue %[[V5]], %[[V14]][0] : !llvm.struct<(i32, f64, i32)>285// CHECK: %[[V16:.*]] = llvm.insertvalue %[[V7]], %[[V15]][1] : !llvm.struct<(i32, f64, i32)>286// CHECK: %[[V17:.*]] = llvm.insertvalue %[[V11]], %[[V16]][2] : !llvm.struct<(i32, f64, i32)>287// CHECK: llvm.return %[[V17]] : !llvm.struct<(i32, f64, i32)>288^bb1(%9: i32):289 %10 = llvm.call @foo(%9) : (i32) -> !llvm.struct<(i32, f64, i32)>290 %11 = llvm.extractvalue %10[0] : !llvm.struct<(i32, f64, i32)>291 %12 = llvm.extractvalue %10[1] : !llvm.struct<(i32, f64, i32)>292 %13 = llvm.extractvalue %10[2] : !llvm.struct<(i32, f64, i32)>293 %14 = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>294 %15 = llvm.insertvalue %5, %14[0] : !llvm.struct<(i32, f64, i32)>295 %16 = llvm.insertvalue %7, %15[1] : !llvm.struct<(i32, f64, i32)>296 %17 = llvm.insertvalue %11, %16[2] : !llvm.struct<(i32, f64, i32)>297 llvm.return %17 : !llvm.struct<(i32, f64, i32)>298 299// CHECK:^[[BB2]](%[[V18:.*]]: i32):300// CHECK: %[[V19:.*]] = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>301// CHECK: %[[V20:.*]] = llvm.insertvalue %[[V18]], %[[V19]][0] : !llvm.struct<(i32, f64, i32)>302// CHECK: %[[V21:.*]] = llvm.insertvalue %[[V7]], %[[V20]][1] : !llvm.struct<(i32, f64, i32)>303// CHECK: %[[V22:.*]] = llvm.insertvalue %[[V5]], %[[V21]][2] : !llvm.struct<(i32, f64, i32)>304// CHECK: llvm.return %[[V22]] : !llvm.struct<(i32, f64, i32)>305^bb2(%18: i32):306 %19 = llvm.mlir.undef : !llvm.struct<(i32, f64, i32)>307 %20 = llvm.insertvalue %18, %19[0] : !llvm.struct<(i32, f64, i32)>308 %21 = llvm.insertvalue %7, %20[1] : !llvm.struct<(i32, f64, i32)>309 %22 = llvm.insertvalue %5, %21[2] : !llvm.struct<(i32, f64, i32)>310 llvm.return %22 : !llvm.struct<(i32, f64, i32)>311}312 313// CHECK-LABEL: @casts314// CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: vector<4xi32>, %[[V4I64:.*]]: vector<4xi64>, %[[PTR:.*]]: !llvm.ptr)315func.func @casts(%arg0: i32, %arg1: i64, %arg2: vector<4xi32>,316 %arg3: vector<4xi64>, %arg4: !llvm.ptr) {317// CHECK: = llvm.sext %[[I32]] : i32 to i56318 %0 = llvm.sext %arg0 : i32 to i56319// CHECK: = llvm.zext %[[I32]] : i32 to i64320 %1 = llvm.zext %arg0 : i32 to i64321// CHECK: = llvm.trunc %[[I64]] : i64 to i56322 %2 = llvm.trunc %arg1 : i64 to i56323// CHECK: = llvm.sext %[[V4I32]] : vector<4xi32> to vector<4xi56>324 %3 = llvm.sext %arg2 : vector<4xi32> to vector<4xi56>325// CHECK: = llvm.zext %[[V4I32]] : vector<4xi32> to vector<4xi64>326 %4 = llvm.zext %arg2 : vector<4xi32> to vector<4xi64>327// CHECK: = llvm.trunc %[[V4I64]] : vector<4xi64> to vector<4xi56>328 %5 = llvm.trunc %arg3 : vector<4xi64> to vector<4xi56>329// CHECK: = llvm.sitofp %[[I32]] : i32 to f32330 %6 = llvm.sitofp %arg0 : i32 to f32331// CHECK: %[[FLOAT:.*]] = llvm.uitofp %[[I32]] : i32 to f32332 %7 = llvm.uitofp %arg0 : i32 to f32333// CHECK: = llvm.fptosi %[[FLOAT]] : f32 to i32334 %8 = llvm.fptosi %7 : f32 to i32335// CHECK: = llvm.fptoui %[[FLOAT]] : f32 to i32336 %9 = llvm.fptoui %7 : f32 to i32337// CHECK: = llvm.addrspacecast %[[PTR]] : !llvm.ptr to !llvm.ptr<2>338 %10 = llvm.addrspacecast %arg4 : !llvm.ptr to !llvm.ptr<2>339// CHECK: = llvm.bitcast %[[I64]] : i64 to f64340 %11 = llvm.bitcast %arg1 : i64 to f64341 llvm.return342}343 344// CHECK-LABEL: @nneg_casts345// CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: vector<4xi32>, %[[V4I64:.*]]: vector<4xi64>, %[[PTR:.*]]: !llvm.ptr)346func.func @nneg_casts(%arg0: i32, %arg1: i64, %arg2: vector<4xi32>,347 %arg3: vector<4xi64>, %arg4: !llvm.ptr) {348// CHECK: = llvm.zext nneg %[[I32]] : i32 to i64349 %0 = llvm.zext nneg %arg0 : i32 to i64350// CHECK: = llvm.zext nneg %[[V4I32]] : vector<4xi32> to vector<4xi64>351 %4 = llvm.zext nneg %arg2 : vector<4xi32> to vector<4xi64>352// CHECK: = llvm.uitofp nneg %[[I32]] : i32 to f32353 %7 = llvm.uitofp nneg %arg0 : i32 to f32354 llvm.return355}356 357// CHECK-LABEL: @casts_overflow358// CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: vector<4xi32>, %[[V4I64:.*]]: vector<4xi64>, %[[PTR:.*]]: !llvm.ptr)359func.func @casts_overflow(%arg0: i32, %arg1: i64, %arg2: vector<4xi32>,360 %arg3: vector<4xi64>, %arg4: !llvm.ptr) {361// CHECK: = llvm.trunc %[[I64]] overflow<nsw> : i64 to i56362 %0 = llvm.trunc %arg1 overflow<nsw> : i64 to i56363// CHECK: = llvm.trunc %[[I64]] overflow<nuw> : i64 to i56364 %1 = llvm.trunc %arg1 overflow<nuw> : i64 to i56365// CHECK: = llvm.trunc %[[I64]] overflow<nsw, nuw> : i64 to i56366 %2 = llvm.trunc %arg1 overflow<nsw, nuw> : i64 to i56367// CHECK: = llvm.trunc %[[I64]] overflow<nsw, nuw> : i64 to i56368 %3 = llvm.trunc %arg1 overflow<nuw, nsw> : i64 to i56369// CHECK: = llvm.trunc %[[V4I64]] overflow<nsw> : vector<4xi64> to vector<4xi56>370 %4 = llvm.trunc %arg3 overflow<nsw> : vector<4xi64> to vector<4xi56>371 llvm.return372}373 374// CHECK-LABEL: @vect375func.func @vect(%arg0: vector<4xf32>, %arg1: i32, %arg2: f32, %arg3: vector<2x!llvm.ptr>) {376// CHECK: = llvm.extractelement {{.*}} : vector<4xf32>377 %0 = llvm.extractelement %arg0[%arg1 : i32] : vector<4xf32>378// CHECK: = llvm.insertelement {{.*}} : vector<4xf32>379 %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<4xf32>380// CHECK: = llvm.shufflevector {{.*}} [0, 0, 0, 0, 7] : vector<4xf32>381 %2 = llvm.shufflevector %arg0, %arg0 [0, 0, 0, 0, 7] : vector<4xf32>382// CHECK: = llvm.shufflevector %{{.+}}, %{{.+}} [1, 0] : vector<2x!llvm.ptr>383 %3 = llvm.shufflevector %arg3, %arg3 [1, 0] : vector<2x!llvm.ptr>384// CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>385 %4 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32>386 return387}388 389// CHECK-LABEL: @scalable_vect390func.func @scalable_vect(%arg0: vector<[4]xf32>, %arg1: i32, %arg2: f32) {391// CHECK: = llvm.extractelement {{.*}} : vector<[4]xf32>392 %0 = llvm.extractelement %arg0[%arg1 : i32] : vector<[4]xf32>393// CHECK: = llvm.insertelement {{.*}} : vector<[4]xf32>394 %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : vector<[4]xf32>395// CHECK: = llvm.shufflevector {{.*}} [0, 0, 0, 0] : vector<[4]xf32>396 %2 = llvm.shufflevector %arg0, %arg0 [0, 0, 0, 0] : vector<[4]xf32>397// CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>398 %3 = llvm.mlir.constant(dense<1.0> : vector<[4]xf32>) : vector<[4]xf32>399 return400}401 402// CHECK-LABEL: @mixed_vect403func.func @mixed_vect(%arg0: vector<8xf32>, %arg1: vector<4xf32>, %arg2: vector<[4]xf32>) {404 // CHECK: = llvm.intr.vector.insert {{.*}} : vector<8xf32> into vector<[4]xf32>405 %0 = llvm.intr.vector.insert %arg0, %arg2[0] : vector<8xf32> into vector<[4]xf32>406 // CHECK: = llvm.intr.vector.insert {{.*}} : vector<4xf32> into vector<[4]xf32>407 %1 = llvm.intr.vector.insert %arg1, %arg2[0] : vector<4xf32> into vector<[4]xf32>408 // CHECK: = llvm.intr.vector.insert {{.*}} : vector<4xf32> into vector<[4]xf32>409 %2 = llvm.intr.vector.insert %arg1, %1[4] : vector<4xf32> into vector<[4]xf32>410 // CHECK: = llvm.intr.vector.insert {{.*}} : vector<4xf32> into vector<8xf32>411 %3 = llvm.intr.vector.insert %arg1, %arg0[4] : vector<4xf32> into vector<8xf32>412 // CHECK: = llvm.intr.vector.extract {{.*}} : vector<8xf32> from vector<[4]xf32>413 %4 = llvm.intr.vector.extract %2[0] : vector<8xf32> from vector<[4]xf32>414 // CHECK: = llvm.intr.vector.extract {{.*}} : vector<2xf32> from vector<8xf32>415 %5 = llvm.intr.vector.extract %arg0[6] : vector<2xf32> from vector<8xf32>416 return417}418 419// CHECK-LABEL: @vector_interleave2420func.func @vector_interleave2(%vec1: vector<[4]xf16>, %vec2 : vector<[4]xf16>) {421 // CHECK: = "llvm.intr.vector.interleave2"({{.*}}) : (vector<[4]xf16>, vector<[4]xf16>) -> vector<[8]xf16>422 %0 = "llvm.intr.vector.interleave2"(%vec1, %vec2) : (vector<[4]xf16>, vector<[4]xf16>) -> vector<[8]xf16>423 return424}425 426// CHECK-LABEL: @vector_deinterleave2427func.func @vector_deinterleave2(%vec: vector<[8]xf16>) {428 // CHECK: = "llvm.intr.vector.deinterleave2"({{.*}}) : (vector<[8]xf16>) -> !llvm.struct<(vector<[4]xf16>, vector<[4]xf16>)>429 %0 = "llvm.intr.vector.deinterleave2"(%vec) : (vector<[8]xf16>) -> !llvm.struct<(vector<[4]xf16>, vector<[4]xf16>)>430 return431}432 433// CHECK-LABEL: @alloca434func.func @alloca(%size : i64) {435 // CHECK: llvm.alloca %{{.*}} x i32 : (i64) -> !llvm.ptr436 llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr)437 // CHECK: llvm.alloca inalloca %{{.*}} x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr438 llvm.alloca inalloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr)439 llvm.return440}441 442// CHECK-LABEL: @null443func.func @null() {444 // CHECK: llvm.mlir.zero : !llvm.ptr445 %0 = llvm.mlir.zero : !llvm.ptr446 llvm.return447}448 449// CHECK-LABEL: @zero450func.func @zero() {451 // CHECK: llvm.mlir.zero : i8452 %0 = llvm.mlir.zero : i8453 llvm.return454}455 456// CHECK-LABEL: @atomic_load457func.func @atomic_load(%ptr : !llvm.ptr) {458 // CHECK: llvm.load %{{.*}} atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> f32459 %0 = llvm.load %ptr atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> f32460 // CHECK: llvm.load volatile %{{.*}} atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr -> f32461 %1 = llvm.load volatile %ptr atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr -> f32462 // CHECK: llvm.load %{{.*}} atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> i128463 %2 = llvm.load %ptr atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> i128464 llvm.return465}466 467// CHECK-LABEL: @atomic_store468func.func @atomic_store(%val : f32, %large_val : i256, %ptr : !llvm.ptr) {469 // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic {alignment = 4 : i64} : f32, !llvm.ptr470 llvm.store %val, %ptr atomic monotonic {alignment = 4 : i64} : f32, !llvm.ptr471 // CHECK: llvm.store volatile %{{.*}}, %{{.*}} atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : f32, !llvm.ptr472 llvm.store volatile %val, %ptr atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : f32, !llvm.ptr473 // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic {alignment = 4 : i64} : i256, !llvm.ptr474 llvm.store %large_val, %ptr atomic monotonic {alignment = 4 : i64} : i256, !llvm.ptr475 llvm.return476}477 478// CHECK-LABEL: @atomicrmw479func.func @atomicrmw(%ptr : !llvm.ptr, %f32 : f32, %f16_vec : vector<2xf16>) {480 // CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} monotonic : !llvm.ptr, f32481 %0 = llvm.atomicrmw fadd %ptr, %f32 monotonic : !llvm.ptr, f32482 // CHECK: llvm.atomicrmw volatile fsub %{{.*}}, %{{.*}} syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr, f32483 %1 = llvm.atomicrmw volatile fsub %ptr, %f32 syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr, f32484 // CHECK: llvm.atomicrmw fmin %{{.*}}, %{{.*}} monotonic : !llvm.ptr, vector<2xf16>485 %2 = llvm.atomicrmw fmin %ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>486 llvm.return487}488 489// CHECK-LABEL: @cmpxchg490func.func @cmpxchg(%ptr : !llvm.ptr, %cmp : i32, %new : i32) {491 // CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : !llvm.ptr, i32492 %0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : !llvm.ptr, i32493 // CHECK: llvm.cmpxchg weak volatile %{{.*}}, %{{.*}}, %{{.*}} syncscope("singlethread") acq_rel monotonic {alignment = 16 : i64} : !llvm.ptr, i32494 %1 = llvm.cmpxchg weak volatile %ptr, %cmp, %new syncscope("singlethread") acq_rel monotonic {alignment = 16 : i64} : !llvm.ptr, i32495 llvm.return496}497 498// CHECK-LABEL: @invariant_load499func.func @invariant_load(%ptr : !llvm.ptr) -> i32 {500 // CHECK: llvm.load %{{.+}} invariant {alignment = 4 : i64} : !llvm.ptr -> i32501 %0 = llvm.load %ptr invariant {alignment = 4 : i64} : !llvm.ptr -> i32502 func.return %0 : i32503}504 505// CHECK-LABEL: @invariant_group_load506func.func @invariant_group_load(%ptr : !llvm.ptr) -> i32 {507 // CHECK: llvm.load %{{.+}} invariant_group {alignment = 4 : i64} : !llvm.ptr -> i32508 %0 = llvm.load %ptr invariant_group {alignment = 4 : i64} : !llvm.ptr -> i32509 func.return %0 : i32510}511 512// CHECK-LABEL: @invariant_group_store513func.func @invariant_group_store(%val: i32, %ptr : !llvm.ptr) {514 // CHECK: llvm.store %{{.+}}, %{{.+}} invariant_group : i32, !llvm.ptr515 llvm.store %val, %ptr invariant_group : i32, !llvm.ptr516 func.return517}518 519llvm.mlir.global external constant @_ZTIi() : !llvm.ptr520llvm.func @bar(!llvm.ptr, !llvm.ptr, !llvm.ptr)521llvm.func @__gxx_personality_v0(...) -> i32522 523// CHECK-LABEL: @invokeLandingpad524llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {525// CHECK: %[[V0:.*]] = llvm.mlir.constant(0 : i32) : i32526// CHECK: %{{.*}} = llvm.mlir.constant(3 : i32) : i32527// CHECK: %[[V1:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8>528// CHECK: %[[V2:.*]] = llvm.mlir.zero : !llvm.ptr529// CHECK: %[[V3:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr530// CHECK: %[[V4:.*]] = llvm.mlir.constant(1 : i32) : i32531// CHECK: %[[V5:.*]] = llvm.alloca %[[V4]] x i8 : (i32) -> !llvm.ptr532// CHECK: %{{.*}} = llvm.invoke @foo(%[[V4]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (i32) -> !llvm.struct<(i32, f64, i32)>533 %0 = llvm.mlir.constant(0 : i32) : i32534 %1 = llvm.mlir.constant(3 : i32) : i32535 %2 = llvm.mlir.constant("\01") : !llvm.array<1 x i8>536 %3 = llvm.mlir.zero : !llvm.ptr537 %4 = llvm.mlir.addressof @_ZTIi : !llvm.ptr538 %5 = llvm.mlir.constant(1 : i32) : i32539 %6 = llvm.alloca %5 x i8 : (i32) -> !llvm.ptr540 %7 = llvm.invoke @foo(%5) to ^bb2 unwind ^bb1 : (i32) -> !llvm.struct<(i32, f64, i32)>541 542// CHECK: ^[[BB1]]:543// CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[V2]] : !llvm.ptr) (catch %[[V3]] : !llvm.ptr) (filter %[[V1]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>544// CHECK: %{{.*}} = llvm.intr.eh.typeid.for %[[V3]] : (!llvm.ptr) -> i32545// CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr, i32)>546^bb1:547 %10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr) (catch %4 : !llvm.ptr) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr, i32)>548 %11 = llvm.intr.eh.typeid.for %4 : (!llvm.ptr) -> i32549 llvm.resume %10 : !llvm.struct<(ptr, i32)>550 551// CHECK: ^[[BB2]]:552// CHECK: llvm.return %[[V4]] : i32553^bb2:554 llvm.return %5 : i32555 556// CHECK: ^[[BB3:.*]]:557// CHECK: llvm.invoke @bar(%[[V5]], %[[V3]], %[[V2]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()558^bb3:559 llvm.invoke @bar(%6, %4, %3) to ^bb2 unwind ^bb1 : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()560 561// CHECK: ^[[BB4:.*]]:562// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr563// CHECK: %{{.*}} = llvm.invoke %[[FUNC]]{{.*}}: !llvm.ptr,564^bb4:565 %12 = llvm.mlir.addressof @foo : !llvm.ptr566 %13 = llvm.invoke %12(%5) to ^bb2 unwind ^bb1 : !llvm.ptr, (i32) -> !llvm.struct<(i32, f64, i32)>567 568// CHECK: ^[[BB5:.*]]:569// CHECK: %{{.*}} = llvm.invoke @{{.*}} vararg(!llvm.func<struct<(i32, f64, i32)> (i32, ...)>) : (i32, i32) -> !llvm.struct<(i32, f64, i32)>570 571^bb5:572 %14 = llvm.invoke @vararg_foo(%5, %5) to ^bb2 unwind ^bb1 vararg(!llvm.func<struct<(i32, f64, i32)> (i32, ...)>) : (i32, i32) -> !llvm.struct<(i32, f64, i32)>573 574// CHECK: ^[[BB6:.*]]:575// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @vararg_foo : !llvm.ptr576// CHECK: %{{.*}} = llvm.invoke %[[FUNC]]{{.*}} vararg(!llvm.func<struct<(i32, f64, i32)> (i32, ...)>) : !llvm.ptr, (i32, i32) -> !llvm.struct<(i32, f64, i32)>577^bb6:578 %15 = llvm.mlir.addressof @vararg_foo : !llvm.ptr579 %16 = llvm.invoke %15(%5, %5) to ^bb2 unwind ^bb1 vararg(!llvm.func<!llvm.struct<(i32, f64, i32)> (i32, ...)>) : !llvm.ptr, (i32, i32) -> !llvm.struct<(i32, f64, i32)>580 581// CHECK: ^[[BB7:.*]]:582// CHECK: llvm.return %[[V0]] : i32583^bb7:584 llvm.return %0 : i32585}586 587// CHECK-LABEL: @useFreezeOp588func.func @useFreezeOp(%arg0: i32) {589 // CHECK: = llvm.freeze %[[ARG0:.*]] : i32590 %0 = llvm.freeze %arg0 : i32591 // CHECK: %[[UNDEF:.*]] = llvm.mlir.undef : i8592 %1 = llvm.mlir.undef : i8593 // CHECK: = llvm.freeze %[[UNDEF]] : i8594 %2 = llvm.freeze %1 : i8595 // CHECK: %[[POISON:.*]] = llvm.mlir.poison : i8596 %3 = llvm.mlir.poison : i8597 // CHECK: = llvm.freeze %[[POISON]] : i8598 %4 = llvm.freeze %3 : i8599 return600}601 602// CHECK-LABEL: @useFenceInst603func.func @useFenceInst() {604 // CHECK: syncscope("agent") seq_cst605 llvm.fence syncscope("agent") seq_cst606 // CHECK: seq_cst607 llvm.fence syncscope("") seq_cst608 // CHECK: release609 llvm.fence release610 return611}612 613// CHECK-LABEL: @useInlineAsm614llvm.func @useInlineAsm(%arg0: i32) {615 // CHECK: llvm.inline_asm {{.*}} (i32) -> i8616 %0 = llvm.inline_asm "bswap $0", "=r,r" %arg0 : (i32) -> i8617 618 // CHECK-NEXT: llvm.inline_asm {{.*}} (i32, i32) -> i8619 %1 = llvm.inline_asm "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8620 621 // CHECK-NEXT: llvm.inline_asm has_side_effects {{.*}} (i32, i32) -> i8622 %2 = llvm.inline_asm has_side_effects "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8623 624 // CHECK-NEXT: llvm.inline_asm is_align_stack {{.*}} (i32, i32) -> i8625 %3 = llvm.inline_asm is_align_stack "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8626 627 // CHECK-NEXT: llvm.inline_asm "foo", "=r,=r,r" {{.*}} : (i32) -> !llvm.struct<(i8, i8)>628 %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>629 630 llvm.return631}632 633// CHECK-LABEL: @fastmathFlags634func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: vector<2 x f32>, %arg4: vector<2 x f32>) {635// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32636// CHECK: {{.*}} = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32637// CHECK: {{.*}} = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32638// CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32639// CHECK: {{.*}} = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32640 %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32641 %1 = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32642 %2 = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32643 %3 = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32644 %4 = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32645 646// CHECK: %[[SCALAR_PRED0:.+]] = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32647 %5 = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32648// CHECK: %{{.*}} = llvm.add %[[SCALAR_PRED0]], %[[SCALAR_PRED0]] : i1649 %typecheck_5 = llvm.add %5, %5 : i1650// CHECK: %[[VEC_PRED0:.+]] = llvm.fcmp "oeq" %arg3, %arg4 {fastmathFlags = #llvm.fastmath<fast>} : vector<2xf32>651 %vcmp = llvm.fcmp "oeq" %arg3, %arg4 {fastmathFlags = #llvm.fastmath<fast>} : vector<2xf32>652// CHECK: %{{.*}} = llvm.add %[[VEC_PRED0]], %[[VEC_PRED0]] : vector<2xi1>653 %typecheck_vcmp = llvm.add %vcmp, %vcmp : vector<2xi1>654 655// CHECK: {{.*}} = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32656 %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32657 658// CHECK: {{.*}} = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>659 %7 = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>660 661// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 : f32662 %8 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<none>} : f32663// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32664 %9 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan,ninf>} : f32665 666// CHECK: {{.*}} = llvm.fneg %arg0 : f32667 %10 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<none>} : f32668 669// CHECK: {{.*}} = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32670 %11 = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32671// CHECK: {{.*}} = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> f32672 %12 = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> f32673 674// CHECK: {{.*}} = llvm.intr.vector.reduce.fmin(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32675 %13 = llvm.intr.vector.reduce.fmin(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32676// CHECK: {{.*}} = llvm.intr.vector.reduce.fmax(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32677 %14 = llvm.intr.vector.reduce.fmax(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32678// CHECK: {{.*}} = llvm.intr.vector.reduce.fminimum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32679 %15 = llvm.intr.vector.reduce.fminimum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32680// CHECK: {{.*}} = llvm.intr.vector.reduce.fmaximum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32681 %16 = llvm.intr.vector.reduce.fmaximum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32682 return683}684 685// CHECK-LABEL: @lifetime686// CHECK-SAME: %[[P:.*]]: !llvm.ptr687llvm.func @lifetime(%p: !llvm.ptr) {688 // CHECK: llvm.intr.lifetime.start %[[P]]689 llvm.intr.lifetime.start %p : !llvm.ptr690 // CHECK: llvm.intr.lifetime.end %[[P]]691 llvm.intr.lifetime.end %p : !llvm.ptr692 llvm.return693}694 695// CHECK-LABEL: @invariant696// CHECK-SAME: %[[P:.*]]: !llvm.ptr697llvm.func @invariant(%p: !llvm.ptr) {698 // CHECK: %[[START:.*]] = llvm.intr.invariant.start 1, %[[P]] : !llvm.ptr699 %1 = llvm.intr.invariant.start 1, %p : !llvm.ptr700 // CHECK: llvm.intr.invariant.end %[[START]], 1, %[[P]] : !llvm.ptr701 llvm.intr.invariant.end %1, 1, %p : !llvm.ptr702 llvm.return703}704 705// CHECK-LABEL: @invariant_group_intrinsics706// CHECK-SAME: %[[P:.+]]: !llvm.ptr707llvm.func @invariant_group_intrinsics(%p: !llvm.ptr) {708 // CHECK: %{{.+}} = llvm.intr.launder.invariant.group %[[P]] : !llvm.ptr709 %1 = llvm.intr.launder.invariant.group %p : !llvm.ptr710 // CHECK: %{{.+}} = llvm.intr.strip.invariant.group %[[P]] : !llvm.ptr711 %2 = llvm.intr.strip.invariant.group %p : !llvm.ptr712 llvm.return713}714 715// CHECK-LABEL: @vararg_func716llvm.func @vararg_func(%arg0: i32, ...) {717 // CHECK: %[[C:.*]] = llvm.mlir.constant(1 : i32)718 // CHECK: %[[LIST:.*]] = llvm.alloca719 // CHECK: llvm.intr.vastart %[[LIST]] : !llvm.ptr{{$}}720 %1 = llvm.mlir.constant(1 : i32) : i32721 %list = llvm.alloca %1 x !llvm.struct<"struct.va_list_opaque", (ptr)> : (i32) -> !llvm.ptr722 llvm.intr.vastart %list : !llvm.ptr723 724 // CHECK: %[[LIST2:.*]] = llvm.alloca725 // CHECK: llvm.intr.vacopy %[[LIST]] to %[[LIST2]] : !llvm.ptr, !llvm.ptr{{$}}726 %list2 = llvm.alloca %1 x !llvm.struct<"struct.va_list_opaque", (ptr)> : (i32) -> !llvm.ptr727 llvm.intr.vacopy %list to %list2 : !llvm.ptr, !llvm.ptr728 729 // CHECK: %[[RET:.+]] = llvm.va_arg %[[LIST2]] : (!llvm.ptr) -> i32730 %ret = llvm.va_arg %list2 : (!llvm.ptr) -> i32731 732 // CHECK: llvm.intr.vaend %[[LIST]] : !llvm.ptr{{$}}733 // CHECK: llvm.intr.vaend %[[LIST2]] : !llvm.ptr{{$}}734 llvm.intr.vaend %list : !llvm.ptr735 llvm.intr.vaend %list2 : !llvm.ptr736 llvm.return737}738 739// CHECK-LABEL: @eh_typeid740// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr741llvm.func @eh_typeid(%arg0: !llvm.ptr) -> i32 {742 // CHECK: llvm.intr.eh.typeid.for %[[ARG0]] : (!llvm.ptr) -> i32743 %0 = llvm.intr.eh.typeid.for %arg0 : (!llvm.ptr) -> i32744 llvm.return %0 : i32745}746 747// CHECK-LABEL: @stackrestore748// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr749llvm.func @stackrestore(%arg0: !llvm.ptr) {750 // CHECK: llvm.intr.stackrestore %[[ARG0]] : !llvm.ptr751 llvm.intr.stackrestore %arg0 : !llvm.ptr752 llvm.return753}754 755#alias_scope_domain = #llvm.alias_scope_domain<id = distinct[0]<>, description = "The domain">756#alias_scope = #llvm.alias_scope<id = distinct[0]<>, domain = #alias_scope_domain, description = "The domain">757 758// CHECK-LABEL: @experimental_noalias_scope_decl759llvm.func @experimental_noalias_scope_decl() {760 // CHECK: llvm.intr.experimental.noalias.scope.decl #alias_scope{{.*}}761 llvm.intr.experimental.noalias.scope.decl #alias_scope762 llvm.return763}764 765#alias_scope_domain2 = #llvm.alias_scope_domain<id = "domainid", description = "The domain">766#alias_scope2 = #llvm.alias_scope<id = "stringid", domain = #alias_scope_domain2, description = "The domain">767 768// CHECK-LABEL: @experimental_noalias_scope_with_string_id769llvm.func @experimental_noalias_scope_with_string_id() {770 // CHECK: llvm.intr.experimental.noalias.scope.decl #alias_scope{{.*}}771 llvm.intr.experimental.noalias.scope.decl #alias_scope2772 llvm.return773}774 775// CHECK-LABEL: @experimental_constrained_fptrunc776llvm.func @experimental_constrained_fptrunc(%in: f64) {777 // CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} towardzero ignore : f64 to f32778 %0 = llvm.intr.experimental.constrained.fptrunc %in towardzero ignore : f64 to f32779 // CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} tonearest maytrap : f64 to f32780 %1 = llvm.intr.experimental.constrained.fptrunc %in tonearest maytrap : f64 to f32781 // CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} upward strict : f64 to f32782 %2 = llvm.intr.experimental.constrained.fptrunc %in upward strict : f64 to f32783 // CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} downward ignore : f64 to f32784 %3 = llvm.intr.experimental.constrained.fptrunc %in downward ignore : f64 to f32785 // CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} tonearestaway ignore : f64 to f32786 %4 = llvm.intr.experimental.constrained.fptrunc %in tonearestaway ignore : f64 to f32787 llvm.return788}789 790// CHECK: llvm.func @tail_call_target() -> i32791llvm.func @tail_call_target() -> i32792 793// CHECK-LABEL: @test_none794llvm.func @test_none() -> i32 {795 // CHECK-NEXT: llvm.call @tail_call_target() : () -> i32796 %0 = llvm.call none @tail_call_target() : () -> i32797 llvm.return %0 : i32798}799 800// CHECK-LABEL: @test_default801llvm.func @test_default() -> i32 {802 // CHECK-NEXT: llvm.call @tail_call_target() : () -> i32803 %0 = llvm.call @tail_call_target() : () -> i32804 llvm.return %0 : i32805}806 807// CHECK-LABEL: @test_musttail808llvm.func @test_musttail() -> i32 {809 // CHECK-NEXT: llvm.call musttail @tail_call_target() : () -> i32810 %0 = llvm.call musttail @tail_call_target() : () -> i32811 llvm.return %0 : i32812}813 814// CHECK-LABEL: @test_tail815llvm.func @test_tail() -> i32 {816 // CHECK-NEXT: llvm.call tail @tail_call_target() : () -> i32817 %0 = llvm.call tail @tail_call_target() : () -> i32818 llvm.return %0 : i32819}820 821// CHECK-LABEL: @test_notail822llvm.func @test_notail() -> i32 {823 // CHECK-NEXT: llvm.call notail @tail_call_target() : () -> i32824 %0 = llvm.call notail @tail_call_target() : () -> i32825 llvm.return %0 : i32826}827 828// CHECK-LABEL: @vector_predication_intrinsics829// CHECK-SAME: (%[[ARG0:.*]]: vector<8xi32>, %[[ARG1:.*]]: vector<8xi32>, %[[ARG2:.*]]: vector<8xi1>, %[[ARG3:.*]]: i32)830llvm.func @vector_predication_intrinsics(%A: vector<8xi32>, %B: vector<8xi32>,831 %mask: vector<8xi1>, %evl: i32) {832 // CHECK-NEXT: "llvm.intr.vp.smax"(%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]])833 "llvm.intr.vp.smax" (%A, %B, %mask, %evl) :834 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>835 // CHECK-NEXT: "llvm.intr.vp.smin"(%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]])836 "llvm.intr.vp.smin" (%A, %B, %mask, %evl) :837 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>838 // CHECK-NEXT: "llvm.intr.vp.umax"(%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]])839 "llvm.intr.vp.umax" (%A, %B, %mask, %evl) :840 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>841 // CHECK-NEXT: "llvm.intr.vp.umin"(%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]])842 "llvm.intr.vp.umin" (%A, %B, %mask, %evl) :843 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>844 llvm.return845}846 847llvm.func @op_bundle_target()848 849// CHECK-LABEL: @test_call_with_empty_opbundle850llvm.func @test_call_with_empty_opbundle() {851 // CHECK: llvm.call @op_bundle_target() : () -> ()852 llvm.call @op_bundle_target() [] : () -> ()853 llvm.return854}855 856// CHECK-LABEL: @test_call_with_empty_opbundle_operands857llvm.func @test_call_with_empty_opbundle_operands() {858 // CHECK: llvm.call @op_bundle_target() ["tag"()] : () -> ()859 llvm.call @op_bundle_target() ["tag"()] : () -> ()860 llvm.return861}862 863// CHECK-LABEL: @test_call_with_opbundle864llvm.func @test_call_with_opbundle() {865 %0 = llvm.mlir.constant(0 : i32) : i32866 %1 = llvm.mlir.constant(1 : i32) : i32867 %2 = llvm.mlir.constant(2 : i32) : i32868 // CHECK: llvm.call @op_bundle_target() ["tag1"(%{{.+}}, %{{.+}} : i32, i32), "tag2"(%{{.+}} : i32)] : () -> ()869 llvm.call @op_bundle_target() ["tag1"(%0, %1 : i32, i32), "tag2"(%2 : i32)] : () -> ()870 llvm.return871}872 873// CHECK-LABEL: @test_invoke_with_empty_opbundle874llvm.func @test_invoke_with_empty_opbundle() attributes { personality = @__gxx_personality_v0 } {875 %0 = llvm.mlir.constant(1 : i32) : i32876 %1 = llvm.mlir.constant(2 : i32) : i32877 %2 = llvm.mlir.constant(3 : i32) : i32878 // CHECK: llvm.invoke @op_bundle_target() to ^{{.+}} unwind ^{{.+}} : () -> ()879 llvm.invoke @op_bundle_target() to ^bb2 unwind ^bb1 [] : () -> ()880 881^bb1:882 %3 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>883 llvm.return884 885^bb2:886 llvm.return887}888 889// CHECK-LABEL: @test_invoke_with_empty_opbundle_operands890llvm.func @test_invoke_with_empty_opbundle_operands() attributes { personality = @__gxx_personality_v0 } {891 %0 = llvm.mlir.constant(1 : i32) : i32892 %1 = llvm.mlir.constant(2 : i32) : i32893 %2 = llvm.mlir.constant(3 : i32) : i32894 // CHECK: llvm.invoke @op_bundle_target() to ^{{.+}} unwind ^{{.+}} ["tag"()] : () -> ()895 llvm.invoke @op_bundle_target() to ^bb2 unwind ^bb1 ["tag"()] : () -> ()896 897^bb1:898 %3 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>899 llvm.return900 901^bb2:902 llvm.return903}904 905// CHECK-LABEL: @test_invoke_with_opbundle906llvm.func @test_invoke_with_opbundle() attributes { personality = @__gxx_personality_v0 } {907 %0 = llvm.mlir.constant(1 : i32) : i32908 %1 = llvm.mlir.constant(2 : i32) : i32909 %2 = llvm.mlir.constant(3 : i32) : i32910 // CHECK: llvm.invoke @op_bundle_target() to ^{{.+}} unwind ^{{.+}} ["tag1"(%{{.+}}, %{{.+}} : i32, i32), "tag2"(%{{.+}} : i32)] : () -> ()911 llvm.invoke @op_bundle_target() to ^bb2 unwind ^bb1 ["tag1"(%0, %1 : i32, i32), "tag2"(%2 : i32)] : () -> ()912 913^bb1:914 %3 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>915 llvm.return916 917^bb2:918 llvm.return919}920 921// CHECK-LABEL: @test_call_intrin_with_opbundle922llvm.func @test_call_intrin_with_opbundle(%arg0 : !llvm.ptr) {923 %0 = llvm.mlir.constant(1 : i1) : i1924 %1 = llvm.mlir.constant(16 : i32) : i32925 // CHECK: llvm.call_intrinsic "llvm.assume"(%{{.+}}) ["align"(%{{.+}}, %{{.+}} : !llvm.ptr, i32)] : (i1) -> ()926 llvm.call_intrinsic "llvm.assume"(%0) ["align"(%arg0, %1 : !llvm.ptr, i32)] : (i1) -> ()927 llvm.return928}929 930// CHECK-LABEL: @test_assume_intr_no_opbundle931llvm.func @test_assume_intr_no_opbundle(%arg0 : !llvm.ptr) {932 %0 = llvm.mlir.constant(1 : i1) : i1933 // CHECK: llvm.intr.assume %0 : i1934 llvm.intr.assume %0 : i1935 llvm.return936}937 938// CHECK-LABEL: @test_assume_intr_empty_opbundle939llvm.func @test_assume_intr_empty_opbundle(%arg0 : !llvm.ptr) {940 %0 = llvm.mlir.constant(1 : i1) : i1941 // CHECK: llvm.intr.assume %0 : i1942 llvm.intr.assume %0 [] : i1943 llvm.return944}945 946// CHECK-LABEL: @test_assume_intr_with_opbundles947llvm.func @test_assume_intr_with_opbundles(%arg0 : !llvm.ptr) {948 %0 = llvm.mlir.constant(1 : i1) : i1949 %1 = llvm.mlir.constant(2 : i32) : i32950 %2 = llvm.mlir.constant(3 : i32) : i32951 %3 = llvm.mlir.constant(4 : i32) : i32952 // CHECK: llvm.intr.assume %0 ["tag1"(%1, %2 : i32, i32), "tag2"(%3 : i32)] : i1953 llvm.intr.assume %0 ["tag1"(%1, %2 : i32, i32), "tag2"(%3 : i32)] : i1954 llvm.return955}956 957llvm.func @somefunc(i32, !llvm.ptr)958 959// CHECK-LABEL: llvm.func @test_call_arg_attrs_direct(960// CHECK-SAME: %[[VAL_0:.*]]: i32,961// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr)962llvm.func @test_call_arg_attrs_direct(%arg0: i32, %arg1: !llvm.ptr) {963 // CHECK: llvm.call @somefunc(%[[VAL_0]], %[[VAL_1]]) : (i32, !llvm.ptr {llvm.byval = i64}) -> ()964 llvm.call @somefunc(%arg0, %arg1) : (i32, !llvm.ptr {llvm.byval = i64}) -> ()965 llvm.return966}967 968// CHECK-LABEL: llvm.func @test_call_arg_attrs_indirect(969// CHECK-SAME: %[[VAL_0:.*]]: i16,970// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr971llvm.func @test_call_arg_attrs_indirect(%arg0: i16, %arg1: !llvm.ptr) -> i16 {972 // CHECK: llvm.call tail %[[VAL_1]](%[[VAL_0]]) : !llvm.ptr, (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})973 %0 = llvm.call tail %arg1(%arg0) : !llvm.ptr, (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})974 llvm.return %0 : i16975}976 977// CHECK-LABEL: llvm.func @test_invoke_arg_attrs(978// CHECK-SAME: %[[VAL_0:.*]]: i16) attributes {personality = @__gxx_personality_v0} {979llvm.func @test_invoke_arg_attrs(%arg0: i16) attributes { personality = @__gxx_personality_v0 } {980 // CHECK: llvm.invoke @somefunc(%[[VAL_0]]) to ^bb2 unwind ^bb1 : (i16 {llvm.noundef, llvm.signext}) -> ()981 llvm.invoke @somefunc(%arg0) to ^bb2 unwind ^bb1 : (i16 {llvm.noundef, llvm.signext}) -> ()982^bb1:983 %1 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>984 llvm.return985^bb2:986 llvm.return987}988 989// CHECK-LABEL: llvm.func @test_invoke_arg_attrs_indirect(990// CHECK-SAME: %[[VAL_0:.*]]: i16,991// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> i16 attributes {personality = @__gxx_personality_v0} {992llvm.func @test_invoke_arg_attrs_indirect(%arg0: i16, %arg1: !llvm.ptr) -> i16 attributes { personality = @__gxx_personality_v0 } {993 // CHECK: llvm.invoke %[[VAL_1]](%[[VAL_0]]) to ^bb2 unwind ^bb1 : !llvm.ptr, (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})994 %0 = llvm.invoke %arg1(%arg0) to ^bb2 unwind ^bb1 : !llvm.ptr, (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})995^bb1:996 %1 = llvm.landingpad cleanup : !llvm.struct<(ptr, i32)>997 llvm.return %0 : i16998^bb2:999 llvm.return %0 : i161000}1001 1002// CHECK-LABEL: intrinsic_call_arg_attrs1003llvm.func @intrinsic_call_arg_attrs(%arg0: i32) -> i32 {1004 // CHECK: %{{.*}} = llvm.call_intrinsic "llvm.riscv.sha256sig0"({{.*}}) : (i32 {llvm.signext}) -> i321005 %0 = llvm.call_intrinsic "llvm.riscv.sha256sig0"(%arg0) : (i32 {llvm.signext}) -> (i32)1006 llvm.return %0 : i321007}1008 1009// CHECK-LABEL: intrinsic_call_arg_attrs_bundles1010llvm.func @intrinsic_call_arg_attrs_bundles(%arg0: i32) -> i32 {1011 // CHECK: %{{.*}} = llvm.call_intrinsic "llvm.riscv.sha256sig0"({{.*}}) ["adazdazd"()] {constant} : (i32 {llvm.signext}) -> i321012 %0 = llvm.call_intrinsic "llvm.riscv.sha256sig0"(%arg0) ["adazdazd"()] {constant} : (i32 {llvm.signext}) -> (i32)1013 llvm.return %0 : i321014}1015 1016llvm.mlir.global private @blockaddr_global() {addr_space = 0 : i32, dso_local} : !llvm.ptr {1017 %0 = llvm.blockaddress <function = @blockaddr_fn, tag = <id = 0>> : !llvm.ptr1018 llvm.return %0 : !llvm.ptr1019}1020 1021// CHECK: llvm.mlir.global private @blockaddr_global() {{.*}}1022// CHECK-NEXT: %{{.*}} = llvm.blockaddress <function = @blockaddr_fn, tag = <id = 0>> : !llvm.ptr1023// CHECK-NEXT: llvm.return %{{.*}} : !llvm.ptr1024 1025llvm.func @blockaddr_fn() {1026 llvm.br ^bb11027^bb1:1028 llvm.blocktag <id = 0>1029 llvm.return1030}1031 1032// CHECK-LABEL: llvm.func @blockaddr_fn1033// CHECK-NEXT: llvm.br ^bb11034// CHECK-NEXT:^bb1:1035// CHECK-NEXT: llvm.blocktag <id = 0>1036 1037llvm.func @callintrin_voidret(%arg0: vector<8xi8>, %arg1: vector<8xi8>, %arg2: vector<8xi8>, %arg3: !llvm.ptr) {1038 llvm.call_intrinsic "llvm.aarch64.neon.st3.v8i8.p0"(%arg0, %arg1, %arg2, %arg3) : (vector<8xi8>, vector<8xi8>, vector<8xi8>, !llvm.ptr) -> ()1039 llvm.return1040}1041llvm.func @llvm.aarch64.neon.st3.v8i8.p0(vector<8xi8>, vector<8xi8>, vector<8xi8>, !llvm.ptr)1042 1043// CHECK-LABEL: llvm.func @callintrin_voidret1044// CHECK-NEXT: llvm.call_intrinsic "llvm.aarch64.neon.st3.v8i8.p0"(%arg0, %arg1, %arg2, %arg3) : (vector<8xi8>, vector<8xi8>, vector<8xi8>, !llvm.ptr) -> ()1045 1046llvm.mlir.global internal thread_local unnamed_addr @myglobal(-1 : i32) {addr_space = 0 : i32, alignment = 4 : i64, dso_local} : i321047// CHECK: llvm.mlir.global internal thread_local unnamed_addr @myglobal(-1 : i32) {addr_space = 0 : i32, alignment = 4 : i64, dso_local} : i321048 1049// CHECK-LABEL: llvm.func @escapedtypename1050llvm.func @escapedtypename() {1051 %0 = llvm.mlir.constant(1 : i32) : i321052 // CHECK: llvm.alloca %0 x !llvm.struct<"bucket<string, double, '\\b'>::Iterator", (ptr, i64, i64)>1053 %1 = llvm.alloca %0 x !llvm.struct<"bucket<string, double, '\\b'>::Iterator", (ptr, i64, i64)> {alignment = 8 : i64} : (i32) -> !llvm.ptr1054 llvm.return1055}1056