1; RUN: llc -mtriple=aarch64-linux-gnu -O0 -stop-after=irtranslator -global-isel -verify-machineinstrs %s -o - 2>&1 | FileCheck %s 2 3; CHECK-LABEL: name: test_trivial_call 4; CHECK: ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp 5; CHECK: BL @trivial_callee, csr_aarch64_aapcs, implicit-def $lr 6; CHECK: ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp 7declare void @trivial_callee() 8define void @test_trivial_call() { 9 call void @trivial_callee() 10 ret void 11} 12 13; CHECK-LABEL: name: test_simple_return 14; CHECK: BL @simple_return_callee, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit-def $x0 15; CHECK: [[RES:%[0-9]+]]:_(s64) = COPY $x0 16; CHECK: $x0 = COPY [[RES]] 17; CHECK: RET_ReallyLR implicit $x0 18declare i64 @simple_return_callee() 19define i64 @test_simple_return() { 20 %res = call i64 @simple_return_callee() 21 ret i64 %res 22} 23 24; CHECK-LABEL: name: test_simple_arg 25; CHECK: [[IN:%[0-9]+]]:_(s32) = COPY $w0 26; CHECK: $w0 = COPY [[IN]] 27; CHECK: BL @simple_arg_callee, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 28; CHECK: RET_ReallyLR 29declare void @simple_arg_callee(i32 %in) 30define void @test_simple_arg(i32 %in) { 31 call void @simple_arg_callee(i32 %in) 32 ret void 33} 34 35; CHECK-LABEL: name: test_indirect_call 36; CHECK: registers: 37; Make sure the register feeding the indirect call is properly constrained. 38; CHECK: - { id: [[FUNC:[0-9]+]], class: gpr64, preferred-register: '' } 39; CHECK: %[[FUNC]]:gpr64(p0) = COPY $x0 40; CHECK: BLR %[[FUNC]](p0), csr_aarch64_aapcs, implicit-def $lr, implicit $sp 41; CHECK: RET_ReallyLR 42define void @test_indirect_call(void()* %func) { 43 call void %func() 44 ret void 45} 46 47; CHECK-LABEL: name: test_multiple_args 48; CHECK: [[IN:%[0-9]+]]:_(s64) = COPY $x0 49; CHECK: [[ANSWER:%[0-9]+]]:_(s32) = G_CONSTANT i32 42 50; CHECK: $w0 = COPY [[ANSWER]] 51; CHECK: $x1 = COPY [[IN]] 52; CHECK: BL @multiple_args_callee, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0, implicit $x1 53; CHECK: RET_ReallyLR 54declare void @multiple_args_callee(i32, i64) 55define void @test_multiple_args(i64 %in) { 56 call void @multiple_args_callee(i32 42, i64 %in) 57 ret void 58} 59 60 61; CHECK-LABEL: name: test_struct_formal 62; CHECK: [[DBL:%[0-9]+]]:_(s64) = COPY $d0 63; CHECK: [[I64:%[0-9]+]]:_(s64) = COPY $x0 64; CHECK: [[I8_C:%[0-9]+]]:_(s32) = COPY $w1 65; CHECK: [[I8:%[0-9]+]]:_(s8) = G_TRUNC [[I8_C]] 66; CHECK: [[ADDR:%[0-9]+]]:_(p0) = COPY $x2 67 68; CHECK: G_STORE [[DBL]](s64), [[ADDR]](p0) :: (store 8 into %ir.addr) 69; CHECK: [[CST1:%[0-9]+]]:_(s64) = G_CONSTANT i64 8 70; CHECK: [[GEP1:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR]], [[CST1]](s64) 71; CHECK: G_STORE [[I64]](s64), [[GEP1]](p0) :: (store 8 into %ir.addr + 8) 72; CHECK: [[CST2:%[0-9]+]]:_(s64) = G_CONSTANT i64 16 73; CHECK: [[GEP2:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR]], [[CST2]](s64) 74; CHECK: G_STORE [[I8]](s8), [[GEP2]](p0) :: (store 1 into %ir.addr + 16, align 8) 75; CHECK: RET_ReallyLR 76define void @test_struct_formal({double, i64, i8} %in, {double, i64, i8}* %addr) { 77 store {double, i64, i8} %in, {double, i64, i8}* %addr 78 ret void 79} 80 81 82; CHECK-LABEL: name: test_struct_return 83; CHECK: [[ADDR:%[0-9]+]]:_(p0) = COPY $x0 84 85; CHECK: [[LD1:%[0-9]+]]:_(s64) = G_LOAD [[ADDR]](p0) :: (load 8 from %ir.addr) 86; CHECK: [[CST1:%[0-9]+]]:_(s64) = G_CONSTANT i64 8 87; CHECK: [[GEP1:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR]], [[CST1]](s64) 88; CHECK: [[LD2:%[0-9]+]]:_(s64) = G_LOAD [[GEP1]](p0) :: (load 8 from %ir.addr + 8) 89; CHECK: [[CST2:%[0-9]+]]:_(s64) = G_CONSTANT i64 16 90; CHECK: [[GEP2:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR]], [[CST2]](s64) 91; CHECK: [[LD3:%[0-9]+]]:_(s32) = G_LOAD [[GEP2]](p0) :: (load 4 from %ir.addr + 16, align 8) 92 93; CHECK: $d0 = COPY [[LD1]](s64) 94; CHECK: $x0 = COPY [[LD2]](s64) 95; CHECK: $w1 = COPY [[LD3]](s32) 96; CHECK: RET_ReallyLR implicit $d0, implicit $x0, implicit $w1 97define {double, i64, i32} @test_struct_return({double, i64, i32}* %addr) { 98 %val = load {double, i64, i32}, {double, i64, i32}* %addr 99 ret {double, i64, i32} %val 100} 101 102; CHECK-LABEL: name: test_arr_call 103; CHECK: %0:_(p0) = COPY $x0 104; CHECK: [[LD1:%[0-9]+]]:_(s64) = G_LOAD %0(p0) :: (load 8 from %ir.addr) 105; CHECK: [[CST1:%[0-9]+]]:_(s64) = G_CONSTANT i64 8 106; CHECK: [[GEP1:%[0-9]+]]:_(p0) = G_PTR_ADD %0, [[CST1]](s64) 107; CHECK: [[LD2:%[0-9]+]]:_(s64) = G_LOAD [[GEP1]](p0) :: (load 8 from %ir.addr + 8) 108; CHECK: [[CST2:%[0-9]+]]:_(s64) = G_CONSTANT i64 16 109; CHECK: [[GEP2:%[0-9]+]]:_(p0) = G_PTR_ADD %0, [[CST2]](s64) 110; CHECK: [[LD3:%[0-9]+]]:_(s64) = G_LOAD [[GEP2]](p0) :: (load 8 from %ir.addr + 16) 111; CHECK: [[CST3:%[0-9]+]]:_(s64) = G_CONSTANT i64 24 112; CHECK: [[GEP3:%[0-9]+]]:_(p0) = G_PTR_ADD %0, [[CST3]](s64) 113; CHECK: [[LD4:%[0-9]+]]:_(s64) = G_LOAD [[GEP3]](p0) :: (load 8 from %ir.addr + 24) 114 115; CHECK: $x0 = COPY [[LD1]](s64) 116; CHECK: $x1 = COPY [[LD2]](s64) 117; CHECK: $x2 = COPY [[LD3]](s64) 118; CHECK: $x3 = COPY [[LD4]](s64) 119; CHECK: BL @arr_callee, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $x0, implicit $x1, implicit $x2, implicit $x3, implicit-def $x0, implicit-def $x1, implicit-def $x2, implicit-def $x3 120; CHECK: [[E0:%[0-9]+]]:_(s64) = COPY $x0 121; CHECK: [[E1:%[0-9]+]]:_(s64) = COPY $x1 122; CHECK: [[E2:%[0-9]+]]:_(s64) = COPY $x2 123; CHECK: [[E3:%[0-9]+]]:_(s64) = COPY $x3 124; CHECK: $x0 = COPY [[E1]] 125declare [4 x i64] @arr_callee([4 x i64]) 126define i64 @test_arr_call([4 x i64]* %addr) { 127 %arg = load [4 x i64], [4 x i64]* %addr 128 %res = call [4 x i64] @arr_callee([4 x i64] %arg) 129 %val = extractvalue [4 x i64] %res, 1 130 ret i64 %val 131} 132 133 134; CHECK-LABEL: name: test_abi_exts_call 135; CHECK: [[VAL:%[0-9]+]]:_(s8) = G_LOAD 136; CHECK: [[VAL_TMP:%[0-9]+]]:_(s32) = G_ANYEXT [[VAL]] 137; CHECK: $w0 = COPY [[VAL_TMP]] 138; CHECK: BL @take_char, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 139; CHECK: [[SVAL:%[0-9]+]]:_(s32) = G_SEXT [[VAL]](s8) 140; CHECK: $w0 = COPY [[SVAL]](s32) 141; CHECK: BL @take_char, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 142; CHECK: [[ZVAL:%[0-9]+]]:_(s32) = G_ZEXT [[VAL]](s8) 143; CHECK: $w0 = COPY [[ZVAL]](s32) 144; CHECK: BL @take_char, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 145declare void @take_char(i8) 146define void @test_abi_exts_call(i8* %addr) { 147 %val = load i8, i8* %addr 148 call void @take_char(i8 %val) 149 call void @take_char(i8 signext %val) 150 call void @take_char(i8 zeroext %val) 151 ret void 152} 153 154; CHECK-LABEL: name: test_zext_in_callee 155; CHECK: bb.1 (%ir-block.0): 156; CHECK: liveins: $x0 157; CHECK: [[COPY:%[0-9]+]]:_(p0) = COPY $x0 158; CHECK: [[LOAD:%[0-9]+]]:_(s8) = G_LOAD [[COPY]](p0) :: (load 1 from %ir.addr) 159; CHECK: ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp 160; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[LOAD]](s8) 161; CHECK: $w0 = COPY [[ZEXT]](s32) 162; CHECK: BL @has_zext_param, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 163; CHECK: ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp 164; CHECK: RET_ReallyLR 165declare void @has_zext_param(i8 zeroext) 166define void @test_zext_in_callee(i8* %addr) { 167 %val = load i8, i8* %addr 168 call void @has_zext_param(i8 %val) 169 ret void 170} 171 172; CHECK-LABEL: name: test_sext_in_callee 173; CHECK: bb.1 (%ir-block.0): 174; CHECK: liveins: $x0 175; CHECK: [[COPY:%[0-9]+]]:_(p0) = COPY $x0 176; CHECK: [[LOAD:%[0-9]+]]:_(s8) = G_LOAD [[COPY]](p0) :: (load 1 from %ir.addr) 177; CHECK: ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp 178; CHECK: [[SEXT:%[0-9]+]]:_(s32) = G_SEXT [[LOAD]](s8) 179; CHECK: $w0 = COPY [[SEXT]](s32) 180; CHECK: BL @has_sext_param, csr_aarch64_aapcs, implicit-def $lr, implicit $sp, implicit $w0 181; CHECK: ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp 182; CHECK: RET_ReallyLR 183declare void @has_sext_param(i8 signext) 184define void @test_sext_in_callee(i8* %addr) { 185 %val = load i8, i8* %addr 186 call void @has_sext_param(i8 %val) 187 ret void 188} 189 190; CHECK-LABEL: name: test_abi_sext_ret 191; CHECK: [[VAL:%[0-9]+]]:_(s8) = G_LOAD 192; CHECK: [[SVAL:%[0-9]+]]:_(s32) = G_SEXT [[VAL]](s8) 193; CHECK: $w0 = COPY [[SVAL]](s32) 194; CHECK: RET_ReallyLR implicit $w0 195define signext i8 @test_abi_sext_ret(i8* %addr) { 196 %val = load i8, i8* %addr 197 ret i8 %val 198} 199 200; CHECK-LABEL: name: test_abi_zext_ret 201; CHECK: [[VAL:%[0-9]+]]:_(s8) = G_LOAD 202; CHECK: [[SVAL:%[0-9]+]]:_(s32) = G_ZEXT [[VAL]](s8) 203; CHECK: $w0 = COPY [[SVAL]](s32) 204; CHECK: RET_ReallyLR implicit $w0 205define zeroext i8 @test_abi_zext_ret(i8* %addr) { 206 %val = load i8, i8* %addr 207 ret i8 %val 208} 209 210; CHECK-LABEL: name: test_stack_slots 211; CHECK: fixedStack: 212; CHECK-DAG: - { id: [[STACK0:[0-9]+]], type: default, offset: 0, size: 8, 213; CHECK-DAG: - { id: [[STACK8:[0-9]+]], type: default, offset: 8, size: 8, 214; CHECK-DAG: - { id: [[STACK16:[0-9]+]], type: default, offset: 16, size: 8, 215; CHECK: [[LHS_ADDR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[STACK0]] 216; CHECK: [[LHS:%[0-9]+]]:_(s64) = G_LOAD [[LHS_ADDR]](p0) :: (invariant load 8 from %fixed-stack.[[STACK0]], align 16) 217; CHECK: [[RHS_ADDR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[STACK8]] 218; CHECK: [[RHS:%[0-9]+]]:_(s64) = G_LOAD [[RHS_ADDR]](p0) :: (invariant load 8 from %fixed-stack.[[STACK8]]) 219; CHECK: [[ADDR_ADDR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[STACK16]] 220; CHECK: [[ADDR:%[0-9]+]]:_(p0) = G_LOAD [[ADDR_ADDR]](p0) :: (invariant load 8 from %fixed-stack.[[STACK16]], align 16) 221; CHECK: [[SUM:%[0-9]+]]:_(s64) = G_ADD [[LHS]], [[RHS]] 222; CHECK: G_STORE [[SUM]](s64), [[ADDR]](p0) 223define void @test_stack_slots([8 x i64], i64 %lhs, i64 %rhs, i64* %addr) { 224 %sum = add i64 %lhs, %rhs 225 store i64 %sum, i64* %addr 226 ret void 227} 228 229; CHECK-LABEL: name: test_call_stack 230; CHECK: [[C42:%[0-9]+]]:_(s64) = G_CONSTANT i64 42 231; CHECK: [[C12:%[0-9]+]]:_(s64) = G_CONSTANT i64 12 232; CHECK: [[PTR:%[0-9]+]]:_(p0) = G_CONSTANT i64 0 233; CHECK: ADJCALLSTACKDOWN 24, 0, implicit-def $sp, implicit $sp 234; CHECK: [[SP:%[0-9]+]]:_(p0) = COPY $sp 235; CHECK: [[C42_OFFS:%[0-9]+]]:_(s64) = G_CONSTANT i64 0 236; CHECK: [[C42_LOC:%[0-9]+]]:_(p0) = G_PTR_ADD [[SP]], [[C42_OFFS]](s64) 237; CHECK: G_STORE [[C42]](s64), [[C42_LOC]](p0) :: (store 8 into stack, align 1) 238; CHECK: [[C12_OFFS:%[0-9]+]]:_(s64) = G_CONSTANT i64 8 239; CHECK: [[C12_LOC:%[0-9]+]]:_(p0) = G_PTR_ADD [[SP]], [[C12_OFFS]](s64) 240; CHECK: G_STORE [[C12]](s64), [[C12_LOC]](p0) :: (store 8 into stack + 8, align 1) 241; CHECK: [[PTR_OFFS:%[0-9]+]]:_(s64) = G_CONSTANT i64 16 242; CHECK: [[PTR_LOC:%[0-9]+]]:_(p0) = G_PTR_ADD [[SP]], [[PTR_OFFS]](s64) 243; CHECK: G_STORE [[PTR]](p0), [[PTR_LOC]](p0) :: (store 8 into stack + 16, align 1) 244; CHECK: BL @test_stack_slots 245; CHECK: ADJCALLSTACKUP 24, 0, implicit-def $sp, implicit $sp 246define void @test_call_stack() { 247 call void @test_stack_slots([8 x i64] undef, i64 42, i64 12, i64* null) 248 ret void 249} 250 251; CHECK-LABEL: name: test_mem_i1 252; CHECK: fixedStack: 253; CHECK-NEXT: - { id: [[SLOT:[0-9]+]], type: default, offset: 0, size: 1, alignment: 16, stack-id: default, 254; CHECK-NEXT: isImmutable: true, 255; CHECK: [[ADDR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[SLOT]] 256; CHECK: {{%[0-9]+}}:_(s1) = G_LOAD [[ADDR]](p0) :: (invariant load 1 from %fixed-stack.[[SLOT]], align 16) 257define void @test_mem_i1([8 x i64], i1 %in) { 258 ret void 259} 260 261; CHECK-LABEL: name: test_128bit_struct 262; CHECK: $x0 = COPY 263; CHECK: $x1 = COPY 264; CHECK: $x2 = COPY 265; CHECK: BL @take_128bit_struct 266define void @test_128bit_struct([2 x i64]* %ptr) { 267 %struct = load [2 x i64], [2 x i64]* %ptr 268 call void @take_128bit_struct([2 x i64]* null, [2 x i64] %struct) 269 ret void 270} 271 272; CHECK-LABEL: name: take_128bit_struct 273; CHECK: {{%.*}}:_(p0) = COPY $x0 274; CHECK: {{%.*}}:_(s64) = COPY $x1 275; CHECK: {{%.*}}:_(s64) = COPY $x2 276define void @take_128bit_struct([2 x i64]* %ptr, [2 x i64] %in) { 277 store [2 x i64] %in, [2 x i64]* %ptr 278 ret void 279} 280 281; CHECK-LABEL: name: test_split_struct 282; CHECK: [[ADDR:%[0-9]+]]:_(p0) = COPY $x0 283; CHECK: [[LO:%[0-9]+]]:_(s64) = G_LOAD %0(p0) :: (load 8 from %ir.ptr) 284; CHECK: [[CST:%[0-9]+]]:_(s64) = G_CONSTANT i64 8 285; CHECK: [[GEP:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR]], [[CST]](s64) 286; CHECK: [[HI:%[0-9]+]]:_(s64) = G_LOAD [[GEP]](p0) :: (load 8 from %ir.ptr + 8) 287 288; CHECK: [[SP:%[0-9]+]]:_(p0) = COPY $sp 289; CHECK: [[CST2:%[0-9]+]]:_(s64) = G_CONSTANT i64 0 290; CHECK: [[GEP2:%[0-9]+]]:_(p0) = G_PTR_ADD [[SP]], [[CST2]](s64) 291; CHECK: G_STORE [[LO]](s64), [[GEP2]](p0) :: (store 8 into stack, align 1) 292; CHECK: [[GEP3:%[0-9]+]]:_(p0) = G_PTR_ADD [[SP]], [[CST]](s64) 293; CHECK: G_STORE [[HI]](s64), [[GEP3]](p0) :: (store 8 into stack + 8, align 1) 294define void @test_split_struct([2 x i64]* %ptr) { 295 %struct = load [2 x i64], [2 x i64]* %ptr 296 call void @take_split_struct([2 x i64]* null, i64 1, i64 2, i64 3, 297 i64 4, i64 5, i64 6, 298 [2 x i64] %struct) 299 ret void 300} 301 302; CHECK-LABEL: name: take_split_struct 303; CHECK: fixedStack: 304; CHECK-DAG: - { id: [[LO_FRAME:[0-9]+]], type: default, offset: 0, size: 8 305; CHECK-DAG: - { id: [[HI_FRAME:[0-9]+]], type: default, offset: 8, size: 8 306 307; CHECK: [[LOPTR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[LO_FRAME]] 308; CHECK: [[LO:%[0-9]+]]:_(s64) = G_LOAD [[LOPTR]](p0) :: (invariant load 8 from %fixed-stack.[[LO_FRAME]], align 16) 309 310; CHECK: [[HIPTR:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[HI_FRAME]] 311; CHECK: [[HI:%[0-9]+]]:_(s64) = G_LOAD [[HIPTR]](p0) :: (invariant load 8 from %fixed-stack.[[HI_FRAME]]) 312define void @take_split_struct([2 x i64]* %ptr, i64, i64, i64, 313 i64, i64, i64, 314 [2 x i64] %in) { 315 store [2 x i64] %in, [2 x i64]* %ptr 316 ret void 317} 318 319%size0type = type { } 320declare %size0type @func.returns.size0.struct() 321 322; CHECK-LABEL: name: call_returns_size0_struct 323; CHECK: bb.1 324; CHECK-NEXT: ADJCALLSTACKDOWN 325; CHECK-NEXT: BL 326; CHECK-NEXT: ADJCALLSTACKUP 327; CHECK-NEXT: RET_ReallyLR 328define void @call_returns_size0_struct() { 329 ; FIXME: Why is this valid IR? 330 %call = call %size0type @func.returns.size0.struct() 331 ret void 332} 333 334declare [0 x i8] @func.returns.size0.array() 335 336; CHECK-LABEL: name: call_returns_size0_array 337; CHECK: bb.1 338; CHECK-NEXT: ADJCALLSTACKDOWN 339; CHECK-NEXT: BL 340; CHECK-NEXT: ADJCALLSTACKUP 341; CHECK-NEXT: RET_ReallyLR 342define void @call_returns_size0_array() { 343 ; FIXME: Why is this valid IR? 344 %call = call [0 x i8] @func.returns.size0.array() 345 ret void 346} 347 348declare [1 x %size0type] @func.returns.array.size0.struct() 349; CHECK-LABEL: name: call_returns_array_size0_struct 350; CHECK: bb.1 351; CHECK-NEXT: ADJCALLSTACKDOWN 352; CHECK-NEXT: BL 353; CHECK-NEXT: ADJCALLSTACKUP 354; CHECK-NEXT: RET_ReallyLR 355define void @call_returns_array_size0_struct() { 356 ; FIXME: Why is this valid IR? 357 %call = call [1 x %size0type] @func.returns.array.size0.struct() 358 ret void 359} 360