[Sanitizer] Fix sanitizer tests without reducing optimization levels

[yln]

Summary

As discussed, these tests are compiled with optimization to mimic real
sanitizer usage [1].

Let's mark relevant functions with noinline so we can continue to
check against the stack traces in the report.

[1] https://reviews.llvm.org/D96198

This reverts commit 04af72c5423eb5ff7c0deba2d08cb46d583bb9d4.

[kcc]

LGTM, thanks for the better fix!

compiler-rt/test/tsan/blacklist2.cpp

 // Test that blacklisted functions are still contained in the stack trace.
 
 // RUN: echo "fun:*Blacklisted_Thread2*" > %t.blacklist
 // RUN: echo "fun:*CallTouchGlobal*" >> %t.blacklist
 
-// RUN: %clangxx_tsan %s -fsanitize-blacklist=%t.blacklist -o %t
+// RUN: %clangxx_tsan -O1 %s -fsanitize-blacklist=%t.blacklist -o %t
 // RUN: %deflake %run %t 2>&1 | FileCheck %s
 #include "test.h"
 
 int Global;
 
 void *Thread1(void *x) {
   barrier_wait(&barrier);
   // CHECK: ThreadSanitizer: data race
   // CHECK: Write of size 4
   // CHECK: #0 Thread1{{.*}}blacklist2.cpp:[[@LINE+1]]
   Global++;
   return NULL;
 }
 
