Lines Matching full:llvm

3 #file = #llvm.di_file<"foo.mlir" in "/foo/">
4 #variable = #llvm.di_local_variable<scope = #file>
5 #variableAddr = #llvm.di_local_variable<scope = #file>
6 #label = #llvm.di_label<scope = #file>
8 func.func @inner_func_inlinable(%ptr : !llvm.ptr) -> i32 {
9   %0 = llvm.mlir.constant(42 : i32) : i32
10   %stack = llvm.intr.stacksave : !llvm.ptr
11   llvm.store %0, %ptr { alignment = 8 } : i32, !llvm.ptr
12   %1 = llvm.load %ptr { alignment = 8 } : !llvm.ptr -> i32
13   llvm.intr.dbg.value #variable = %0 : i32
14   llvm.intr.dbg.declare #variableAddr = %ptr : !llvm.ptr
15   llvm.intr.dbg.label #label
16   %byte = llvm.mlir.constant(43 : i8) : i8
17   %true = llvm.mlir.constant(1 : i1) : i1
18   "llvm.intr.memset"(%ptr, %byte, %0) <{isVolatile = true}> : (!llvm.ptr, i8, i32) -> ()
19   "llvm.intr.memmove"(%ptr, %ptr, %0) <{isVolatile = true}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
20   "llvm.intr.memcpy"(%ptr, %ptr, %0) <{isVolatile = true}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
21   llvm.intr.assume %true : i1
22   llvm.fence release
23   %2 = llvm.atomicrmw add %ptr, %0 monotonic : !llvm.ptr, i32
24   %3 = llvm.cmpxchg %ptr, %0, %1 acq_rel monotonic : !llvm.ptr, i32
25   llvm.inline_asm has_side_effects "foo", "bar" : () -> ()
26   llvm.cond_br %true, ^bb1, ^bb2
28   llvm.unreachable
30   llvm.intr.stackrestore %stack : !llvm.ptr
31   llvm.call_intrinsic "llvm.x86.sse41.round.ss"() : () -> (vector<8xf32>)
37 // CHECK: %[[CST:.*]] = llvm.mlir.constant(42
38 // CHECK: %[[STACK:.+]] = llvm.intr.stacksave
39 // CHECK: llvm.store %[[CST]], %[[PTR]]
40 // CHECK: %[[RES:.+]] = llvm.load %[[PTR]]
41 // CHECK: llvm.intr.dbg.value #{{.+}} = %[[CST]]
42 // CHECK: llvm.intr.dbg.declare #{{.+}} = %[[PTR]]
43 // CHECK: llvm.intr.dbg.label #{{.+}}
44 // CHECK: "llvm.intr.memset"(%[[PTR]]
45 // CHECK: "llvm.intr.memmove"(%[[PTR]], %[[PTR]]
46 // CHECK: "llvm.intr.memcpy"(%[[PTR]], %[[PTR]]
47 // CHECK: llvm.intr.assume
48 // CHECK: llvm.fence release
49 // CHECK: llvm.atomicrmw add %[[PTR]], %[[CST]] monotonic
50 // CHECK: llvm.cmpxchg %[[PTR]], %[[CST]], %[[RES]] acq_rel monotonic
51 // CHECK: llvm.inline_asm has_side_effects "foo", "bar"
52 // CHECK: llvm.unreachable
53 // CHECK: llvm.intr.stackrestore %[[STACK]]
54 // CHECK: llvm.call_intrinsic "llvm.x86.sse41.round.ss"(
55 func.func @test_inline(%ptr : !llvm.ptr) -> i32 {
56   %0 = call @inner_func_inlinable(%ptr) : (!llvm.ptr) -> i32
61 // Check that llvm.return is correctly handled
64   llvm.return %arg0 : i32
77 llvm.func internal fastcc @callee() -> (i32) attributes { function_entry_count = 42 : i64, dso_local } {
78   %0 = llvm.mlir.constant(42 : i32) : i32
79   llvm.return %0 : i32
82 // CHECK-LABEL: llvm.func @caller
83 // CHECK-NEXT: %[[CST:.+]] = llvm.mlir.constant
84 // CHECK-NEXT: llvm.return %[[CST]]
85 llvm.func @caller() -> (i32) {
87   %0 = llvm.call fastcc @callee() { fastmathFlags = #llvm.fastmath<nnan, ninf>, branch_weights = dense<42> : vector<1xi32> } : () -> (i32)
88   llvm.return %0 : i32
93 llvm.func @foo() -> (i32) attributes { no_inline } {
94   %0 = llvm.mlir.constant(0 : i32) : i32
95   llvm.return %0 : i32
98 llvm.func @bar() -> (i32) attributes { no_inline } {
99   %0 = llvm.mlir.constant(1 : i32) : i32
100   llvm.return %0 : i32
103 llvm.func @callee_with_multiple_blocks(%cond: i1) -> (i32) {
104   llvm.cond_br %cond, ^bb1, ^bb2
106   %0 = llvm.call @foo() : () -> (i32)
107   llvm.br ^bb3(%0: i32)
109   %1 = llvm.call @bar() : () -> (i32)
110   llvm.br ^bb3(%1: i32)
112   llvm.return %arg : i32
115 // CHECK-LABEL: llvm.func @caller
116 // CHECK-NEXT: llvm.cond_br {{.+}}, ^[[BB1:.+]], ^[[BB2:.+]]
118 // CHECK-NEXT: llvm.call @foo
119 // CHECK-NEXT: llvm.br ^[[BB3:[a-zA-Z0-9_]+]]
121 // CHECK-NEXT: llvm.call @bar
122 // CHECK-NEXT: llvm.br ^[[BB3]]
124 // CHECK-NEXT: llvm.br ^[[BB4:[a-zA-Z0-9_]+]]
126 // CHECK-NEXT: llvm.return
127 llvm.func @caller(%cond: i1) -> (i32) {
128   %0 = llvm.call @callee_with_multiple_blocks(%cond) : (i1) -> (i32)
129   llvm.return %0 : i32
134 llvm.func @personality() -> i32
136 llvm.func @callee() -> (i32) attributes { personality = @personality } {
137   %0 = llvm.mlir.constant(42 : i32) : i32
138   llvm.return %0 : i32
141 // CHECK-LABEL: llvm.func @caller
142 // CHECK-NEXT: llvm.call @callee
144 llvm.func @caller() -> (i32) {
145   %0 = llvm.call @callee() : () -> (i32)
146   llvm.return %0 : i32
151 llvm.func @callee() attributes { passthrough = ["foo", "bar"] } {
152   llvm.return
155 // CHECK-LABEL: llvm.func @caller
156 // CHECK-NEXT: llvm.return
157 llvm.func @caller() {
158   llvm.call @callee() : () -> ()
159   llvm.return
164 llvm.func @callee_noinline() attributes { no_inline } {
165   llvm.return
168 llvm.func @callee_noduplicate() attributes { passthrough = ["noduplicate"] } {
169   llvm.return
172 llvm.func @callee_presplitcoroutine() attributes { passthrough = ["presplitcoroutine"] } {
173   llvm.return
176 llvm.func @callee_returns_twice() attributes { passthrough = ["returns_twice"] } {
177   llvm.return
180 llvm.func @callee_strictfp() attributes { passthrough = ["strictfp"] } {
181   llvm.return
184 // CHECK-LABEL: llvm.func @caller
185 // CHECK-NEXT: llvm.call @callee_noinline
186 // CHECK-NEXT: llvm.call @callee_noduplicate
187 // CHECK-NEXT: llvm.call @callee_presplitcoroutine
188 // CHECK-NEXT: llvm.call @callee_returns_twice
189 // CHECK-NEXT: llvm.call @callee_strictfp
190 // CHECK-NEXT: llvm.return
191 llvm.func @caller() {
192   llvm.call @callee_noinline() : () -> ()
193   llvm.call @callee_noduplicate() : () -> ()
194   llvm.call @callee_presplitcoroutine() : () -> ()
195   llvm.call @callee_returns_twice() : () -> ()
196   llvm.call @callee_strictfp() : () -> ()
197   llvm.return
202 llvm.func @static_alloca() -> f32 {
203   %0 = llvm.mlir.constant(4 : i32) : i32
204   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
205   %2 = llvm.load %1 : !llvm.ptr -> f32
206   llvm.return %2 : f32
209 llvm.func @dynamic_alloca(%size : i32) -> f32 {
210   %0 = llvm.add %size, %size : i32
211   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
212   %2 = llvm.load %1 : !llvm.ptr -> f32
213   llvm.return %2 : f32
216 // CHECK-LABEL: llvm.func @test_inline
217 llvm.func @test_inline(%cond : i1, %size : i32) -> f32 {
221   // CHECK-NEXT: llvm.mlir.constant
222   // CHECK-NEXT: llvm.alloca
223   // CHECK: llvm.cond_br
224   llvm.cond_br %cond, ^bb1, ^bb2
227   // CHECK-NOT: llvm.call @static_alloca
228   // CHECK: llvm.intr.lifetime.start
229   %0 = llvm.call @static_alloca() : () -> f32
230   // CHECK: llvm.intr.lifetime.end
231   // CHECK: llvm.br ^[[BB3:[a-zA-Z0-9_]+]]
232   llvm.br ^bb3(%0: f32)
237   // CHECK: %[[STACK:[a-zA-Z0-9_]+]] = llvm.intr.stacksave
238   // CHECK: llvm.add
239   // CHECK: llvm.alloca
240   // CHECK: llvm.intr.stackrestore %[[STACK]]
241   // CHECK-NOT: llvm.call @dynamic_alloca
242   %1 = llvm.call @dynamic_alloca(%size) : (i32) -> f32
243   // CHECK: llvm.br ^[[BB3]]
244   llvm.br ^bb3(%1: f32)
248   llvm.return %arg : f32
253 llvm.func @static_alloca_not_in_entry(%cond : i1) -> f32 {
254   llvm.cond_br %cond, ^bb1, ^bb2
256   %0 = llvm.mlir.constant(4 : i32) : i32
257   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
258   llvm.br ^bb3(%1: !llvm.ptr)
260   %2 = llvm.mlir.constant(8 : i32) : i32
261   %3 = llvm.alloca %2 x f32 : (i32) -> !llvm.ptr
262   llvm.br ^bb3(%3: !llvm.ptr)
263 ^bb3(%ptr : !llvm.ptr):
264   %4 = llvm.load %ptr : !llvm.ptr -> f32
265   llvm.return %4 : f32
268 // CHECK-LABEL: llvm.func @test_inline
269 llvm.func @test_inline(%cond : i1) -> f32 {
271   // CHECK-NOT: llvm.alloca
272   // CHECK: llvm.cond_br
273   // CHECK: llvm.alloca
274   %0 = llvm.call @static_alloca_not_in_entry(%cond) : (i1) -> f32
275   llvm.return %0 : f32
280 llvm.func @static_alloca(%cond: i1) -> f32 {
281   %0 = llvm.mlir.constant(4 : i32) : i32
282   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
283   llvm.cond_br %cond, ^bb1, ^bb2
285   %2 = llvm.load %1 : !llvm.ptr -> f32
286   llvm.return %2 : f32
288   %3 = llvm.mlir.constant(3.14192 : f32) : f32
289   llvm.return %3 : f32
292 // CHECK-LABEL: llvm.func @test_inline
293 llvm.func @test_inline(%cond0 : i1, %cond1 : i1, %funcArg : f32) -> f32 {
294   // CHECK-NOT: llvm.cond_br
295   // CHECK: %[[PTR:.+]] = llvm.alloca
296   // CHECK: llvm.cond_br %{{.+}}, ^[[BB1:.+]], ^{{.+}}
297   llvm.cond_br %cond0, ^bb1, ^bb2
302   // CHECK-NEXT: llvm.intr.lifetime.start 4, %[[PTR]]
303   %0 = llvm.call @static_alloca(%cond1) : (i1) -> f32
304   // CHECK: llvm.cond_br %{{.+}}, ^[[BB2:.+]], ^[[BB3:.+]]
305   llvm.br ^bb3(%0: f32)
309   // CHECK-NEXT: llvm.load
310   // CHECK-NEXT: llvm.intr.lifetime.end 4, %[[PTR]]
312   // CHECK-NEXT: llvm.intr.lifetime.end 4, %[[PTR]]
314   llvm.br ^bb3(%funcArg: f32)
316   llvm.return %blockArg : f32
321 llvm.func @static_alloca() -> f32 {
322   %0 = llvm.mlir.constant(4 : i32) : i32
323   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
324   %2 = llvm.load %1 : !llvm.ptr -> f32
325   llvm.return %2 : f32
328 // CHECK-LABEL: llvm.func @test_inline
329 llvm.func @test_inline(%cond0 : i1) {
333   // CHECK: %[[ALLOCA:.+]] = llvm.alloca
336     %0 = llvm.call @static_alloca() : () -> f32
337     // CHECK-NEXT: llvm.intr.lifetime.start 4, %[[ALLOCA]]
338     // CHECK-NEXT: %[[RES:.+]] = llvm.load %[[ALLOCA]]
339     // CHECK-NEXT: llvm.intr.lifetime.end 4, %[[ALLOCA]]
345   // CHECK-NOT: llvm.alloca
348     // CHECK: %[[ALLOCA:.+]] = llvm.alloca
349     %0 = llvm.call @static_alloca() : () -> f32
355   // CHECK-NOT: llvm.alloca
358     // CHECK: %[[ALLOCA:.+]] = llvm.alloca
359     %0 = llvm.call @static_alloca() : () -> f32
363   llvm.return
368 llvm.func @alloca_with_lifetime(%cond: i1) -> f32 {
369   %0 = llvm.mlir.constant(4 : i32) : i32
370   %1 = llvm.alloca %0 x f32 : (i32) -> !llvm.ptr
371   llvm.intr.lifetime.start 4, %1 : !llvm.ptr
372   %2 = llvm.load %1 : !llvm.ptr -> f32
373   llvm.intr.lifetime.end 4, %1 : !llvm.ptr
374   %3 = llvm.fadd %2, %2 : f32
375   llvm.return %3 : f32
378 // CHECK-LABEL: llvm.func @test_inline
379 llvm.func @test_inline(%cond0 : i1, %cond1 : i1, %funcArg : f32) -> f32 {
380   // CHECK-NOT: llvm.cond_br
381   // CHECK: %[[PTR:.+]] = llvm.alloca
382   // CHECK: llvm.cond_br %{{.+}}, ^[[BB1:.+]], ^{{.+}}
383   llvm.cond_br %cond0, ^bb1, ^bb2
388   // CHECK: llvm.intr.lifetime.start 4, %[[PTR]]
389   // CHECK-NEXT: llvm.load %[[PTR]]
390   // CHECK-NEXT: llvm.intr.lifetime.end 4, %[[PTR]]
391   // CHECK: llvm.fadd
392   // CHECK-NOT: llvm.intr.lifetime.end
393   %0 = llvm.call @alloca_with_lifetime(%cond1) : (i1) -> f32
394   llvm.br ^bb3(%0: f32)
396   llvm.br ^bb3(%funcArg: f32)
398   llvm.return %blockArg : f32
403 llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) {
404   llvm.return
407 // CHECK-LABEL: llvm.func @test_byval
408 // CHECK-SAME: %[[PTR:[a-zA-Z0-9_]+]]: !llvm.ptr
409 llvm.func @test_byval(%ptr : !llvm.ptr) {
411   // CHECK: %[[ALLOCA:.+]] = llvm.alloca %{{.+}} x f64
412   // CHECK: llvm.br ^[[BB1:[a-zA-Z0-9_]+]]
413   llvm.br ^bb1
416   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[PTR]]
417   llvm.call @with_byval_arg(%ptr) : (!llvm.ptr) -> ()
418   llvm.br ^bb2
420   llvm.return
425 llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects<other = readwrite, argMem = read, inaccessibleMem = readwrite>} {
426   llvm.return
429 // CHECK-LABEL: llvm.func @test_byval_read_only
430 // CHECK-NOT: llvm.call
431 // CHECK-NEXT: llvm.return
432 llvm.func @test_byval_read_only(%ptr : !llvm.ptr) {
433   llvm.call @with_byval_arg(%ptr) : (!llvm.ptr) -> ()
434   llvm.return
439 llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects<other = readwrite, argMem = write, inaccessibleMem = readwrite>} {
440   llvm.return
443 // CHECK-LABEL: llvm.func @test_byval_write_only
444 // CHECK-SAME: %[[PTR:[a-zA-Z0-9_]+]]: !llvm.ptr
445 // CHECK: %[[ALLOCA:.+]] = llvm.alloca %{{.+}} x f64
446 // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[PTR]]
447 llvm.func @test_byval_write_only(%ptr : !llvm.ptr) {
448   llvm.call @with_byval_arg(%ptr) : (!llvm.ptr) -> ()
449   llvm.return
454 llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = read>} {
455   llvm.return
458 // CHECK-LABEL: llvm.func @test_byval_input_aligned
459 // CHECK-SAME: %[[UNALIGNED:[a-zA-Z0-9_]+]]: !llvm.ptr
460 // CHECK-SAME: %[[ALIGNED:[a-zA-Z0-9_]+]]: !llvm.ptr
461 llvm.func @test_byval_input_aligned(%unaligned : !llvm.ptr, %aligned : !llvm.ptr { llvm.align = 16 }) {
463   // CHECK: %[[ALLOCA:.+]] = llvm.alloca %{{.+}} x i16 {alignment = 16
464   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[UNALIGNED]]
465   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
467   llvm.call @aligned_byval_arg(%aligned) : (!llvm.ptr) -> ()
468   llvm.return
473 llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr)
475 llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = read>} {
476   llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> ()
477   llvm.return
480 // CHECK-LABEL: llvm.func @test_byval_realign_alloca
481 llvm.func @test_byval_realign_alloca() {
482   %size = llvm.mlir.constant(4 : i64) : i64
483   // CHECK-NOT: llvm.alloca{{.+}}alignment = 1
484   // CHECK: llvm.alloca {{.+}}alignment = 16 : i64
485   // CHECK-NOT: llvm.intr.memcpy
486   %unaligned = llvm.alloca %size x i16 { alignment = 1 } : (i64) -> !llvm.ptr
487   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
488   llvm.return
497 llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr)
499 llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = read>} {
500   llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> ()
501   llvm.return
504 // CHECK-LABEL: llvm.func @test_exceeds_natural_stack_alignment
505 llvm.func @test_exceeds_natural_stack_alignment() {
506   %size = llvm.mlir.constant(4 : i64) : i64
509   // CHECK-DAG: %[[SRC:[a-zA-Z0-9_]+]] = llvm.alloca{{.+}}alignment = 2
510   // CHECK-DAG: %[[DST:[a-zA-Z0-9_]+]] = llvm.alloca{{.+}}alignment = 16
511   // CHECK: "llvm.intr.memcpy"(%[[DST]], %[[SRC]]
512   %unaligned = llvm.alloca %size x i16 { alignment = 2 } : (i64) -> !llvm.ptr
513   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
514   llvm.return
525 llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr)
527 llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = read>} {
528   llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> ()
529   llvm.return
532 // CHECK-LABEL: llvm.func @test_alignment_exceeded_anyway
533 llvm.func @test_alignment_exceeded_anyway() {
534   %size = llvm.mlir.constant(4 : i64) : i64
538   // CHECK-NOT: llvm.alloca{{.+}}alignment = 1
539   // CHECK: llvm.alloca {{.+}}alignment = 16 : i64
540   // CHECK-NOT: llvm.intr.memcpy
541   %unaligned = llvm.alloca %size x i16 { alignment = 8 } : (i64) -> !llvm.ptr
542   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
543   llvm.return
550 llvm.mlir.global private @unaligned_global(42 : i64) : i64
551 llvm.mlir.global private @aligned_global(42 : i64) { alignment = 64 } : i64
553 llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects<other = read, argMem = read, inaccessibleMem = read>} {
554   llvm.return
557 // CHECK-LABEL: llvm.func @test_byval_global
558 llvm.func @test_byval_global() {
560   // CHECK-DAG: %[[UNALIGNED:.+]] = llvm.mlir.addressof @unaligned_global
561   // CHECK-DAG: %[[ALLOCA:.+]] = llvm.alloca
562   // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[UNALIGNED]]
563   // CHECK-NOT: llvm.alloca
564   %unaligned = llvm.mlir.addressof @unaligned_global : !llvm.ptr
565   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
566   %aligned = llvm.mlir.addressof @aligned_global : !llvm.ptr
567   llvm.call @aligned_byval_arg(%aligned) : (!llvm.ptr) -> ()
568   llvm.return
573 llvm.func @ignored_attrs(%ptr : !llvm.ptr { llvm.inreg, llvm.nocapture, llvm.nofree, llvm.preallocated = i32, llvm.returned, llvm.alignstack = 32 : i64, llvm.writeonly, llvm.noundef, llvm.nonnull }, %x : i32 { llvm.zeroext }) -> (!llvm.ptr { llvm.noundef, llvm.inreg, llvm.nonnull }) {
574   llvm.return %ptr : !llvm.ptr
578 // CHECK-NOT: llvm.call
579 // CHECK-NEXT: llvm.return
580 llvm.func @test_ignored_attrs(%ptr : !llvm.ptr, %x : i32) {
581   llvm.call @ignored_attrs(%ptr, %x) : (!llvm.ptr, i32) -> (!llvm.ptr)
582   llvm.return
587 llvm.func @disallowed_arg_attr(%ptr : !llvm.ptr { llvm.inalloca = i64 }) {
588   llvm.return
592 // CHECK-NEXT: llvm.call
593 llvm.func @test_disallow_arg_attr(%ptr : !llvm.ptr) {
594   llvm.call @disallowed_arg_attr(%ptr) : (!llvm.ptr) -> ()
595   llvm.return
600 #callee = #llvm.access_group<id = distinct[0]<>>
601 #caller = #llvm.access_group<id = distinct[1]<>>
603 llvm.func @inlinee(%ptr : !llvm.ptr) -> i32 {
604   %0 = llvm.load %ptr { access_groups = [#callee] } : !llvm.ptr -> i32
605   llvm.return %0 : i32
608 // CHECK-DAG: #[[$CALLEE:.*]] = #llvm.access_group<id = {{.*}}>
609 // CHECK-DAG: #[[$CALLER:.*]] = #llvm.access_group<id = {{.*}}>
612 // CHECK: llvm.load
614 llvm.func @caller(%ptr : !llvm.ptr) -> i32 {
615   %0 = llvm.call @inlinee(%ptr) { access_groups = [#caller] } : (!llvm.ptr) -> (i32)
616   llvm.return %0 : i32
621 #caller = #llvm.access_group<id = distinct[1]<>>
623 llvm.func @inlinee(%ptr : !llvm.ptr) -> i32 {
624   %0 = llvm.load %ptr : !llvm.ptr -> i32
625   llvm.return %0 : i32
628 // CHECK-DAG: #[[$CALLER:.*]] = #llvm.access_group<id = {{.*}}>
631 // CHECK: llvm.load
633 // CHECK: llvm.store
635 llvm.func @caller(%ptr : !llvm.ptr) -> i32 {
636   %c5 = llvm.mlir.constant(5 : i32) : i32
637   %0 = llvm.call @inlinee(%ptr) { access_groups = [#caller] } : (!llvm.ptr) -> (i32)
638   llvm.store %c5, %ptr { access_groups = [#caller] } : i32, !llvm.ptr
639   llvm.return %0 : i32
644 llvm.func @vararg_func(...) {
645   llvm.return
648 llvm.func @vararg_intrinrics() {
649   %0 = llvm.mlir.constant(1 : i32) : i32
650   %list = llvm.alloca %0 x !llvm.struct<"struct.va_list_opaque", (ptr)> : (i32) -> !llvm.ptr
654   llvm.intr.vastart %list : !llvm.ptr
655   llvm.return
659 llvm.func @caller() {
660   // CHECK-NEXT: llvm.call @vararg_func()
661   llvm.call @vararg_func() vararg(!llvm.func<void (...)>) : () -> ()
662   // CHECK-NEXT: llvm.call @vararg_intrinrics()
663   llvm.call @vararg_intrinrics() : () -> ()
664   llvm.return
669 llvm.func @private_func(%a : i32) -> i32 attributes {sym_visibility = "private"} {
670   llvm.return %a : i32
674 llvm.func @caller(%x : i32) -> i32 {
675   // CHECK-NOT: llvm.call @private_func
676   %z = llvm.call @private_func(%x) : (i32) -> (i32)
677   llvm.return %z : i32
682 llvm.func @unreachable_func(%a : i32) -> i32 {
683   "llvm.intr.trap"() : () -> ()
684   llvm.unreachable
688 llvm.func @caller(%x : i32) -> i32 {
689   // CHECK-NOT: llvm.call @unreachable_func
690   // CHECK: llvm.intr.trap
691   // CHECK: llvm.unreachable
692   %z = llvm.call @unreachable_func(%x) : (i32) -> (i32)
693   llvm.return %z : i32