Update all tests to not use LLVM opts, and generally fix them up; allow fake use emission with disable-O0-optnone

Author: SLTozer

clang/lib/CodeGen/CGDecl.cpp

@@ -1353,6 +1353,11 @@ void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) {
 }
 
 void CodeGenFunction::EmitFakeUse(Address Addr) {
+  // We do not emit a fake use if we want to apply optnone to this function,
+  // even if we might not apply it anyway due to minsize or similar attributes.
+  if (!CGM.getCodeGenOpts().DisableO0ImplyOptNone &&
+      CGM.getCodeGenOpts().OptimizationLevel == 0)
+    return;
   auto NL = ApplyDebugLocation::CreateEmpty(*this);
   llvm::Value *V = Builder.CreateLoad(Addr, "fake.use");
   llvm::CallInst *C = Builder.CreateCall(CGM.getLLVMFakeUseFn(), {V});
@@ -1446,8 +1451,8 @@ static bool extendLifetime(const ASTContext &Context, const Decl *FuncDecl,
   // Don't extend variables that exceed a certain size.
   if (Context.getTypeSize(Ty) > maxFakeUseAggregateSize(Context))
     return false;
-  // Do not extend variables in nodebug functions.
-  if (FuncDecl->hasAttr<NoDebugAttr>())
+  // Do not extend variables in nodebug or optnone functions.
+  if (FuncDecl->hasAttr<NoDebugAttr>() || FuncDecl->hasAttr<OptimizeNoneAttr>())
     return false;
   return true;
 }

clang/test/CodeGen/extend-liveness-except.cpp

@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 %s -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes -fcxx-exceptions -fexceptions -o - | FileCheck %s
+// This test checks that the fake uses can be generated in exception handling
+// blocks and that we can emit fake uses for the __int128 data type.
+
+extern int bar();
+
+/// Try block: fake use ends at try-block scope.
+// [[BAR_VAL::%[a-zA-Z0-9\.]+]] = invoke{{.*}} i32 @_Z3barv()
+// store i32 %[[BAR_VAL]], ptr [[K_ALLOC_VAL:%[a-zA-Z0-9\.]+]], align 4
+// [[K_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr [[K_ALLOC_VAL]], align 4
+// call void (...) @llvm.fake.use(i32 [[K_FAKE_USE]]) #2
+// br label
+
+/// Catch block: fetching the caught value...
+// CHECK: [[CATCH_PTR:%[a-zA-Z0-9\.]+]] = call ptr @__cxa_begin_catch(
+// CHECK: [[L_VAL:%[a-zA-Z0-9\.]+]] = load i32, ptr [[CATCH_PTR]], align 4
+
+/// Storing to allocas...
+// CHECK-DAG: store i32 8, ptr [[M_ALLOC_VAL:%[a-zA-Z0-9\.]+]]
+// CHECK-DAG: store i32 [[L_VAL]], ptr [[L_ALLOC_VAL:%[a-zA-Z0-9\.]+]], align 4
+
+/// Load into fake uses - expect M to precede L.
+// CHECK: [[M_FAKE_VAL:%[a-zA-Z0-9\.]+]] = load i32, ptr [[M_ALLOC_VAL]]
+// CHECK: call void (...) @llvm.fake.use(i32 [[M_FAKE_VAL]])
+// CHECK: [[L_FAKE_VAL:%[a-zA-Z0-9\.]+]] = load i32, ptr [[L_ALLOC_VAL]]
+// CHECK: call void (...) @llvm.fake.use(i32 [[L_FAKE_VAL]])
+void foo() {
+  try {
+    int k = bar();
+  } catch (int l) {
+    /// The catch block contains a fake use for the local within its scope.
+    int m = 8;
+  }
+}

clang/test/CodeGen/extend-liveness-wide-scalar.cpp

@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -disable-O0-optnone -emit-llvm -fextend-lifetimes -triple x86_64-unknown-linux -o - | FileCheck %s
+// REQUIRES: x86-registered-target
+// This test checks that the fake uses can be generated in exception handling
+// blocks and that we can emit fake uses for the __int128 data type.
+
+void bar();
+
+// CHECK: call void (...) @llvm.fake.use(i128 %
+void foo(__int128 wide_int) {
+  bar();
+}

clang/test/CodeGen/extend-liveness1.c

@@ -1,29 +1,29 @@
-// RUN: %clang_cc1 %s -O2 -emit-llvm -fextend-lifetimes -o - | FileCheck %s
+// RUN: %clang_cc1 %s -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes -o - | FileCheck %s --implicit-check-not=llvm.fake.use
 // Check that fake use calls are emitted at the correct locations, i.e.
 // at the end of lexical blocks and at the end of the function.
 
-extern int use(int);
-int glob1;
-int glob2;
-float globf;
+int glob_i;
+char glob_c;
+float glob_f;
 
 int foo(int i) {
-  // CHECK: define{{.*}}foo
+  // CHECK-LABEL: define{{.*}}foo
   if (i < 4) {
-    int j = i * 3;
-    if (glob1 > 3) {
-      float f = globf;
-      // CHECK: [[SSAVAL:%[a-z0-9]*]] = load float{{.*}}globf
+    char j = i * 3;
+    if (glob_i > 3) {
+      float f = glob_f;
       j = f;
-      glob2 = j;
-      // CHECK: store{{.*}}glob2
-      // CHECK-NEXT: call void (...) @llvm.fake.use(float [[SSAVAL]])
+      glob_c = j;
+      // CHECK: call void (...) @llvm.fake.use(float %
+      // CHECK-NEXT: br label %
     }
-    glob1 = j;
-    // CHECK: store{{.*}}glob1
-    // CHECK-NEXT: call void (...) @llvm.fake.use(i32 %j.
+    glob_i = j;
+    // CHECK: call void (...) @llvm.fake.use(i8 %
+    // CHECK-NEXT: br label %
   }
-  // CHECK: call void (...) @llvm.fake.use(i32 %i)
+  // CHECK: call void (...) @llvm.fake.use(i32 %
   // CHECK-NEXT: ret
   return 4;
 }
+
+// CHECK: declare void @llvm.fake.use(...)

clang/test/CodeGen/extend-liveness2.cpp

@@ -1,15 +1,17 @@
-// RUN: %clang -S -O2 -emit-llvm -fextend-lifetimes %s -o - | FileCheck %s
-// REQUIRES: asserts
+// RUN: %clang_cc1 -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes %s -o - | FileCheck %s
 //
 // We are checking that the fake.use calls for i, j and k appear
 // in a particular order. It is not the order itself that is important
 // but that it remains the same between different test runs.
 
-// CHECK:       call {{.*}}void (...) @llvm.fake.use(i32 %k)
-// CHECK-NEXT:  call {{.*}}void (...) @llvm.fake.use(i32 %j)
-// CHECK-NEXT:  call {{.*}}void (...) @llvm.fake.use(i32 %i)
+// CHECK:      [[K_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr %k.addr
+// CHECK-NEXT: call void (...) @llvm.fake.use(i32 [[K_FAKE_USE]]) #2
+// CHECK-NEXT: [[J_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr %j.addr
+// CHECK-NEXT: call void (...) @llvm.fake.use(i32 [[J_FAKE_USE]]) #2
+// CHECK-NEXT: [[I_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr %i.addr
+// CHECK-NEXT: call void (...) @llvm.fake.use(i32 [[I_FAKE_USE]]) #2
 
-extern void bar();
+void bar();
 void foo(int i, int j, int k)
 {
    for (int l = 0; l < i; l++) {

clang/test/CodeGen/fake-use-determinism.c

@@ -27,17 +27,17 @@ int func(int param) {
 // The mangled function name contains a $_0, followed by 'cl'.
 // This lambda is an orphaned lambda, i.e. one without lexical parent.
 //
-// CHECK:     define internal {{.+\"_Z.+\$_0.*cl.*\"}}
-// CHECK-NOT: ret
-// CHECK:     fake.use(i32
-// CHECK-NOT: ret
-// CHECK:     fake.use(ptr
+// CHECK-LABEL: define internal {{.+\"_Z.+\$_0.*cl.*\"}}
+// CHECK-NOT:   ret
+// CHECK:       fake.use(i32
+// CHECK-NOT:   ret
+// CHECK:       fake.use(ptr
 
 // The second lambda. We are looking for 3 fake uses.
-// CHECK:     define internal {{.+\"_Z.+\$_0.*cl.*\"}}
-// CHECK-NOT: ret
-// CHECK:     fake.use(i32
-// CHECK-NOT: ret
-// CHECK:     fake.use(i32
-// CHECK-NOT: ret
-// CHECK:     fake.use(ptr
+// CHECK-LABEL: define internal {{.+\"_Z.+\$_0.*cl.*\"}}
+// CHECK-NOT:   ret
+// CHECK:       fake.use(i32
+// CHECK-NOT:   ret
+// CHECK:       fake.use(i32
+// CHECK-NOT:   ret
+// CHECK:       fake.use(ptr

clang/test/CodeGen/fake-use-lambda.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 %s -O3 -emit-llvm -fextend-lifetimes -fexceptions -o - | FileCheck %s
+// RUN: %clang_cc1 %s -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes -fexceptions -o - | FileCheck %s --implicit-check-not=landingpad
 
 // Check that fake uses do not mistakenly cause a landing pad to be generated when
 // exceptions are enabled.
@@ -11,6 +11,4 @@ void foo(int p) {
 
 // CHECK:      define {{.*}} @foo
 // CHECK-NOT:  personality
-// CHECK:      entry:
-// CHECK:      llvm.fake.use
-// CHECK-NOT:  landingpad
+// CHECK:      call void (...) @llvm.fake.use

clang/test/CodeGen/fake-use-landingpad.c

@@ -1,14 +1,15 @@
-// RUN: %clang %s -S -emit-llvm -fextend-lifetimes -O2 -o - -fno-discard-value-names | FileCheck %s
+// RUN: %clang_cc1 %s -emit-llvm -fextend-lifetimes -O0 -disable-O0-optnone -o - | FileCheck %s
 //
 // Check we can correctly produce fake uses for function-level variables even
 // when we have a return in a nested conditional and there is no code at the end
 // of the function.
 
 // CHECK-LABEL: define{{.*}}@_Z3fooi
-// CHECK:         call{{.*}}llvm.fake.use(i32 %i)
+// CHECK:         [[I_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr %i.addr
+// CHECK:         call void (...) @llvm.fake.use(i32 [[I_FAKE_USE]])
 // CHECK-LABEL: define{{.*}}@_ZN1C3barEi
-// CHECK-DAG:     call{{.*}}llvm.fake.use(i32 %i)
-// CHECK-DAG:     call{{.*}}llvm.fake.use({{.*}}%this)
+// CHECK:         [[J_FAKE_USE:%[a-zA-Z0-9\.]+]] = load i32, ptr %j.addr
+// CHECK:         call void (...) @llvm.fake.use(i32 [[J_FAKE_USE]])
 
 void foo(int i) {
    while (0)
@@ -17,10 +18,10 @@ void foo(int i) {
 }
 
 class C {
-  void bar(int i);
+  void bar(int j);
 };
 
-void C::bar(int i) {
+void C::bar(int j) {
   while (0)
     if (1)
       return;

clang/test/CodeGen/fake-use-noreturn.cpp

@@ -1,11 +1,12 @@
-// RUN: %clang_cc1 -emit-llvm -O2 -debug-info-kind=limited -fextend-lifetimes -o - %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -O0 -disable-O0-optnone -debug-info-kind=limited -fextend-lifetimes -o - %s | FileCheck %s
 
 // Clang adjusts the line numbers of returns based on the line numbers of
 // dominating stores to %retval; we test that fake use intrinsics do not affect
 // this, and the return is given the correct line.
 
 // CHECK: define{{.*}}@main
-// CHECK: ret i32{{.*}}!dbg ![[MDINDEX:[0-9]*]]
+// CHECK: call void (...) @llvm.fake.use(i32
+// CHECK-NEXT: ret i32{{.*}}!dbg ![[MDINDEX:[0-9]*]]
 // CHECK: ![[MDINDEX]] = !DILocation(line: [[# @LINE + 5]]
 int main()
 {

clang/test/CodeGen/fake-use-return-line.c

@@ -1,37 +1,61 @@
-// RUN: %clang_cc1 %s -O1 -emit-llvm -fextend-lifetimes -fsanitize=null -fsanitize-trap=null -o - | FileCheck --check-prefix TRAP %s
-// RUN: %clang_cc1 %s -O1 -emit-llvm -fextend-lifetimes -o - | FileCheck --check-prefix FAKEUSE %s
+// RUN: %clang_cc1 %s -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes -fsanitize=null -fsanitize-trap=null -o - | FileCheck --check-prefixes=CHECK,NULL --implicit-check-not=ubsantrap %s
+// RUN: %clang_cc1 %s -O0 -disable-O0-optnone -emit-llvm -fextend-lifetimes -o - | FileCheck %s
 
-// With -fextend-lifetimes the compiler generated a fake.use of a
-// reference variable at the end of the function, in the cleanup block. This prompted the 
-// address sanitizer to verify that the variable has been allocated properly, even when 
-// the function returns early.
-// We check that sanitizers are disabled for code generated for the benefit of fake.use 
-// intrinsics, as well as that the fake.use is no longer generated in the cleanup block.
-// It should be generated in the block preceding the cleanup block instead.
+// With -fextend-lifetimes, the compiler previously generated a fake.use of any
+// reference variable at the end of the scope in which its alloca exists. This
+// caused two issues, where we would get fake uses for uninitialized variables
+// if that variable was declared after an early-return, and UBSan's null checks
+// would complain about this.
+// This test verifies that UBSan does not produce null-checks for arguments to
+// llvm.fake.use, and that fake uses are not emitted for a variable on paths
+// it has not been declared.
 
 struct A { short s1, s2; };
-extern A& getA();
+extern long& getA();
 
 void foo()
 {
   auto& va = getA();
-  short s = va.s1 & ~va.s2;
-  if (s == 0)
+  if (va < 5)
     return;
 
   auto& vb = getA();
 }
 
-// TRAP:         define{{.*}}foo
-// TRAP:         [[COMPARE:%[^\s]*]] = icmp eq
-// TRAP-NOT:     br i1 [[COMPARE]]{{.*}}trap
-// TRAP:         br i1 [[COMPARE]]{{.*}}%if.end
-// TRAP-NOT:     trap:
-// TRAP:         if.end:
-// TRAP-NOT:     call{{.*}}llvm.trap
-
-// FAKEUSE:      if.end:
-// FAKEUSE-NEXT: [[CALL:%[^\s]*]] = {{.*}}call{{.*}}getA
-// FAKEUSE-NOT:  br{{.*}}cleanup
-// FAKEUSE:      call{{.*}}fake.use({{.*}}[[CALL]])
-// FAKEUSE:      cleanup:
+// CHECK-LABEL:  define{{.*}}foo
+// CHECK:  [[VA_CALL:%.+]] = call{{.*}} ptr @_Z4getAv()
+
+/// We check here for the first UBSan check for "va".
+// NULL:   [[VA_ISNULL:%.+]] = icmp ne ptr [[VA_CALL]], null
+// NULL:   br i1 [[VA_ISNULL]], label %{{[^,]+}}, label %[[VA_TRAP:[^,]+]]
+// NULL: [[VA_TRAP]]:
+// NULL:   call void @llvm.ubsantrap(
+
+// CHECK:       [[VA_PTR:%.+]] = load ptr, ptr %va
+// CHECK-NEXT:  [[VA_CMP:%.+]] = load i64, ptr [[VA_PTR]]
+// CHECK-NEXT:  [[VA_CMP_RES:%.+]] = icmp slt i64 [[VA_CMP]], 5
+// CHECK-NEXT:  br i1 [[VA_CMP_RES]], label %[[EARLY_EXIT:[^,]+]], label %[[NOT_EARLY_EXIT:[^,]+]]
+
+// CHECK: [[EARLY_EXIT]]:
+// CHECK:   br label %cleanup
+
+/// The fake use for "vb" only appears on the path where its declaration is
+/// reached.
+// CHECK:     [[NOT_EARLY_EXIT]]:
+// CHECK:  [[VB_CALL:%.+]] = call{{.*}} ptr @_Z4getAv()
+
+/// We check here for the second UBSan check for "vb".
+// NULL:   [[VB_ISNULL:%.+]] = icmp ne ptr [[VB_CALL]], null
+// NULL:   br i1 [[VB_ISNULL]], label %{{[^,]+}}, label %[[VB_TRAP:[^,]+]]
+// NULL: [[VB_TRAP]]:
+// NULL:   call void @llvm.ubsantrap(
+
+// CHECK:       [[VB_FAKE_USE:%.+]] = load ptr, ptr %vb
+// CHECK-NEXT:  call void (...) @llvm.fake.use(ptr [[VB_FAKE_USE]])
+// CHECK:       br label %cleanup
+
+// CHECK:     cleanup:
+// CHECK:       [[VA_FAKE_USE:%.+]] = load ptr, ptr %va
+// CHECK-NEXT:  call void (...) @llvm.fake.use(ptr [[VA_FAKE_USE]])
+
+// NULL: declare void @llvm.ubsantrap