1 int DefinedInDifferentFile(int *a); 2 // RUN: echo "int DefinedInDifferentFile(int *a) { return *a; }" > %t.extra-source.cpp 3 // RUN: echo "struct S { S(){} ~S(){} };" >> %t.extra-source.cpp 4 // RUN: echo "S glob_array[5];" >> %t.extra-source.cpp 5 6 // RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp | FileCheck -check-prefix=WITHOUT %s 7 // RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address | FileCheck -check-prefix=ASAN %s 8 9 // RUN: echo "fun:*BlacklistedFunction*" > %t.func.blacklist 10 // RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.func.blacklist | FileCheck -check-prefix=BLFUNC %s 11 12 // The blacklist file uses regexps, so escape backslashes, which are common in 13 // Windows paths. 14 // RUN: echo "src:%s" | sed -e 's/\\/\\\\/g' > %t.file.blacklist 15 // RUN: %clang_cc1 -std=c++11 -triple x86_64-apple-darwin -emit-llvm -o - %s -include %t.extra-source.cpp -fsanitize=address -fsanitize-blacklist=%t.file.blacklist | FileCheck -check-prefix=BLFILE %s 16 17 // The sanitize_address attribute should be attached to functions 18 // when AddressSanitizer is enabled, unless no_sanitize_address attribute 19 // is present. 20 21 // Attributes for function defined in different source file: 22 // WITHOUT: DefinedInDifferentFile{{.*}} [[NOATTR:#[0-9]+]] 23 // BLFILE: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] 24 // BLFUNC: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] 25 // ASAN: DefinedInDifferentFile{{.*}} [[WITH:#[0-9]+]] 26 27 // Check that functions generated for global in different source file are 28 // not blacklisted. 29 // WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] 30 // WITHOUT: @__cxx_global_array_dtor{{.*}}[[NOATTR]] 31 // BLFILE: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] 32 // BLFILE: @__cxx_global_array_dtor{{.*}}[[WITH]] 33 // BLFUNC: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] 34 // BLFUNC: @__cxx_global_array_dtor{{.*}}[[WITH]] 35 // ASAN: @__cxx_global_var_init{{.*}}[[WITH:#[0-9]+]] 36 // ASAN: @__cxx_global_array_dtor{{.*}}[[WITH]] 37 38 39 // WITHOUT: NoAddressSafety1{{.*}}) [[NOATTR]] 40 // BLFILE: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] 41 // BLFUNC: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] 42 // ASAN: NoAddressSafety1{{.*}}) [[NOATTR:#[0-9]+]] 43 __attribute__((no_sanitize_address)) 44 int NoAddressSafety1(int *a) { return *a; } 45 46 // WITHOUT: NoAddressSafety2{{.*}}) [[NOATTR]] 47 // BLFILE: NoAddressSafety2{{.*}}) [[NOATTR]] 48 // BLFUNC: NoAddressSafety2{{.*}}) [[NOATTR]] 49 // ASAN: NoAddressSafety2{{.*}}) [[NOATTR]] 50 __attribute__((no_sanitize_address)) 51 int NoAddressSafety2(int *a); 52 int NoAddressSafety2(int *a) { return *a; } 53 54 // WITHOUT: NoAddressSafety3{{.*}}) [[NOATTR]] 55 // BLFILE: NoAddressSafety3{{.*}}) [[NOATTR]] 56 // BLFUNC: NoAddressSafety3{{.*}}) [[NOATTR]] 57 // ASAN: NoAddressSafety3{{.*}}) [[NOATTR]] 58 [[gnu::no_sanitize_address]] 59 int NoAddressSafety3(int *a) { return *a; } 60 61 // WITHOUT: NoAddressSafety4{{.*}}) [[NOATTR]] 62 // BLFILE: NoAddressSafety4{{.*}}) [[NOATTR]] 63 // BLFUNC: NoAddressSafety4{{.*}}) [[NOATTR]] 64 // ASAN: NoAddressSafety4{{.*}}) [[NOATTR]] 65 [[gnu::no_sanitize_address]] 66 int NoAddressSafety4(int *a); 67 int NoAddressSafety4(int *a) { return *a; } 68 69 // WITHOUT: NoAddressSafety5{{.*}}) [[NOATTR]] 70 // BLFILE: NoAddressSafety5{{.*}}) [[NOATTR]] 71 // BLFUNC: NoAddressSafety5{{.*}}) [[NOATTR]] 72 // ASAN: NoAddressSafety5{{.*}}) [[NOATTR]] 73 __attribute__((no_sanitize("address"))) 74 int NoAddressSafety5(int *a) { return *a; } 75 76 // WITHOUT: NoAddressSafety6{{.*}}) [[NOATTR]] 77 // BLFILE: NoAddressSafety6{{.*}}) [[NOATTR]] 78 // BLFUNC: NoAddressSafety6{{.*}}) [[NOATTR]] 79 // ASAN: NoAddressSafety6{{.*}}) [[NOATTR]] 80 __attribute__((no_sanitize("address"))) 81 int NoAddressSafety6(int *a); 82 int NoAddressSafety6(int *a) { return *a; } 83 84 // WITHOUT: AddressSafetyOk{{.*}}) [[NOATTR]] 85 // BLFILE: AddressSafetyOk{{.*}}) [[NOATTR]] 86 // BLFUNC: AddressSafetyOk{{.*}}) [[WITH]] 87 // ASAN: AddressSafetyOk{{.*}}) [[WITH]] 88 int AddressSafetyOk(int *a) { return *a; } 89 90 // WITHOUT: BlacklistedFunction{{.*}}) [[NOATTR]] 91 // BLFILE: BlacklistedFunction{{.*}}) [[NOATTR]] 92 // BLFUNC: BlacklistedFunction{{.*}}) [[NOATTR]] 93 // ASAN: BlacklistedFunction{{.*}}) [[WITH]] 94 int BlacklistedFunction(int *a) { return *a; } 95 96 #define GENERATE_FUNC(name) \ 97 int name(int *a) { return *a; } 98 // WITHOUT: GeneratedFunction{{.*}}) [[NOATTR]] 99 // BLFILE: GeneratedFunction{{.*}}) [[NOATTR]] 100 // BLFUNC: GeneratedFunction{{.*}}) [[WITH]] 101 // ASAN: GeneratedFunction{{.*}}) [[WITH]] 102 GENERATE_FUNC(GeneratedFunction) 103 104 #define GENERATE_NAME(name) name##_generated 105 // WITHOUT: Function_generated{{.*}}) [[NOATTR]] 106 // BLFILE: Function_generated{{.*}}) [[NOATTR]] 107 // BLFUNC: Function_generated{{.*}}) [[WITH]] 108 // ASAN: Function_generated{{.*}}) [[WITH]] 109 int GENERATE_NAME(Function)(int *a) { return *a; } 110 111 // WITHOUT: TemplateAddressSafetyOk{{.*}}) [[NOATTR]] 112 // BLFILE: TemplateAddressSafetyOk{{.*}}) [[NOATTR]] 113 // BLFUNC: TemplateAddressSafetyOk{{.*}}) [[WITH]] 114 // ASAN: TemplateAddressSafetyOk{{.*}}) [[WITH]] 115 template<int i> 116 int TemplateAddressSafetyOk() { return i; } 117 118 // WITHOUT: TemplateNoAddressSafety1{{.*}}) [[NOATTR]] 119 // BLFILE: TemplateNoAddressSafety1{{.*}}) [[NOATTR]] 120 // BLFUNC: TemplateNoAddressSafety1{{.*}}) [[NOATTR]] 121 // ASAN: TemplateNoAddressSafety1{{.*}}) [[NOATTR]] 122 template<int i> 123 __attribute__((no_sanitize_address)) 124 int TemplateNoAddressSafety1() { return i; } 125 126 // WITHOUT: TemplateNoAddressSafety2{{.*}}) [[NOATTR]] 127 // BLFILE: TemplateNoAddressSafety2{{.*}}) [[NOATTR]] 128 // BLFUNC: TemplateNoAddressSafety2{{.*}}) [[NOATTR]] 129 // ASAN: TemplateNoAddressSafety2{{.*}}) [[NOATTR]] 130 template<int i> 131 __attribute__((no_sanitize("address"))) 132 int TemplateNoAddressSafety2() { return i; } 133 134 int force_instance = TemplateAddressSafetyOk<42>() 135 + TemplateNoAddressSafety1<42>() 136 + TemplateNoAddressSafety2<42>(); 137 138 // Check that __cxx_global_var_init* get the sanitize_address attribute. 139 int global1 = 0; 140 int global2 = *(int*)((char*)&global1+1); 141 // WITHOUT: @__cxx_global_var_init{{.*}}[[NOATTR]] 142 // BLFILE: @__cxx_global_var_init{{.*}}[[NOATTR:#[0-9]+]] 143 // BLFUNC: @__cxx_global_var_init{{.*}}[[WITH]] 144 // ASAN: @__cxx_global_var_init{{.*}}[[WITH]] 145 146 // WITHOUT: attributes [[NOATTR]] = { noinline nounwind{{.*}} } 147 148 // BLFILE: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } 149 // BLFILE: attributes [[NOATTR]] = { noinline nounwind{{.*}} } 150 151 // BLFUNC: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } 152 // BLFUNC: attributes [[NOATTR]] = { noinline nounwind{{.*}} } 153 154 // ASAN: attributes [[WITH]] = { noinline nounwind sanitize_address{{.*}} } 155 // ASAN: attributes [[NOATTR]] = { noinline nounwind{{.*}} } 156