-void TouchGlobal() {
+void TouchGlobal() __attribute__((noinline)) {
   // CHECK: Previous write of size 4
   // CHECK: #0 TouchGlobal{{.*}}blacklist2.cpp:[[@LINE+1]]
   Global--;
 }
 
-void CallTouchGlobal() {
+void CallTouchGlobal() __attribute__((noinline)) {
   // CHECK: #1 CallTouchGlobal{{.*}}blacklist2.cpp:[[@LINE+1]]
   TouchGlobal();
 }
 
 void *Blacklisted_Thread2(void *x) {
   Global--;
   // CHECK: #2 Blacklisted_Thread2{{.*}}blacklist2.cpp:[[@LINE+1]]
   CallTouchGlobal();

compiler-rt/test/tsan/free_race.c

-// RUN: %clang_tsan %s -o %t
+// RUN: %clang_tsan -O1 %s -o %t
 // RUN: %deflake %run %t | FileCheck %s --check-prefix=CHECK-NOZUPP
 // RUN: %env_tsan_opts=suppressions='%s.supp':print_suppressions=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUPP
 
 #include "test.h"
 
 int *mem;
 pthread_mutex_t mtx;
 
 void *Thread1(void *x) {
   pthread_mutex_lock(&mtx);
   free(mem);
   pthread_mutex_unlock(&mtx);
   barrier_wait(&barrier);
   return NULL;
 }
 
-void *Thread2(void *x) {
+void *Thread2(void *x) __attribute__((noinline)) {
   barrier_wait(&barrier);
   pthread_mutex_lock(&mtx);
   mem[0] = 42;
   pthread_mutex_unlock(&mtx);
   return NULL;
 }
 
 int main() {

compiler-rt/test/tsan/longjmp3.cpp

-// RUN: %clang_tsan %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 
 void bar(jmp_buf env) {
   volatile int x = 42;
   longjmp(env, 42);
   x++;
 }
 
 void foo(jmp_buf env) {
   volatile int x = 42;
   bar(env);
   x++;
 }
 
-void badguy() {
+void badguy() __attribute__((noinline)) {
   pthread_mutex_t mtx;
   pthread_mutex_init(&mtx, 0);
   pthread_mutex_lock(&mtx);
   pthread_mutex_destroy(&mtx);
 }
 
-void mymain() {
+void mymain() __attribute__((noinline)) {
   jmp_buf env;
   if (setjmp(env) == 42) {
     badguy();
     return;
   }
   foo(env);
   fprintf(stderr, "FAILED\n");
 }

compiler-rt/test/tsan/longjmp4.cpp

-// RUN: %clang_tsan %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 #include <string.h>
 
 void bar(jmp_buf env) {
   volatile int x = 42;
   jmp_buf env2;
   memcpy(env2, env, sizeof(jmp_buf));
   longjmp(env2, 42);
   x++;
 }
 
 void foo(jmp_buf env) {
   volatile int x = 42;
   bar(env);
   x++;
 }
 
-void badguy() {
+void badguy() __attribute__((noinline)) {
   pthread_mutex_t mtx;
   pthread_mutex_init(&mtx, 0);
   pthread_mutex_lock(&mtx);
   pthread_mutex_destroy(&mtx);
 }
 
-void mymain() {
+void mymain() __attribute__((noinline)) {
   jmp_buf env;
   if (setjmp(env) == 42) {
     badguy();
     return;
   }
   foo(env);
   fprintf(stderr, "FAILED\n");
 }

compiler-rt/test/tsan/race_on_heap.cpp

-// RUN: %clangxx_tsan %s -o %t && %deflake %run %t | FileCheck %s
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include <pthread.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "test.h"
 
 void *Thread1(void *p) {
   *(int*)p = 42;
   return 0;
 }
 
 void *Thread2(void *p) {
   *(int*)p = 44;
   return 0;
 }
 
-void *alloc() {
+void *alloc() __attribute__((noinline)) {
   return malloc(99);
 }
 
 void *AllocThread(void* arg) {
   return alloc();
 }
 
 int main() {

compiler-rt/test/tsan/race_top_suppression.cpp

 // RUN: echo "race_top:TopFunction" > %t.supp
-// RUN: %clangxx_tsan %s -o %t
+// RUN: %clangxx_tsan -O1 %s -o %t
 // RUN: %env_tsan_opts=suppressions='%t.supp' %run %t 2>&1 | FileCheck %s
 // RUN: rm %t.supp
 #include "test.h"
 
 int Global;
 
-void TopFunction(int *p) {
+void TopFunction(int *p) __attribute__((noinline)) {
   *p = 1;
 }
 
 void *Thread(void *x) {
   barrier_wait(&barrier);
   TopFunction(&Global);
   return 0;
 }

compiler-rt/test/tsan/simple_stack.c

 }
 
 void *Thread2(void *x) {
   bar2();
   barrier_wait(&barrier);
   return NULL;
 }
 
-void StartThread(pthread_t *t, void *(*f)(void*)) {
+void __attribute__((noinline)) StartThread(pthread_t *t, void *(*f)(void*)) {
   pthread_create(t, NULL, f, NULL);
 }
 
 int main() {
   barrier_init(&barrier, 2);
   pthread_t t[2];
   StartThread(&t[0], Thread1);
   StartThread(&t[1], Thread2);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
   return 0;
 }
 
-// RUN: %clang_tsan %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
+// RUN: %clang_tsan -O1 %s -o %t && %deflake %run %t 2>&1 | FileCheck %s
 
 // Also check that functions instrumentation can be configured by either driver
 // or legacy flags:
 
-// RUN: %clangxx_tsan %s -o %t -fno-sanitize-thread-func-entry-exit && %deflake %run %t 2>&1 \
+// RUN: %clangxx_tsan -O1 %s -o %t -fno-sanitize-thread-func-entry-exit && %deflake %run %t 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-FUNC-ENTRY-EXIT-OFF %s
-// RUN: %clangxx_tsan %s -o %t -mllvm -tsan-instrument-func-entry-exit=0 && %deflake %run %t 2>&1 \
+// RUN: %clangxx_tsan -O1 %s -o %t -mllvm -tsan-instrument-func-entry-exit=0 && %deflake %run %t 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-FUNC-ENTRY-EXIT-OFF %s
 
 // CHECK:      WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   Write of size 4 at {{.*}} by thread T1:
 // CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack.c:6{{(:10)?}} ({{.*}})
 // CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack.c:11{{(:3)?}} ({{.*}})
 // CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack.c:25{{(:3)?}} ({{.*}})
 // CHECK:        Previous read of size 4 at {{.*}} by thread T2:

compiler-rt/test/tsan/sleep_sync.cpp

-// RUN: %clangxx_tsan %s -o %t && %deflake %run %t | FileCheck %s
+// RUN: %clangxx_tsan -O1 %s -o %t && %deflake %run %t | FileCheck %s
 #include "test.h"
 
 int X = 0;
 
-void MySleep() {
+void MySleep() __attribute__((noinline)) {
   sleep(1);  // the sleep that must appear in the report
 }
 
 void *Thread(void *p) {
   barrier_wait(&barrier);
   MySleep();  // Assume the main thread has done the write.
   X = 42;
   return 0;

compiler-rt/test/ubsan/TestCases/Misc/missing_return.cpp

-// RUN: %clangxx -fsanitize=return %gmlt %s -o %t
+// RUN: %clangxx -fsanitize=return %gmlt %s -O3 -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 // RUN: %env_ubsan_opts=print_stacktrace=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-STACKTRACE
 // Error message does not exact what expected
 // XFAIL: openbsd
 
 // CHECK: missing_return.cpp:[[@LINE+1]]:5: runtime error: execution reached the end of a value-returning function without returning a value
-int f() {
+int f() __attribute__((noinline)) {
 // CHECK-STACKTRACE: #0 {{.*}}f{{.*}}missing_return.cpp:[[@LINE-1]]
 }
 
 int main(int, char **argv) {
   return f();
 }