| // RUN: %clang_cc1 -triple x86_64-linux-gnu -gkey-instructions -gno-column-info -x c++ %s -debug-info-kind=line-tables-only -emit-llvm -o - \ |
| // RUN: | FileCheck %s --check-prefixes=CHECK,CHECK-CXX |
| |
| // RUN: %clang_cc1 -triple x86_64-linux-gnu -gkey-instructions -gno-column-info -x c %s -debug-info-kind=line-tables-only -emit-llvm -o - \ |
| // RUN: | FileCheck %s |
| |
| // Check the stores to `retval` allocas and branches to `return` block are in |
| // the same atom group. They are both rank 1, which could in theory introduce |
| // an extra step in some optimized code. This low risk currently feels an |
| // acceptable for keeping the code a bit simpler (as opposed to adding |
| // scaffolding to make the store rank 2). |
| |
| // Also check that in the case of a single return (no control flow) the |
| // return instruction inherits the atom group of the branch to the return |
| // block when the blocks get folded togather. |
| |
| #ifdef __cplusplus |
| #define nomangle extern "C" |
| #else |
| #define nomangle |
| #endif |
| |
| int g; |
| nomangle float a() { |
| // CHECK: float @a() |
| if (g) |
| // CHECK: if.then: |
| // CHECK-NEXT: %1 = load i32, ptr @g{{.*}}, !dbg [[G2R3:!.*]] |
| // CHECK-NEXT: %conv = sitofp i32 %1 to float{{.*}}, !dbg [[G2R2:!.*]] |
| // CHECK-NEXT: store float %conv, ptr %retval{{.*}}, !dbg [[G2R1:!.*]] |
| // CHECK-NEXT: br label %return{{.*}}, !dbg [[G2R1]] |
| return g; |
| // CHECK: if.end: |
| // CHECK-NEXT: store float 1.000000e+00, ptr %retval{{.*}}, !dbg [[G3R1:!.*]] |
| // CHECK-NEXT: br label %return, !dbg [[G3R1]] |
| |
| // CHECK: return: |
| // CHECK-NEXT: %2 = load float, ptr %retval{{.*}}, !dbg [[G4R2:!.*]] |
| // CHECK-NEXT: ret float %2{{.*}}, !dbg [[G4R1:!.*]] |
| return 1; |
| } |
| |
| // CHECK: void @b() |
| // CHECK: ret void{{.*}}, !dbg [[B_G1R1:!.*]] |
| nomangle void b() { return; } |
| |
| // CHECK: i32 @c() |
| // CHECK: %add = add{{.*}}, !dbg [[C_G1R2:!.*]] |
| // CHECK: ret i32 %add{{.*}}, !dbg [[C_G1R1:!.*]] |
| nomangle int c() { return g + 1; } |
| |
| // NOTE: (return) (g = 1) are two separate atoms. |
| // CHECK: i32 @d() |
| // CHECK: store{{.*}}, !dbg [[D_G2R1:!.*]] |
| // CHECK: ret i32 1{{.*}}, !dbg [[D_G1R1:!.*]] |
| nomangle int d() { return g = 1; } |
| |
| // The implicit return here get the line number of the closing brace; make it |
| // key to match existing behaviour. |
| // CHECK: void @e() |
| // CHECK: ret void, !dbg [[E_G1R1:!.*]] |
| nomangle void e() {} |
| |
| #ifdef __cplusplus |
| // CHECK-CXX: ptr @_Z1fRi |
| int &f(int &r) { |
| // Include ctrl-flow to stop ret value store being elided. |
| if (r) |
| // CHECK-CXX: if.then: |
| // CHECK-CXX-NEXT: %2 = load ptr, ptr %r.addr{{.*}}, !dbg [[F_G2R2:!.*]], !nonnull |
| // CHECK-CXX-NEXT: store ptr %2, ptr %retval{{.*}}, !dbg [[F_G2R1:!.*]] |
| // CHECK-CXX-NEXT: br label %return, !dbg [[F_G2R1:!.*]] |
| return r; |
| |
| // CHECK-CXX: if.end: |
| // CHECK-CXX-NEXT: store ptr @g, ptr %retval{{.*}}, !dbg [[F_G3R1:!.*]] |
| // CHECK-CXX-NEXT: br label %return, !dbg [[F_G3R1:!.*]] |
| // CHECK-CXX: return: |
| // CHECK-CXX-NEXT: %3 = load ptr, ptr %retval{{.*}}, !dbg [[F_G4R2:!.*]] |
| // CHECK-CXX-NEXT: ret ptr %3, !dbg [[F_G4R1:!.*]] |
| return g; |
| } |
| #endif |
| |
| // CHECK: [[G2R3]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 3) |
| // CHECK: [[G2R2]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 2) |
| // CHECK: [[G2R1]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 1) |
| // CHECK: [[G3R1]] = !DILocation({{.*}}, atomGroup: 3, atomRank: 1) |
| // CHECK: [[G4R2]] = !DILocation({{.*}}, atomGroup: 4, atomRank: 2) |
| // CHECK: [[G4R1]] = !DILocation({{.*}}, atomGroup: 4, atomRank: 1) |
| // CHECK: [[B_G1R1]] = !DILocation({{.*}}, atomGroup: 1, atomRank: 1) |
| // CHECK: [[C_G1R2]] = !DILocation({{.*}}, atomGroup: 1, atomRank: 2) |
| // CHECK: [[C_G1R1]] = !DILocation({{.*}}, atomGroup: 1, atomRank: 1) |
| // CHECK: [[D_G2R1]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 1) |
| // CHECK: [[D_G1R1]] = !DILocation({{.*}}, atomGroup: 1, atomRank: 1) |
| // CHECK: [[E_G1R1]] = !DILocation({{.*}}, atomGroup: 1, atomRank: 1) |
| // CHECK-CXX: [[F_G2R2]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 2) |
| // CHECK-CXX: [[F_G2R1]] = !DILocation({{.*}}, atomGroup: 2, atomRank: 1) |
| // CHECK-CXX: [[F_G3R1]] = !DILocation({{.*}}, atomGroup: 3, atomRank: 1) |
| // CHECK-CXX: [[F_G4R2]] = !DILocation({{.*}}, atomGroup: 4, atomRank: 2) |
| // CHECK-CXX: [[F_G4R1]] = !DILocation({{.*}}, atomGroup: 4, atomRank: 1) |
