1 ; RUN: llc -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-I386 %s 2 ; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-X64 %s 3 ; RUN: llc -code-model=kernel -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-KERNEL-X64 %s 4 ; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | FileCheck --check-prefix=DARWIN-X64 %s 5 ; RUN: llc -mtriple=amd64-pc-openbsd < %s -o - | FileCheck --check-prefix=OPENBSD-AMD64 %s 6 ; RUN: llc -mtriple=i386-pc-windows-msvc < %s -o - | FileCheck -check-prefix=MSVC-I386 %s 7 ; RUN: llc -mtriple=x86_64-w64-mingw32 < %s -o - | FileCheck --check-prefix=MINGW-X64 %s 8 ; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=IGNORE_INTRIN %s 9 10 %struct.foo = type { [16 x i8] } 11 %struct.foo.0 = type { [4 x i8] } 12 %struct.pair = type { i32, i32 } 13 %struct.nest = type { %struct.pair, %struct.pair } 14 %struct.vec = type { <4 x i32> } 15 %class.A = type { [2 x i8] } 16 %struct.deep = type { %union.anon } 17 %union.anon = type { %struct.anon } 18 %struct.anon = type { %struct.anon.0 } 19 %struct.anon.0 = type { %union.anon.1 } 20 %union.anon.1 = type { [2 x i8] } 21 %struct.small = type { i8 } 22 %struct.small_char = type { i32, [5 x i8] } 23 24 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 25 26 ; test1a: array of [16 x i8] 27 ; no ssp attribute 28 ; Requires no protector. 29 define void @test1a(i8* %a) { 30 entry: 31 ; LINUX-I386-LABEL: test1a: 32 ; LINUX-I386-NOT: calll __stack_chk_fail 33 ; LINUX-I386: .cfi_endproc 34 35 ; LINUX-X64-LABEL: test1a: 36 ; LINUX-X64-NOT: callq __stack_chk_fail 37 ; LINUX-X64: .cfi_endproc 38 39 ; LINUX-KERNEL-X64-LABEL: test1a: 40 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 41 ; LINUX-KERNEL-X64: .cfi_endproc 42 43 ; DARWIN-X64-LABEL: test1a: 44 ; DARWIN-X64-NOT: callq ___stack_chk_fail 45 ; DARWIN-X64: .cfi_endproc 46 47 ; MSVC-I386-LABEL: test1a: 48 ; MSVC-I386-NOT: calll @__security_check_cookie@4 49 ; MSVC-I386: retl 50 51 ; MINGW-X64-LABEL: test1a: 52 ; MINGW-X64-NOT: callq __stack_chk_fail 53 ; MINGW-X64: .seh_endproc 54 55 %a.addr = alloca i8*, align 8 56 %buf = alloca [16 x i8], align 16 57 store i8* %a, i8** %a.addr, align 8 58 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 59 %0 = load i8*, i8** %a.addr, align 8 60 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 61 %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 62 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 63 ret void 64 } 65 66 ; test1b: array of [16 x i8] 67 ; ssp attribute 68 ; Requires protector. 69 ; Function Attrs: ssp 70 define void @test1b(i8* %a) #0 { 71 entry: 72 ; LINUX-I386-LABEL: test1b: 73 ; LINUX-I386: mov{{l|q}} %gs: 74 ; LINUX-I386: calll __stack_chk_fail 75 76 ; LINUX-X64-LABEL: test1b: 77 ; LINUX-X64: mov{{l|q}} %fs: 78 ; LINUX-X64: callq __stack_chk_fail 79 80 ; LINUX-KERNEL-X64-LABEL: test1b: 81 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 82 ; LINUX-KERNEL-X64: callq __stack_chk_fail 83 84 ; DARWIN-X64-LABEL: test1b: 85 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 86 ; DARWIN-X64: callq ___stack_chk_fail 87 88 ; OPENBSD-AMD64-LABEL: test1b: 89 ; OPENBSD-AMD64: movq __guard_local(%rip) 90 ; OPENBSD-AMD64: callq __stack_smash_handler 91 92 ; MSVC-I386-LABEL: test1b: 93 ; MSVC-I386: movl ___security_cookie, 94 ; MSVC-I386: calll @__security_check_cookie@4 95 96 ; MINGW-X64-LABEL: test1b: 97 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 98 ; MINGW-X64: callq __stack_chk_fail 99 100 %a.addr = alloca i8*, align 8 101 %buf = alloca [16 x i8], align 16 102 store i8* %a, i8** %a.addr, align 8 103 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 104 %0 = load i8*, i8** %a.addr, align 8 105 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 106 %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 107 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 108 ret void 109 } 110 111 ; test1c: array of [16 x i8] 112 ; sspstrong attribute 113 ; Requires protector. 114 ; Function Attrs: sspstrong 115 define void @test1c(i8* %a) #1 { 116 entry: 117 ; LINUX-I386-LABEL: test1c: 118 ; LINUX-I386: mov{{l|q}} %gs: 119 ; LINUX-I386: calll __stack_chk_fail 120 121 ; LINUX-X64-LABEL: test1c: 122 ; LINUX-X64: mov{{l|q}} %fs: 123 ; LINUX-X64: callq __stack_chk_fail 124 125 ; LINUX-KERNEL-X64-LABEL: test1c: 126 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 127 ; LINUX-KERNEL-X64: callq __stack_chk_fail 128 129 ; DARWIN-X64-LABEL: test1c: 130 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 131 ; DARWIN-X64: callq ___stack_chk_fail 132 133 ; MSVC-I386-LABEL: test1c: 134 ; MSVC-I386: movl ___security_cookie, 135 ; MSVC-I386: calll @__security_check_cookie@4 136 137 ; MINGW-X64-LABEL: test1c: 138 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 139 ; MINGW-X64: callq __stack_chk_fail 140 141 %a.addr = alloca i8*, align 8 142 %buf = alloca [16 x i8], align 16 143 store i8* %a, i8** %a.addr, align 8 144 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 145 %0 = load i8*, i8** %a.addr, align 8 146 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 147 %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 148 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 149 ret void 150 } 151 152 ; test1d: array of [16 x i8] 153 ; sspreq attribute 154 ; Requires protector. 155 ; Function Attrs: sspreq 156 define void @test1d(i8* %a) #2 { 157 entry: 158 ; LINUX-I386-LABEL: test1d: 159 ; LINUX-I386: mov{{l|q}} %gs: 160 ; LINUX-I386: calll __stack_chk_fail 161 162 ; LINUX-X64-LABEL: test1d: 163 ; LINUX-X64: mov{{l|q}} %fs: 164 ; LINUX-X64: callq __stack_chk_fail 165 166 ; LINUX-KERNEL-X64-LABEL: test1d: 167 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 168 ; LINUX-KERNEL-X64: callq __stack_chk_fail 169 170 ; DARWIN-X64-LABEL: test1d: 171 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 172 ; DARWIN-X64: callq ___stack_chk_fail 173 174 ; MSVC-I386-LABEL: test1d: 175 ; MSVC-I386: movl ___security_cookie, 176 ; MSVC-I386: calll @__security_check_cookie@4 177 178 ; MINGW-X64-LABEL: test1d: 179 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 180 ; MINGW-X64: callq __stack_chk_fail 181 182 %a.addr = alloca i8*, align 8 183 %buf = alloca [16 x i8], align 16 184 store i8* %a, i8** %a.addr, align 8 185 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 186 %0 = load i8*, i8** %a.addr, align 8 187 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 188 %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 189 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 190 ret void 191 } 192 193 ; test2a: struct { [16 x i8] } 194 ; no ssp attribute 195 ; Requires no protector. 196 define void @test2a(i8* %a) { 197 entry: 198 ; LINUX-I386-LABEL: test2a: 199 ; LINUX-I386-NOT: calll __stack_chk_fail 200 ; LINUX-I386: .cfi_endproc 201 202 ; LINUX-X64-LABEL: test2a: 203 ; LINUX-X64-NOT: callq __stack_chk_fail 204 ; LINUX-X64: .cfi_endproc 205 206 ; LINUX-KERNEL-X64-LABEL: test2a: 207 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 208 ; LINUX-KERNEL-X64: .cfi_endproc 209 210 ; DARWIN-X64-LABEL: test2a: 211 ; DARWIN-X64-NOT: callq ___stack_chk_fail 212 ; DARWIN-X64: .cfi_endproc 213 214 ; MSVC-I386-LABEL: test2a: 215 ; MSVC-I386-NOT: calll @__security_check_cookie@4 216 ; MSVC-I386: retl 217 218 ; MINGW-X64-LABEL: test2a: 219 ; MINGW-X64-NOT: callq __stack_chk_fail 220 ; MINGW-X64: .seh_endproc 221 222 %a.addr = alloca i8*, align 8 223 %b = alloca %struct.foo, align 1 224 store i8* %a, i8** %a.addr, align 8 225 %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 226 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 227 %0 = load i8*, i8** %a.addr, align 8 228 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 229 %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 230 %arraydecay2 = getelementptr inbounds [16 x i8], [16 x i8]* %buf1, i32 0, i32 0 231 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 232 ret void 233 } 234 235 ; test2b: struct { [16 x i8] } 236 ; ssp attribute 237 ; Requires protector. 238 ; Function Attrs: ssp 239 define void @test2b(i8* %a) #0 { 240 entry: 241 ; LINUX-I386-LABEL: test2b: 242 ; LINUX-I386: mov{{l|q}} %gs: 243 ; LINUX-I386: calll __stack_chk_fail 244 245 ; LINUX-X64-LABEL: test2b: 246 ; LINUX-X64: mov{{l|q}} %fs: 247 ; LINUX-X64: callq __stack_chk_fail 248 249 ; LINUX-KERNEL-X64-LABEL: test2b: 250 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 251 ; LINUX-KERNEL-X64: callq __stack_chk_fail 252 253 ; DARWIN-X64-LABEL: test2b: 254 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 255 ; DARWIN-X64: callq ___stack_chk_fail 256 257 ; MINGW-X64-LABEL: test2b: 258 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 259 ; MINGW-X64: callq __stack_chk_fail 260 261 %a.addr = alloca i8*, align 8 262 %b = alloca %struct.foo, align 1 263 store i8* %a, i8** %a.addr, align 8 264 %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 265 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 266 %0 = load i8*, i8** %a.addr, align 8 267 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 268 %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 269 %arraydecay2 = getelementptr inbounds [16 x i8], [16 x i8]* %buf1, i32 0, i32 0 270 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 271 ret void 272 } 273 274 ; test2c: struct { [16 x i8] } 275 ; sspstrong attribute 276 ; Requires protector. 277 ; Function Attrs: sspstrong 278 define void @test2c(i8* %a) #1 { 279 entry: 280 ; LINUX-I386-LABEL: test2c: 281 ; LINUX-I386: mov{{l|q}} %gs: 282 ; LINUX-I386: calll __stack_chk_fail 283 284 ; LINUX-X64-LABEL: test2c: 285 ; LINUX-X64: mov{{l|q}} %fs: 286 ; LINUX-X64: callq __stack_chk_fail 287 288 ; LINUX-KERNEL-X64-LABEL: test2c: 289 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 290 ; LINUX-KERNEL-X64: callq __stack_chk_fail 291 292 ; DARWIN-X64-LABEL: test2c: 293 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 294 ; DARWIN-X64: callq ___stack_chk_fail 295 296 ; MSVC-I386-LABEL: test2c: 297 ; MSVC-I386: movl ___security_cookie, 298 ; MSVC-I386: calll @__security_check_cookie@4 299 300 ; MINGW-X64-LABEL: test2c: 301 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 302 ; MINGW-X64: callq __stack_chk_fail 303 304 %a.addr = alloca i8*, align 8 305 %b = alloca %struct.foo, align 1 306 store i8* %a, i8** %a.addr, align 8 307 %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 308 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 309 %0 = load i8*, i8** %a.addr, align 8 310 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 311 %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 312 %arraydecay2 = getelementptr inbounds [16 x i8], [16 x i8]* %buf1, i32 0, i32 0 313 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 314 ret void 315 } 316 317 ; test2d: struct { [16 x i8] } 318 ; sspreq attribute 319 ; Requires protector. 320 ; Function Attrs: sspreq 321 define void @test2d(i8* %a) #2 { 322 entry: 323 ; LINUX-I386-LABEL: test2d: 324 ; LINUX-I386: mov{{l|q}} %gs: 325 ; LINUX-I386: calll __stack_chk_fail 326 327 ; LINUX-X64-LABEL: test2d: 328 ; LINUX-X64: mov{{l|q}} %fs: 329 ; LINUX-X64: callq __stack_chk_fail 330 331 ; LINUX-KERNEL-X64-LABEL: test2d: 332 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 333 ; LINUX-KERNEL-X64: callq __stack_chk_fail 334 335 ; DARWIN-X64-LABEL: test2d: 336 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 337 ; DARWIN-X64: callq ___stack_chk_fail 338 339 ; MSVC-I386-LABEL: test2d: 340 ; MSVC-I386: movl ___security_cookie, 341 ; MSVC-I386: calll @__security_check_cookie@4 342 343 ; MINGW-X64-LABEL: test2d: 344 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 345 ; MINGW-X64: callq __stack_chk_fail 346 347 %a.addr = alloca i8*, align 8 348 %b = alloca %struct.foo, align 1 349 store i8* %a, i8** %a.addr, align 8 350 %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 351 %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0 352 %0 = load i8*, i8** %a.addr, align 8 353 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 354 %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0 355 %arraydecay2 = getelementptr inbounds [16 x i8], [16 x i8]* %buf1, i32 0, i32 0 356 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 357 ret void 358 } 359 360 ; test3a: array of [4 x i8] 361 ; no ssp attribute 362 ; Requires no protector. 363 define void @test3a(i8* %a) { 364 entry: 365 ; LINUX-I386-LABEL: test3a: 366 ; LINUX-I386-NOT: calll __stack_chk_fail 367 ; LINUX-I386: .cfi_endproc 368 369 ; LINUX-X64-LABEL: test3a: 370 ; LINUX-X64-NOT: callq __stack_chk_fail 371 ; LINUX-X64: .cfi_endproc 372 373 ; LINUX-KERNEL-X64-LABEL: test3a: 374 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 375 ; LINUX-KERNEL-X64: .cfi_endproc 376 377 ; DARWIN-X64-LABEL: test3a: 378 ; DARWIN-X64-NOT: callq ___stack_chk_fail 379 ; DARWIN-X64: .cfi_endproc 380 381 ; MSVC-I386-LABEL: test3a: 382 ; MSVC-I386-NOT: calll @__security_check_cookie@4 383 ; MSVC-I386: retl 384 385 ; MINGW-X64-LABEL: test3a: 386 ; MINGW-X64-NOT: callq __stack_chk_fail 387 ; MINGW-X64: .seh_endproc 388 389 %a.addr = alloca i8*, align 8 390 %buf = alloca [4 x i8], align 1 391 store i8* %a, i8** %a.addr, align 8 392 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 393 %0 = load i8*, i8** %a.addr, align 8 394 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 395 %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 396 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 397 ret void 398 } 399 400 ; test3b: array [4 x i8] 401 ; ssp attribute 402 ; Requires no protector. 403 ; Function Attrs: ssp 404 define void @test3b(i8* %a) #0 { 405 entry: 406 ; LINUX-I386-LABEL: test3b: 407 ; LINUX-I386-NOT: calll __stack_chk_fail 408 ; LINUX-I386: .cfi_endproc 409 410 ; LINUX-X64-LABEL: test3b: 411 ; LINUX-X64-NOT: callq __stack_chk_fail 412 ; LINUX-X64: .cfi_endproc 413 414 ; LINUX-KERNEL-X64-LABEL: test3b: 415 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 416 ; LINUX-KERNEL-X64: .cfi_endproc 417 418 ; DARWIN-X64-LABEL: test3b: 419 ; DARWIN-X64-NOT: callq ___stack_chk_fail 420 ; DARWIN-X64: .cfi_endproc 421 422 ; MSVC-I386-LABEL: test3b: 423 ; MSVC-I386-NOT: calll @__security_check_cookie@4 424 ; MSVC-I386: retl 425 426 ; MINGW-X64-LABEL: test3b: 427 ; MINGW-X64-NOT: callq __stack_chk_fail 428 ; MINGW-X64: .seh_endproc 429 430 %a.addr = alloca i8*, align 8 431 %buf = alloca [4 x i8], align 1 432 store i8* %a, i8** %a.addr, align 8 433 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 434 %0 = load i8*, i8** %a.addr, align 8 435 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 436 %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 437 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 438 ret void 439 } 440 441 ; test3c: array of [4 x i8] 442 ; sspstrong attribute 443 ; Requires protector. 444 ; Function Attrs: sspstrong 445 define void @test3c(i8* %a) #1 { 446 entry: 447 ; LINUX-I386-LABEL: test3c: 448 ; LINUX-I386: mov{{l|q}} %gs: 449 ; LINUX-I386: calll __stack_chk_fail 450 451 ; LINUX-X64-LABEL: test3c: 452 ; LINUX-X64: mov{{l|q}} %fs: 453 ; LINUX-X64: callq __stack_chk_fail 454 455 ; LINUX-KERNEL-X64-LABEL: test3c: 456 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 457 ; LINUX-KERNEL-X64: callq __stack_chk_fail 458 459 ; DARWIN-X64-LABEL: test3c: 460 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 461 ; DARWIN-X64: callq ___stack_chk_fail 462 463 ; MSVC-I386-LABEL: test3c: 464 ; MSVC-I386: movl ___security_cookie, 465 ; MSVC-I386: calll @__security_check_cookie@4 466 467 ; MINGW-X64-LABEL: test3c: 468 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 469 ; MINGW-X64: callq __stack_chk_fail 470 471 %a.addr = alloca i8*, align 8 472 %buf = alloca [4 x i8], align 1 473 store i8* %a, i8** %a.addr, align 8 474 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 475 %0 = load i8*, i8** %a.addr, align 8 476 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 477 %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 478 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 479 ret void 480 } 481 482 ; test3d: array of [4 x i8] 483 ; sspreq attribute 484 ; Requires protector. 485 ; Function Attrs: sspreq 486 define void @test3d(i8* %a) #2 { 487 entry: 488 ; LINUX-I386-LABEL: test3d: 489 ; LINUX-I386: mov{{l|q}} %gs: 490 ; LINUX-I386: calll __stack_chk_fail 491 492 ; LINUX-X64-LABEL: test3d: 493 ; LINUX-X64: mov{{l|q}} %fs: 494 ; LINUX-X64: callq __stack_chk_fail 495 496 ; LINUX-KERNEL-X64-LABEL: test3d: 497 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 498 ; LINUX-KERNEL-X64: callq __stack_chk_fail 499 500 ; DARWIN-X64-LABEL: test3d: 501 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 502 ; DARWIN-X64: callq ___stack_chk_fail 503 504 ; MSVC-I386-LABEL: test3d: 505 ; MSVC-I386: movl ___security_cookie, 506 ; MSVC-I386: calll @__security_check_cookie@4 507 508 ; MINGW-X64-LABEL: test3d: 509 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 510 ; MINGW-X64: callq __stack_chk_fail 511 512 %a.addr = alloca i8*, align 8 513 %buf = alloca [4 x i8], align 1 514 store i8* %a, i8** %a.addr, align 8 515 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 516 %0 = load i8*, i8** %a.addr, align 8 517 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 518 %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 519 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 520 ret void 521 } 522 523 ; test4a: struct { [4 x i8] } 524 ; no ssp attribute 525 ; Requires no protector. 526 define void @test4a(i8* %a) { 527 entry: 528 ; LINUX-I386-LABEL: test4a: 529 ; LINUX-I386-NOT: calll __stack_chk_fail 530 ; LINUX-I386: .cfi_endproc 531 532 ; LINUX-X64-LABEL: test4a: 533 ; LINUX-X64-NOT: callq __stack_chk_fail 534 ; LINUX-X64: .cfi_endproc 535 536 ; LINUX-KERNEL-X64-LABEL: test4a: 537 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 538 ; LINUX-KERNEL-X64: .cfi_endproc 539 540 ; DARWIN-X64-LABEL: test4a: 541 ; DARWIN-X64-NOT: callq ___stack_chk_fail 542 ; DARWIN-X64: .cfi_endproc 543 544 ; MSVC-I386-LABEL: test4a: 545 ; MSVC-I386-NOT: calll @__security_check_cookie@4 546 ; MSVC-I386: retl 547 548 ; MINGW-X64-LABEL: test4a: 549 ; MINGW-X64-NOT: callq __stack_chk_fail 550 ; MINGW-X64: .seh_endproc 551 552 %a.addr = alloca i8*, align 8 553 %b = alloca %struct.foo.0, align 1 554 store i8* %a, i8** %a.addr, align 8 555 %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 556 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 557 %0 = load i8*, i8** %a.addr, align 8 558 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 559 %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 560 %arraydecay2 = getelementptr inbounds [4 x i8], [4 x i8]* %buf1, i32 0, i32 0 561 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 562 ret void 563 } 564 565 ; test4b: struct { [4 x i8] } 566 ; ssp attribute 567 ; Requires no protector. 568 ; Function Attrs: ssp 569 define void @test4b(i8* %a) #0 { 570 entry: 571 ; LINUX-I386-LABEL: test4b: 572 ; LINUX-I386-NOT: calll __stack_chk_fail 573 ; LINUX-I386: .cfi_endproc 574 575 ; LINUX-X64-LABEL: test4b: 576 ; LINUX-X64-NOT: callq __stack_chk_fail 577 ; LINUX-X64: .cfi_endproc 578 579 ; LINUX-KERNEL-X64-LABEL: test4b: 580 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 581 ; LINUX-KERNEL-X64: .cfi_endproc 582 583 ; DARWIN-X64-LABEL: test4b: 584 ; DARWIN-X64-NOT: callq ___stack_chk_fail 585 ; DARWIN-X64: .cfi_endproc 586 587 ; MSVC-I386-LABEL: test4b: 588 ; MSVC-I386-NOT: calll @__security_check_cookie@4 589 ; MSVC-I386: retl 590 591 ; MINGW-X64-LABEL: test4b: 592 ; MINGW-X64-NOT: callq __stack_chk_fail 593 ; MINGW-X64: .seh_endproc 594 595 %a.addr = alloca i8*, align 8 596 %b = alloca %struct.foo.0, align 1 597 store i8* %a, i8** %a.addr, align 8 598 %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 599 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 600 %0 = load i8*, i8** %a.addr, align 8 601 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 602 %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 603 %arraydecay2 = getelementptr inbounds [4 x i8], [4 x i8]* %buf1, i32 0, i32 0 604 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 605 ret void 606 } 607 608 ; test4c: struct { [4 x i8] } 609 ; sspstrong attribute 610 ; Requires protector. 611 ; Function Attrs: sspstrong 612 define void @test4c(i8* %a) #1 { 613 entry: 614 ; LINUX-I386-LABEL: test4c: 615 ; LINUX-I386: mov{{l|q}} %gs: 616 ; LINUX-I386: calll __stack_chk_fail 617 618 ; LINUX-X64-LABEL: test4c: 619 ; LINUX-X64: mov{{l|q}} %fs: 620 ; LINUX-X64: callq __stack_chk_fail 621 622 ; LINUX-KERNEL-X64-LABEL: test4c: 623 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 624 ; LINUX-KERNEL-X64: callq __stack_chk_fail 625 626 ; DARWIN-X64-LABEL: test4c: 627 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 628 ; DARWIN-X64: callq ___stack_chk_fail 629 630 ; MSVC-I386-LABEL: test4c: 631 ; MSVC-I386: movl ___security_cookie, 632 ; MSVC-I386: calll @__security_check_cookie@4 633 634 ; MINGW-X64-LABEL: test4c: 635 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 636 ; MINGW-X64: callq __stack_chk_fail 637 638 %a.addr = alloca i8*, align 8 639 %b = alloca %struct.foo.0, align 1 640 store i8* %a, i8** %a.addr, align 8 641 %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 642 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 643 %0 = load i8*, i8** %a.addr, align 8 644 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 645 %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 646 %arraydecay2 = getelementptr inbounds [4 x i8], [4 x i8]* %buf1, i32 0, i32 0 647 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 648 ret void 649 } 650 651 ; test4d: struct { [4 x i8] } 652 ; sspreq attribute 653 ; Requires protector. 654 ; Function Attrs: sspreq 655 define void @test4d(i8* %a) #2 { 656 entry: 657 ; LINUX-I386-LABEL: test4d: 658 ; LINUX-I386: mov{{l|q}} %gs: 659 ; LINUX-I386: calll __stack_chk_fail 660 661 ; LINUX-X64-LABEL: test4d: 662 ; LINUX-X64: mov{{l|q}} %fs: 663 ; LINUX-X64: callq __stack_chk_fail 664 665 ; LINUX-KERNEL-X64-LABEL: test4d: 666 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 667 ; LINUX-KERNEL-X64: callq __stack_chk_fail 668 669 ; DARWIN-X64-LABEL: test4d: 670 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 671 ; DARWIN-X64: callq ___stack_chk_fail 672 673 ; MSVC-I386-LABEL: test4d: 674 ; MSVC-I386: movl ___security_cookie, 675 ; MSVC-I386: calll @__security_check_cookie@4 676 677 ; MINGW-X64-LABEL: test4d: 678 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 679 ; MINGW-X64: callq __stack_chk_fail 680 681 %a.addr = alloca i8*, align 8 682 %b = alloca %struct.foo.0, align 1 683 store i8* %a, i8** %a.addr, align 8 684 %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 685 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0 686 %0 = load i8*, i8** %a.addr, align 8 687 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 688 %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0 689 %arraydecay2 = getelementptr inbounds [4 x i8], [4 x i8]* %buf1, i32 0, i32 0 690 %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 691 ret void 692 } 693 694 ; test5a: no arrays / no nested arrays 695 ; no ssp attribute 696 ; Requires no protector. 697 define void @test5a(i8* %a) { 698 entry: 699 ; LINUX-I386-LABEL: test5a: 700 ; LINUX-I386-NOT: calll __stack_chk_fail 701 ; LINUX-I386: .cfi_endproc 702 703 ; LINUX-X64-LABEL: test5a: 704 ; LINUX-X64-NOT: callq __stack_chk_fail 705 ; LINUX-X64: .cfi_endproc 706 707 ; LINUX-KERNEL-X64-LABEL: test5a: 708 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 709 ; LINUX-KERNEL-X64: .cfi_endproc 710 711 ; DARWIN-X64-LABEL: test5a: 712 ; DARWIN-X64-NOT: callq ___stack_chk_fail 713 ; DARWIN-X64: .cfi_endproc 714 715 ; MSVC-I386-LABEL: test5a: 716 ; MSVC-I386-NOT: calll @__security_check_cookie@4 717 ; MSVC-I386: retl 718 719 ; MINGW-X64-LABEL: test5a: 720 ; MINGW-X64-NOT: callq __stack_chk_fail 721 ; MINGW-X64: .seh_endproc 722 723 %a.addr = alloca i8*, align 8 724 store i8* %a, i8** %a.addr, align 8 725 %0 = load i8*, i8** %a.addr, align 8 726 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0) 727 ret void 728 } 729 730 ; test5b: no arrays / no nested arrays 731 ; ssp attribute 732 ; Requires no protector. 733 ; Function Attrs: ssp 734 define void @test5b(i8* %a) #0 { 735 entry: 736 ; LINUX-I386-LABEL: test5b: 737 ; LINUX-I386-NOT: calll __stack_chk_fail 738 ; LINUX-I386: .cfi_endproc 739 740 ; LINUX-X64-LABEL: test5b: 741 ; LINUX-X64-NOT: callq __stack_chk_fail 742 ; LINUX-X64: .cfi_endproc 743 744 ; LINUX-KERNEL-X64-LABEL: test5b: 745 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 746 ; LINUX-KERNEL-X64: .cfi_endproc 747 748 ; DARWIN-X64-LABEL: test5b: 749 ; DARWIN-X64-NOT: callq ___stack_chk_fail 750 ; DARWIN-X64: .cfi_endproc 751 752 ; MSVC-I386-LABEL: test5b: 753 ; MSVC-I386-NOT: calll @__security_check_cookie@4 754 ; MSVC-I386: retl 755 756 ; MINGW-X64-LABEL: test5b: 757 ; MINGW-X64-NOT: callq __stack_chk_fail 758 ; MINGW-X64: .seh_endproc 759 760 %a.addr = alloca i8*, align 8 761 store i8* %a, i8** %a.addr, align 8 762 %0 = load i8*, i8** %a.addr, align 8 763 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0) 764 ret void 765 } 766 767 ; test5c: no arrays / no nested arrays 768 ; sspstrong attribute 769 ; Requires no protector. 770 ; Function Attrs: sspstrong 771 define void @test5c(i8* %a) #1 { 772 entry: 773 ; LINUX-I386-LABEL: test5c: 774 ; LINUX-I386-NOT: calll __stack_chk_fail 775 ; LINUX-I386: .cfi_endproc 776 777 ; LINUX-X64-LABEL: test5c: 778 ; LINUX-X64-NOT: callq __stack_chk_fail 779 ; LINUX-X64: .cfi_endproc 780 781 ; LINUX-KERNEL-X64-LABEL: test5c: 782 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 783 ; LINUX-KERNEL-X64: .cfi_endproc 784 785 ; DARWIN-X64-LABEL: test5c: 786 ; DARWIN-X64-NOT: callq ___stack_chk_fail 787 ; DARWIN-X64: .cfi_endproc 788 789 ; MSVC-I386-LABEL: test5c: 790 ; MSVC-I386-NOT: calll @__security_check_cookie@4 791 ; MSVC-I386: retl 792 793 ; MINGW-X64-LABEL: test5c: 794 ; MINGW-X64-NOT: callq __stack_chk_fail 795 ; MINGW-X64: .seh_endproc 796 797 %a.addr = alloca i8*, align 8 798 store i8* %a, i8** %a.addr, align 8 799 %0 = load i8*, i8** %a.addr, align 8 800 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0) 801 ret void 802 } 803 804 ; test5d: no arrays / no nested arrays 805 ; sspreq attribute 806 ; Requires protector. 807 ; Function Attrs: sspreq 808 define void @test5d(i8* %a) #2 { 809 entry: 810 ; LINUX-I386-LABEL: test5d: 811 ; LINUX-I386: mov{{l|q}} %gs: 812 ; LINUX-I386: calll __stack_chk_fail 813 814 ; LINUX-X64-LABEL: test5d: 815 ; LINUX-X64: mov{{l|q}} %fs: 816 ; LINUX-X64: callq __stack_chk_fail 817 818 ; LINUX-KERNEL-X64-LABEL: test5d: 819 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 820 ; LINUX-KERNEL-X64: callq __stack_chk_fail 821 822 ; DARWIN-X64-LABEL: test5d: 823 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 824 ; DARWIN-X64: callq ___stack_chk_fail 825 826 ; MSVC-I386-LABEL: test5d: 827 ; MSVC-I386: movl ___security_cookie, 828 ; MSVC-I386: calll @__security_check_cookie@4 829 830 ; MINGW-X64-LABEL: test5d: 831 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 832 ; MINGW-X64: callq __stack_chk_fail 833 834 %a.addr = alloca i8*, align 8 835 store i8* %a, i8** %a.addr, align 8 836 %0 = load i8*, i8** %a.addr, align 8 837 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0) 838 ret void 839 } 840 841 ; test6a: Address-of local taken (j = &a) 842 ; no ssp attribute 843 ; Requires no protector. 844 define void @test6a() { 845 entry: 846 ; LINUX-I386-LABEL: test6a: 847 ; LINUX-I386-NOT: calll __stack_chk_fail 848 ; LINUX-I386: .cfi_endproc 849 850 ; LINUX-X64-LABEL: test6a: 851 ; LINUX-X64-NOT: callq __stack_chk_fail 852 ; LINUX-X64: .cfi_endproc 853 854 ; LINUX-KERNEL-X64-LABEL: test6a: 855 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 856 ; LINUX-KERNEL-X64: .cfi_endproc 857 858 ; DARWIN-X64-LABEL: test6a: 859 ; DARWIN-X64-NOT: callq ___stack_chk_fail 860 ; DARWIN-X64: .cfi_endproc 861 862 ; MSVC-I386-LABEL: test6a: 863 ; MSVC-I386-NOT: calll @__security_check_cookie@4 864 ; MSVC-I386: retl 865 866 ; MINGW-X64-LABEL: test6a: 867 ; MINGW-X64-NOT: callq __stack_chk_fail 868 ; MINGW-X64: .seh_endproc 869 870 %retval = alloca i32, align 4 871 %a = alloca i32, align 4 872 %j = alloca i32*, align 8 873 store i32 0, i32* %retval 874 %0 = load i32, i32* %a, align 4 875 %add = add nsw i32 %0, 1 876 store i32 %add, i32* %a, align 4 877 store i32* %a, i32** %j, align 8 878 ret void 879 } 880 881 ; test6b: Address-of local taken (j = &a) 882 ; ssp attribute 883 ; Requires no protector. 884 ; Function Attrs: ssp 885 define void @test6b() #0 { 886 entry: 887 ; LINUX-I386-LABEL: test6b: 888 ; LINUX-I386-NOT: calll __stack_chk_fail 889 ; LINUX-I386: .cfi_endproc 890 891 ; LINUX-X64-LABEL: test6b: 892 ; LINUX-X64-NOT: callq __stack_chk_fail 893 ; LINUX-X64: .cfi_endproc 894 895 ; LINUX-KERNEL-X64-LABEL: test6b: 896 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 897 ; LINUX-KERNEL-X64: .cfi_endproc 898 899 ; DARWIN-X64-LABEL: test6b: 900 ; DARWIN-X64-NOT: callq ___stack_chk_fail 901 ; DARWIN-X64: .cfi_endproc 902 903 ; MSVC-I386-LABEL: test6b: 904 ; MSVC-I386-NOT: calll @__security_check_cookie@4 905 ; MSVC-I386: retl 906 907 ; MINGW-X64-LABEL: test6b: 908 ; MINGW-X64-NOT: callq __stack_chk_fail 909 ; MINGW-X64: .seh_endproc 910 911 %retval = alloca i32, align 4 912 %a = alloca i32, align 4 913 %j = alloca i32*, align 8 914 store i32 0, i32* %retval 915 %0 = load i32, i32* %a, align 4 916 %add = add nsw i32 %0, 1 917 store i32 %add, i32* %a, align 4 918 store i32* %a, i32** %j, align 8 919 ret void 920 } 921 922 ; test6c: Address-of local taken (j = &a) 923 ; sspstrong attribute 924 ; Requires protector. 925 ; Function Attrs: sspstrong 926 define void @test6c() #1 { 927 entry: 928 ; LINUX-I386-LABEL: test6c: 929 ; LINUX-I386: mov{{l|q}} %gs: 930 ; LINUX-I386: calll __stack_chk_fail 931 932 ; LINUX-X64-LABEL: test6c: 933 ; LINUX-X64: mov{{l|q}} %fs: 934 ; LINUX-X64: callq __stack_chk_fail 935 936 ; LINUX-KERNEL-X64-LABEL: test6c: 937 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 938 ; LINUX-KERNEL-X64: callq __stack_chk_fail 939 940 ; DARWIN-X64-LABEL: test6c: 941 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 942 ; DARWIN-X64: callq ___stack_chk_fail 943 944 ; MSVC-I386-LABEL: test6c: 945 ; MSVC-I386: movl ___security_cookie, 946 ; MSVC-I386: calll @__security_check_cookie@4 947 948 ; MINGW-X64-LABEL: test6c: 949 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 950 ; MINGW-X64: callq __stack_chk_fail 951 952 %retval = alloca i32, align 4 953 %a = alloca i32, align 4 954 %j = alloca i32*, align 8 955 store i32 0, i32* %retval 956 %0 = load i32, i32* %a, align 4 957 %add = add nsw i32 %0, 1 958 store i32 %add, i32* %a, align 4 959 store i32* %a, i32** %j, align 8 960 ret void 961 } 962 963 ; test6d: Address-of local taken (j = &a) 964 ; sspreq attribute 965 ; Requires protector. 966 ; Function Attrs: sspreq 967 define void @test6d() #2 { 968 entry: 969 ; LINUX-I386-LABEL: test6d: 970 ; LINUX-I386: mov{{l|q}} %gs: 971 ; LINUX-I386: calll __stack_chk_fail 972 973 ; LINUX-X64-LABEL: test6d: 974 ; LINUX-X64: mov{{l|q}} %fs: 975 ; LINUX-X64: callq __stack_chk_fail 976 977 ; LINUX-KERNEL-X64-LABEL: test6d: 978 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 979 ; LINUX-KERNEL-X64: callq __stack_chk_fail 980 981 ; DARWIN-X64-LABEL: test6d: 982 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 983 ; DARWIN-X64: callq ___stack_chk_fail 984 985 ; MSVC-I386-LABEL: test6d: 986 ; MSVC-I386: movl ___security_cookie, 987 ; MSVC-I386: calll @__security_check_cookie@4 988 989 ; MINGW-X64-LABEL: test6d: 990 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 991 ; MINGW-X64: callq __stack_chk_fail 992 993 %retval = alloca i32, align 4 994 %a = alloca i32, align 4 995 %j = alloca i32*, align 8 996 store i32 0, i32* %retval 997 %0 = load i32, i32* %a, align 4 998 %add = add nsw i32 %0, 1 999 store i32 %add, i32* %a, align 4 1000 store i32* %a, i32** %j, align 8 1001 ret void 1002 } 1003 1004 ; test7a: PtrToInt Cast 1005 ; no ssp attribute 1006 ; Requires no protector. 1007 define void @test7a() { 1008 entry: 1009 ; LINUX-I386-LABEL: test7a: 1010 ; LINUX-I386-NOT: calll __stack_chk_fail 1011 ; LINUX-I386: .cfi_endproc 1012 1013 ; LINUX-X64-LABEL: test7a: 1014 ; LINUX-X64-NOT: callq __stack_chk_fail 1015 ; LINUX-X64: .cfi_endproc 1016 1017 ; LINUX-KERNEL-X64-LABEL: test7a: 1018 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1019 ; LINUX-KERNEL-X64: .cfi_endproc 1020 1021 ; DARWIN-X64-LABEL: test7a: 1022 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1023 ; DARWIN-X64: .cfi_endproc 1024 1025 ; MSVC-I386-LABEL: test7a: 1026 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1027 ; MSVC-I386: retl 1028 1029 ; MINGW-X64-LABEL: test7a: 1030 ; MINGW-X64-NOT: callq __stack_chk_fail 1031 ; MINGW-X64: .seh_endproc 1032 1033 %a = alloca i32, align 4 1034 %0 = ptrtoint i32* %a to i64 1035 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1036 ret void 1037 } 1038 1039 ; test7b: PtrToInt Cast 1040 ; ssp attribute 1041 ; Requires no protector. 1042 ; Function Attrs: ssp 1043 define void @test7b() #0 { 1044 entry: 1045 ; LINUX-I386-LABEL: test7b: 1046 ; LINUX-I386-NOT: calll __stack_chk_fail 1047 ; LINUX-I386: .cfi_endproc 1048 1049 ; LINUX-X64-LABEL: test7b: 1050 ; LINUX-X64-NOT: callq __stack_chk_fail 1051 ; LINUX-X64: .cfi_endproc 1052 1053 ; LINUX-KERNEL-X64-LABEL: test7b: 1054 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1055 ; LINUX-KERNEL-X64: .cfi_endproc 1056 1057 ; DARWIN-X64-LABEL: test7b: 1058 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1059 ; DARWIN-X64: .cfi_endproc 1060 1061 ; MSVC-I386-LABEL: test7b: 1062 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1063 ; MSVC-I386: retl 1064 1065 ; MINGW-X64-LABEL: test7b: 1066 ; MINGW-X64-NOT: callq __stack_chk_fail 1067 ; MINGW-X64: .seh_endproc 1068 1069 %a = alloca i32, align 4 1070 %0 = ptrtoint i32* %a to i64 1071 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1072 ret void 1073 } 1074 1075 ; test7c: PtrToInt Cast 1076 ; sspstrong attribute 1077 ; Requires protector. 1078 ; Function Attrs: sspstrong 1079 define void @test7c() #1 { 1080 entry: 1081 ; LINUX-I386-LABEL: test7c: 1082 ; LINUX-I386: mov{{l|q}} %gs: 1083 ; LINUX-I386: calll __stack_chk_fail 1084 1085 ; LINUX-X64-LABEL: test7c: 1086 ; LINUX-X64: mov{{l|q}} %fs: 1087 ; LINUX-X64: callq __stack_chk_fail 1088 1089 ; LINUX-KERNEL-X64-LABEL: test7c: 1090 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1091 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1092 1093 ; DARWIN-X64-LABEL: test7c: 1094 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1095 ; DARWIN-X64: callq ___stack_chk_fail 1096 1097 ; MSVC-I386-LABEL: test7c: 1098 ; MSVC-I386: movl ___security_cookie, 1099 ; MSVC-I386: calll @__security_check_cookie@4 1100 1101 ; MINGW-X64-LABEL: test7c: 1102 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 1103 ; MINGW-X64: .seh_endproc 1104 1105 %a = alloca i32, align 4 1106 %0 = ptrtoint i32* %a to i64 1107 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1108 ret void 1109 } 1110 1111 ; test7d: PtrToInt Cast 1112 ; sspreq attribute 1113 ; Requires protector. 1114 ; Function Attrs: sspreq 1115 define void @test7d() #2 { 1116 entry: 1117 ; LINUX-I386-LABEL: test7d: 1118 ; LINUX-I386: mov{{l|q}} %gs: 1119 ; LINUX-I386: calll __stack_chk_fail 1120 1121 ; LINUX-X64-LABEL: test7d: 1122 ; LINUX-X64: mov{{l|q}} %fs: 1123 ; LINUX-X64: callq __stack_chk_fail 1124 1125 ; LINUX-KERNEL-X64-LABEL: test7d: 1126 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1127 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1128 1129 ; DARWIN-X64-LABEL: test7d: 1130 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1131 ; DARWIN-X64: callq ___stack_chk_fail 1132 1133 ; MSVC-I386-LABEL: test7d: 1134 ; MSVC-I386: movl ___security_cookie, 1135 ; MSVC-I386: calll @__security_check_cookie@4 1136 1137 ; MINGW-X64-LABEL: test7d: 1138 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 1139 ; MINGW-X64: callq __stack_chk_fail 1140 1141 %a = alloca i32, align 4 1142 %0 = ptrtoint i32* %a to i64 1143 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1144 ret void 1145 } 1146 1147 ; test8a: Passing addr-of to function call 1148 ; no ssp attribute 1149 ; Requires no protector. 1150 define void @test8a() { 1151 entry: 1152 ; LINUX-I386-LABEL: test8a: 1153 ; LINUX-I386-NOT: calll __stack_chk_fail 1154 ; LINUX-I386: .cfi_endproc 1155 1156 ; LINUX-X64-LABEL: test8a: 1157 ; LINUX-X64-NOT: callq __stack_chk_fail 1158 ; LINUX-X64: .cfi_endproc 1159 1160 ; LINUX-KERNEL-X64-LABEL: test8a: 1161 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1162 ; LINUX-KERNEL-X64: .cfi_endproc 1163 1164 ; DARWIN-X64-LABEL: test8a: 1165 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1166 ; DARWIN-X64: .cfi_endproc 1167 1168 ; MSVC-I386-LABEL: test8a: 1169 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1170 ; MSVC-I386: retl 1171 1172 ; MINGW-X64-LABEL: test8a: 1173 ; MINGW-X64-NOT: callq __stack_chk_fail 1174 ; MINGW-X64: .seh_endproc 1175 1176 %b = alloca i32, align 4 1177 call void @funcall(i32* %b) 1178 ret void 1179 } 1180 1181 ; test8b: Passing addr-of to function call 1182 ; ssp attribute 1183 ; Requires no protector. 1184 ; Function Attrs: ssp 1185 define void @test8b() #0 { 1186 entry: 1187 ; LINUX-I386-LABEL: test8b: 1188 ; LINUX-I386-NOT: calll __stack_chk_fail 1189 ; LINUX-I386: .cfi_endproc 1190 1191 ; LINUX-X64-LABEL: test8b: 1192 ; LINUX-X64-NOT: callq __stack_chk_fail 1193 ; LINUX-X64: .cfi_endproc 1194 1195 ; LINUX-KERNEL-X64-LABEL: test8b: 1196 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1197 ; LINUX-KERNEL-X64: .cfi_endproc 1198 1199 ; DARWIN-X64-LABEL: test8b: 1200 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1201 ; DARWIN-X64: .cfi_endproc 1202 1203 ; MSVC-I386-LABEL: test8b: 1204 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1205 ; MSVC-I386: retl 1206 1207 ; MINGW-X64-LABEL: test8b: 1208 ; MINGW-X64-NOT: callq __stack_chk_fail 1209 ; MINGW-X64: .seh_endproc 1210 1211 %b = alloca i32, align 4 1212 call void @funcall(i32* %b) 1213 ret void 1214 } 1215 1216 ; test8c: Passing addr-of to function call 1217 ; sspstrong attribute 1218 ; Requires protector. 1219 ; Function Attrs: sspstrong 1220 define void @test8c() #1 { 1221 entry: 1222 ; LINUX-I386-LABEL: test8c: 1223 ; LINUX-I386: mov{{l|q}} %gs: 1224 ; LINUX-I386: calll __stack_chk_fail 1225 1226 ; LINUX-X64-LABEL: test8c: 1227 ; LINUX-X64: mov{{l|q}} %fs: 1228 ; LINUX-X64: callq __stack_chk_fail 1229 1230 ; LINUX-KERNEL-X64-LABEL: test8c: 1231 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1232 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1233 1234 ; DARWIN-X64-LABEL: test8c: 1235 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1236 ; DARWIN-X64: callq ___stack_chk_fail 1237 1238 ; MSVC-I386-LABEL: test8c: 1239 ; MSVC-I386: movl ___security_cookie, 1240 ; MSVC-I386: calll @__security_check_cookie@4 1241 1242 ; MINGW-X64-LABEL: test8c: 1243 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 1244 ; MINGW-X64: callq __stack_chk_fail 1245 1246 %b = alloca i32, align 4 1247 call void @funcall(i32* %b) 1248 ret void 1249 } 1250 1251 ; test8d: Passing addr-of to function call 1252 ; sspreq attribute 1253 ; Requires protector. 1254 ; Function Attrs: sspreq 1255 define void @test8d() #2 { 1256 entry: 1257 ; LINUX-I386-LABEL: test8d: 1258 ; LINUX-I386: mov{{l|q}} %gs: 1259 ; LINUX-I386: calll __stack_chk_fail 1260 1261 ; LINUX-X64-LABEL: test8d: 1262 ; LINUX-X64: mov{{l|q}} %fs: 1263 ; LINUX-X64: callq __stack_chk_fail 1264 1265 ; LINUX-KERNEL-X64-LABEL: test8d: 1266 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1267 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1268 1269 ; DARWIN-X64-LABEL: test8d: 1270 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1271 ; DARWIN-X64: callq ___stack_chk_fail 1272 1273 ; MSVC-I386-LABEL: test8d: 1274 ; MSVC-I386: movl ___security_cookie, 1275 ; MSVC-I386: calll @__security_check_cookie@4 1276 1277 ; MINGW-X64-LABEL: test8d: 1278 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 1279 ; MINGW-X64: callq __stack_chk_fail 1280 1281 %b = alloca i32, align 4 1282 call void @funcall(i32* %b) 1283 ret void 1284 } 1285 1286 ; test9a: Addr-of in select instruction 1287 ; no ssp attribute 1288 ; Requires no protector. 1289 define void @test9a() { 1290 entry: 1291 ; LINUX-I386-LABEL: test9a: 1292 ; LINUX-I386-NOT: calll __stack_chk_fail 1293 ; LINUX-I386: .cfi_endproc 1294 1295 ; LINUX-X64-LABEL: test9a: 1296 ; LINUX-X64-NOT: callq __stack_chk_fail 1297 ; LINUX-X64: .cfi_endproc 1298 1299 ; LINUX-KERNEL-X64-LABEL: test9a: 1300 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1301 ; LINUX-KERNEL-X64: .cfi_endproc 1302 1303 ; DARWIN-X64-LABEL: test9a: 1304 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1305 ; DARWIN-X64: .cfi_endproc 1306 1307 ; MSVC-I386-LABEL: test9a: 1308 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1309 ; MSVC-I386: retl 1310 %x = alloca double, align 8 1311 %call = call double @testi_aux() 1312 store double %call, double* %x, align 8 1313 %cmp2 = fcmp ogt double %call, 0.000000e+00 1314 %y.1 = select i1 %cmp2, double* %x, double* null 1315 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1316 ret void 1317 } 1318 1319 ; test9b: Addr-of in select instruction 1320 ; ssp attribute 1321 ; Requires no protector. 1322 ; Function Attrs: ssp 1323 define void @test9b() #0 { 1324 entry: 1325 ; LINUX-I386-LABEL: test9b: 1326 ; LINUX-I386-NOT: calll __stack_chk_fail 1327 ; LINUX-I386: .cfi_endproc 1328 1329 ; LINUX-X64-LABEL: test9b: 1330 ; LINUX-X64-NOT: callq __stack_chk_fail 1331 ; LINUX-X64: .cfi_endproc 1332 1333 ; LINUX-KERNEL-X64-LABEL: test9b: 1334 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1335 ; LINUX-KERNEL-X64: .cfi_endproc 1336 1337 ; DARWIN-X64-LABEL: test9b: 1338 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1339 ; DARWIN-X64: .cfi_endproc 1340 1341 ; MSVC-I386-LABEL: test9b: 1342 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1343 ; MSVC-I386: retl 1344 %x = alloca double, align 8 1345 %call = call double @testi_aux() 1346 store double %call, double* %x, align 8 1347 %cmp2 = fcmp ogt double %call, 0.000000e+00 1348 %y.1 = select i1 %cmp2, double* %x, double* null 1349 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1350 ret void 1351 } 1352 1353 ; test9c: Addr-of in select instruction 1354 ; sspstrong attribute 1355 ; Requires protector. 1356 ; Function Attrs: sspstrong 1357 define void @test9c() #1 { 1358 entry: 1359 ; LINUX-I386-LABEL: test9c: 1360 ; LINUX-I386: mov{{l|q}} %gs: 1361 ; LINUX-I386: calll __stack_chk_fail 1362 1363 ; LINUX-X64-LABEL: test9c: 1364 ; LINUX-X64: mov{{l|q}} %fs: 1365 ; LINUX-X64: callq __stack_chk_fail 1366 1367 ; LINUX-KERNEL-X64-LABEL: test9c: 1368 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1369 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1370 1371 ; DARWIN-X64-LABEL: test9c: 1372 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1373 ; DARWIN-X64: callq ___stack_chk_fail 1374 1375 ; MSVC-I386-LABEL: test9c: 1376 ; MSVC-I386: movl ___security_cookie, 1377 ; MSVC-I386: calll @__security_check_cookie@4 1378 %x = alloca double, align 8 1379 %call = call double @testi_aux() 1380 store double %call, double* %x, align 8 1381 %cmp2 = fcmp ogt double %call, 0.000000e+00 1382 %y.1 = select i1 %cmp2, double* %x, double* null 1383 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1384 ret void 1385 } 1386 1387 ; test9d: Addr-of in select instruction 1388 ; sspreq attribute 1389 ; Requires protector. 1390 ; Function Attrs: sspreq 1391 define void @test9d() #2 { 1392 entry: 1393 ; LINUX-I386-LABEL: test9d: 1394 ; LINUX-I386: mov{{l|q}} %gs: 1395 ; LINUX-I386: calll __stack_chk_fail 1396 1397 ; LINUX-X64-LABEL: test9d: 1398 ; LINUX-X64: mov{{l|q}} %fs: 1399 ; LINUX-X64: callq __stack_chk_fail 1400 1401 ; LINUX-KERNEL-X64-LABEL: test9d: 1402 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1403 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1404 1405 ; DARWIN-X64-LABEL: test9d: 1406 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1407 ; DARWIN-X64: callq ___stack_chk_fail 1408 1409 ; MSVC-I386-LABEL: test9d: 1410 ; MSVC-I386: movl ___security_cookie, 1411 ; MSVC-I386: calll @__security_check_cookie@4 1412 %x = alloca double, align 8 1413 %call = call double @testi_aux() 1414 store double %call, double* %x, align 8 1415 %cmp2 = fcmp ogt double %call, 0.000000e+00 1416 %y.1 = select i1 %cmp2, double* %x, double* null 1417 %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1418 ret void 1419 } 1420 1421 ; test10a: Addr-of in phi instruction 1422 ; no ssp attribute 1423 ; Requires no protector. 1424 define void @test10a() { 1425 entry: 1426 ; LINUX-I386-LABEL: test10a: 1427 ; LINUX-I386-NOT: calll __stack_chk_fail 1428 ; LINUX-I386: .cfi_endproc 1429 1430 ; LINUX-X64-LABEL: test10a: 1431 ; LINUX-X64-NOT: callq __stack_chk_fail 1432 ; LINUX-X64: .cfi_endproc 1433 1434 ; LINUX-KERNEL-X64-LABEL: test10a: 1435 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1436 ; LINUX-KERNEL-X64: .cfi_endproc 1437 1438 ; DARWIN-X64-LABEL: test10a: 1439 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1440 ; DARWIN-X64: .cfi_endproc 1441 1442 ; MSVC-I386-LABEL: test10a: 1443 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1444 ; MSVC-I386: retl 1445 %x = alloca double, align 8 1446 %call = call double @testi_aux() 1447 store double %call, double* %x, align 8 1448 %cmp = fcmp ogt double %call, 3.140000e+00 1449 br i1 %cmp, label %if.then, label %if.else 1450 1451 if.then: ; preds = %entry 1452 %call1 = call double @testi_aux() 1453 store double %call1, double* %x, align 8 1454 br label %if.end4 1455 1456 if.else: ; preds = %entry 1457 %cmp2 = fcmp ogt double %call, 1.000000e+00 1458 br i1 %cmp2, label %if.then3, label %if.end4 1459 1460 if.then3: ; preds = %if.else 1461 br label %if.end4 1462 1463 if.end4: ; preds = %if.else, %if.then3, %if.then 1464 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1465 %call5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), double* %y.0) 1466 ret void 1467 } 1468 1469 ; test10b: Addr-of in phi instruction 1470 ; ssp attribute 1471 ; Requires no protector. 1472 ; Function Attrs: ssp 1473 define void @test10b() #0 { 1474 entry: 1475 ; LINUX-I386-LABEL: test10b: 1476 ; LINUX-I386-NOT: calll __stack_chk_fail 1477 ; LINUX-I386: .cfi_endproc 1478 1479 ; LINUX-X64-LABEL: test10b: 1480 ; LINUX-X64-NOT: callq __stack_chk_fail 1481 ; LINUX-X64: .cfi_endproc 1482 1483 ; LINUX-KERNEL-X64-LABEL: test10b: 1484 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1485 ; LINUX-KERNEL-X64: .cfi_endproc 1486 1487 ; DARWIN-X64-LABEL: test10b: 1488 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1489 ; DARWIN-X64: .cfi_endproc 1490 1491 ; MSVC-I386-LABEL: test10b: 1492 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1493 ; MSVC-I386: retl 1494 %x = alloca double, align 8 1495 %call = call double @testi_aux() 1496 store double %call, double* %x, align 8 1497 %cmp = fcmp ogt double %call, 3.140000e+00 1498 br i1 %cmp, label %if.then, label %if.else 1499 1500 if.then: ; preds = %entry 1501 %call1 = call double @testi_aux() 1502 store double %call1, double* %x, align 8 1503 br label %if.end4 1504 1505 if.else: ; preds = %entry 1506 %cmp2 = fcmp ogt double %call, 1.000000e+00 1507 br i1 %cmp2, label %if.then3, label %if.end4 1508 1509 if.then3: ; preds = %if.else 1510 br label %if.end4 1511 1512 if.end4: ; preds = %if.else, %if.then3, %if.then 1513 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1514 %call5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), double* %y.0) 1515 ret void 1516 } 1517 1518 ; test10c: Addr-of in phi instruction 1519 ; sspstrong attribute 1520 ; Requires protector. 1521 ; Function Attrs: sspstrong 1522 define void @test10c() #1 { 1523 entry: 1524 ; LINUX-I386-LABEL: test10c: 1525 ; LINUX-I386: mov{{l|q}} %gs: 1526 ; LINUX-I386: calll __stack_chk_fail 1527 1528 ; LINUX-X64-LABEL: test10c: 1529 ; LINUX-X64: mov{{l|q}} %fs: 1530 ; LINUX-X64: callq __stack_chk_fail 1531 1532 ; LINUX-KERNEL-X64-LABEL: test10c: 1533 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1534 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1535 1536 ; DARWIN-X64-LABEL: test10c: 1537 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1538 ; DARWIN-X64: callq ___stack_chk_fail 1539 1540 ; MSVC-I386-LABEL: test10c: 1541 ; MSVC-I386: movl ___security_cookie, 1542 ; MSVC-I386: calll @__security_check_cookie@4 1543 %x = alloca double, align 8 1544 %call = call double @testi_aux() 1545 store double %call, double* %x, align 8 1546 %cmp = fcmp ogt double %call, 3.140000e+00 1547 br i1 %cmp, label %if.then, label %if.else 1548 1549 if.then: ; preds = %entry 1550 %call1 = call double @testi_aux() 1551 store double %call1, double* %x, align 8 1552 br label %if.end4 1553 1554 if.else: ; preds = %entry 1555 %cmp2 = fcmp ogt double %call, 1.000000e+00 1556 br i1 %cmp2, label %if.then3, label %if.end4 1557 1558 if.then3: ; preds = %if.else 1559 br label %if.end4 1560 1561 if.end4: ; preds = %if.else, %if.then3, %if.then 1562 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1563 %call5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), double* %y.0) 1564 ret void 1565 } 1566 1567 ; test10d: Addr-of in phi instruction 1568 ; sspreq attribute 1569 ; Requires protector. 1570 ; Function Attrs: sspreq 1571 define void @test10d() #2 { 1572 entry: 1573 ; LINUX-I386-LABEL: test10d: 1574 ; LINUX-I386: mov{{l|q}} %gs: 1575 ; LINUX-I386: calll __stack_chk_fail 1576 1577 ; LINUX-X64-LABEL: test10d: 1578 ; LINUX-X64: mov{{l|q}} %fs: 1579 ; LINUX-X64: callq __stack_chk_fail 1580 1581 ; LINUX-KERNEL-X64-LABEL: test10d: 1582 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1583 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1584 1585 ; DARWIN-X64-LABEL: test10d: 1586 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1587 ; DARWIN-X64: callq ___stack_chk_fail 1588 1589 ; MSVC-I386-LABEL: test10d: 1590 ; MSVC-I386: movl ___security_cookie, 1591 ; MSVC-I386: calll @__security_check_cookie@4 1592 %x = alloca double, align 8 1593 %call = call double @testi_aux() 1594 store double %call, double* %x, align 8 1595 %cmp = fcmp ogt double %call, 3.140000e+00 1596 br i1 %cmp, label %if.then, label %if.else 1597 1598 if.then: ; preds = %entry 1599 %call1 = call double @testi_aux() 1600 store double %call1, double* %x, align 8 1601 br label %if.end4 1602 1603 if.else: ; preds = %entry 1604 %cmp2 = fcmp ogt double %call, 1.000000e+00 1605 br i1 %cmp2, label %if.then3, label %if.end4 1606 1607 if.then3: ; preds = %if.else 1608 br label %if.end4 1609 1610 if.end4: ; preds = %if.else, %if.then3, %if.then 1611 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1612 %call5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), double* %y.0) 1613 ret void 1614 } 1615 1616 ; test11a: Addr-of struct element. (GEP followed by store). 1617 ; no ssp attribute 1618 ; Requires no protector. 1619 define void @test11a() { 1620 entry: 1621 ; LINUX-I386-LABEL: test11a: 1622 ; LINUX-I386-NOT: calll __stack_chk_fail 1623 ; LINUX-I386: .cfi_endproc 1624 1625 ; LINUX-X64-LABEL: test11a: 1626 ; LINUX-X64-NOT: callq __stack_chk_fail 1627 ; LINUX-X64: .cfi_endproc 1628 1629 ; LINUX-KERNEL-X64-LABEL: test11a: 1630 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1631 ; LINUX-KERNEL-X64: .cfi_endproc 1632 1633 ; DARWIN-X64-LABEL: test11a: 1634 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1635 ; DARWIN-X64: .cfi_endproc 1636 1637 ; MSVC-I386-LABEL: test11a: 1638 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1639 ; MSVC-I386: retl 1640 %c = alloca %struct.pair, align 4 1641 %b = alloca i32*, align 8 1642 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1643 store i32* %y, i32** %b, align 8 1644 %0 = load i32*, i32** %b, align 8 1645 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32* %0) 1646 ret void 1647 } 1648 1649 ; test11b: Addr-of struct element. (GEP followed by store). 1650 ; ssp attribute 1651 ; Requires no protector. 1652 ; Function Attrs: ssp 1653 define void @test11b() #0 { 1654 entry: 1655 ; LINUX-I386-LABEL: test11b: 1656 ; LINUX-I386-NOT: calll __stack_chk_fail 1657 ; LINUX-I386: .cfi_endproc 1658 1659 ; LINUX-X64-LABEL: test11b: 1660 ; LINUX-X64-NOT: callq __stack_chk_fail 1661 ; LINUX-X64: .cfi_endproc 1662 1663 ; LINUX-KERNEL-X64-LABEL: test11b: 1664 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1665 ; LINUX-KERNEL-X64: .cfi_endproc 1666 1667 ; DARWIN-X64-LABEL: test11b: 1668 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1669 ; DARWIN-X64: .cfi_endproc 1670 1671 ; MSVC-I386-LABEL: test11b: 1672 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1673 ; MSVC-I386: retl 1674 %c = alloca %struct.pair, align 4 1675 %b = alloca i32*, align 8 1676 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1677 store i32* %y, i32** %b, align 8 1678 %0 = load i32*, i32** %b, align 8 1679 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32* %0) 1680 ret void 1681 } 1682 1683 ; test11c: Addr-of struct element. (GEP followed by store). 1684 ; sspstrong attribute 1685 ; Requires protector. 1686 ; Function Attrs: sspstrong 1687 define void @test11c() #1 { 1688 entry: 1689 ; LINUX-I386-LABEL: test11c: 1690 ; LINUX-I386: mov{{l|q}} %gs: 1691 ; LINUX-I386: calll __stack_chk_fail 1692 1693 ; LINUX-X64-LABEL: test11c: 1694 ; LINUX-X64: mov{{l|q}} %fs: 1695 ; LINUX-X64: callq __stack_chk_fail 1696 1697 ; LINUX-KERNEL-X64-LABEL: test11c: 1698 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1699 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1700 1701 ; DARWIN-X64-LABEL: test11c: 1702 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1703 ; DARWIN-X64: callq ___stack_chk_fail 1704 1705 ; MSVC-I386-LABEL: test11c: 1706 ; MSVC-I386: movl ___security_cookie, 1707 ; MSVC-I386: calll @__security_check_cookie@4 1708 %c = alloca %struct.pair, align 4 1709 %b = alloca i32*, align 8 1710 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1711 store i32* %y, i32** %b, align 8 1712 %0 = load i32*, i32** %b, align 8 1713 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32* %0) 1714 ret void 1715 } 1716 1717 ; test11d: Addr-of struct element. (GEP followed by store). 1718 ; sspreq attribute 1719 ; Requires protector. 1720 ; Function Attrs: sspreq 1721 define void @test11d() #2 { 1722 entry: 1723 ; LINUX-I386-LABEL: test11d: 1724 ; LINUX-I386: mov{{l|q}} %gs: 1725 ; LINUX-I386: calll __stack_chk_fail 1726 1727 ; LINUX-X64-LABEL: test11d: 1728 ; LINUX-X64: mov{{l|q}} %fs: 1729 ; LINUX-X64: callq __stack_chk_fail 1730 1731 ; LINUX-KERNEL-X64-LABEL: test11d: 1732 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1733 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1734 1735 ; DARWIN-X64-LABEL: test11d: 1736 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1737 ; DARWIN-X64: callq ___stack_chk_fail 1738 1739 ; MSVC-I386-LABEL: test11d: 1740 ; MSVC-I386: movl ___security_cookie, 1741 ; MSVC-I386: calll @__security_check_cookie@4 1742 %c = alloca %struct.pair, align 4 1743 %b = alloca i32*, align 8 1744 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1745 store i32* %y, i32** %b, align 8 1746 %0 = load i32*, i32** %b, align 8 1747 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32* %0) 1748 ret void 1749 } 1750 1751 ; test12a: Addr-of struct element, GEP followed by ptrtoint. 1752 ; no ssp attribute 1753 ; Requires no protector. 1754 define void @test12a() { 1755 entry: 1756 ; LINUX-I386-LABEL: test12a: 1757 ; LINUX-I386-NOT: calll __stack_chk_fail 1758 ; LINUX-I386: .cfi_endproc 1759 1760 ; LINUX-X64-LABEL: test12a: 1761 ; LINUX-X64-NOT: callq __stack_chk_fail 1762 ; LINUX-X64: .cfi_endproc 1763 1764 ; LINUX-KERNEL-X64-LABEL: test12a: 1765 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1766 ; LINUX-KERNEL-X64: .cfi_endproc 1767 1768 ; DARWIN-X64-LABEL: test12a: 1769 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1770 ; DARWIN-X64: .cfi_endproc 1771 1772 ; MSVC-I386-LABEL: test12a: 1773 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1774 ; MSVC-I386: retl 1775 %c = alloca %struct.pair, align 4 1776 %b = alloca i32*, align 8 1777 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1778 %0 = ptrtoint i32* %y to i64 1779 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1780 ret void 1781 } 1782 1783 ; test12b: Addr-of struct element, GEP followed by ptrtoint. 1784 ; ssp attribute 1785 ; Requires no protector. 1786 ; Function Attrs: ssp 1787 define void @test12b() #0 { 1788 entry: 1789 ; LINUX-I386-LABEL: test12b: 1790 ; LINUX-I386-NOT: calll __stack_chk_fail 1791 ; LINUX-I386: .cfi_endproc 1792 1793 ; LINUX-X64-LABEL: test12b: 1794 ; LINUX-X64-NOT: callq __stack_chk_fail 1795 ; LINUX-X64: .cfi_endproc 1796 1797 ; LINUX-KERNEL-X64-LABEL: test12b: 1798 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1799 ; LINUX-KERNEL-X64: .cfi_endproc 1800 1801 ; DARWIN-X64-LABEL: test12b: 1802 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1803 ; DARWIN-X64: .cfi_endproc 1804 1805 ; MSVC-I386-LABEL: test12b: 1806 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1807 ; MSVC-I386: retl 1808 %c = alloca %struct.pair, align 4 1809 %b = alloca i32*, align 8 1810 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1811 %0 = ptrtoint i32* %y to i64 1812 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1813 ret void 1814 } 1815 1816 ; test12c: Addr-of struct element, GEP followed by ptrtoint. 1817 ; sspstrong attribute 1818 ; Function Attrs: sspstrong 1819 define void @test12c() #1 { 1820 entry: 1821 ; LINUX-I386-LABEL: test12c: 1822 ; LINUX-I386: mov{{l|q}} %gs: 1823 ; LINUX-I386: calll __stack_chk_fail 1824 1825 ; LINUX-X64-LABEL: test12c: 1826 ; LINUX-X64: mov{{l|q}} %fs: 1827 ; LINUX-X64: callq __stack_chk_fail 1828 1829 ; LINUX-KERNEL-X64-LABEL: test12c: 1830 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1831 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1832 1833 ; DARWIN-X64-LABEL: test12c: 1834 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1835 ; DARWIN-X64: callq ___stack_chk_fail 1836 1837 ; MSVC-I386-LABEL: test12c: 1838 ; MSVC-I386: movl ___security_cookie, 1839 ; MSVC-I386: calll @__security_check_cookie@4 1840 %c = alloca %struct.pair, align 4 1841 %b = alloca i32*, align 8 1842 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1843 %0 = ptrtoint i32* %y to i64 1844 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1845 ret void 1846 } 1847 1848 ; test12d: Addr-of struct element, GEP followed by ptrtoint. 1849 ; sspreq attribute 1850 ; Requires protector. 1851 ; Function Attrs: sspreq 1852 define void @test12d() #2 { 1853 entry: 1854 ; LINUX-I386-LABEL: test12d: 1855 ; LINUX-I386: mov{{l|q}} %gs: 1856 ; LINUX-I386: calll __stack_chk_fail 1857 1858 ; LINUX-X64-LABEL: test12d: 1859 ; LINUX-X64: mov{{l|q}} %fs: 1860 ; LINUX-X64: callq __stack_chk_fail 1861 1862 ; LINUX-KERNEL-X64-LABEL: test12d: 1863 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1864 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1865 1866 ; DARWIN-X64-LABEL: test12d: 1867 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1868 ; DARWIN-X64: callq ___stack_chk_fail 1869 1870 ; MSVC-I386-LABEL: test12d: 1871 ; MSVC-I386: movl ___security_cookie, 1872 ; MSVC-I386: calll @__security_check_cookie@4 1873 %c = alloca %struct.pair, align 4 1874 %b = alloca i32*, align 8 1875 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1 1876 %0 = ptrtoint i32* %y to i64 1877 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0) 1878 ret void 1879 } 1880 1881 ; test13a: Addr-of struct element, GEP followed by callinst. 1882 ; no ssp attribute 1883 ; Requires no protector. 1884 define void @test13a() { 1885 entry: 1886 ; LINUX-I386-LABEL: test13a: 1887 ; LINUX-I386-NOT: calll __stack_chk_fail 1888 ; LINUX-I386: .cfi_endproc 1889 1890 ; LINUX-X64-LABEL: test13a: 1891 ; LINUX-X64-NOT: callq __stack_chk_fail 1892 ; LINUX-X64: .cfi_endproc 1893 1894 ; LINUX-KERNEL-X64-LABEL: test13a: 1895 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1896 ; LINUX-KERNEL-X64: .cfi_endproc 1897 1898 ; DARWIN-X64-LABEL: test13a: 1899 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1900 ; DARWIN-X64: .cfi_endproc 1901 1902 ; MSVC-I386-LABEL: test13a: 1903 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1904 ; MSVC-I386: retl 1905 %c = alloca %struct.pair, align 4 1906 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i64 0, i32 1 1907 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %y) 1908 ret void 1909 } 1910 1911 ; test13b: Addr-of struct element, GEP followed by callinst. 1912 ; ssp attribute 1913 ; Requires no protector. 1914 ; Function Attrs: ssp 1915 define void @test13b() #0 { 1916 entry: 1917 ; LINUX-I386-LABEL: test13b: 1918 ; LINUX-I386-NOT: calll __stack_chk_fail 1919 ; LINUX-I386: .cfi_endproc 1920 1921 ; LINUX-X64-LABEL: test13b: 1922 ; LINUX-X64-NOT: callq __stack_chk_fail 1923 ; LINUX-X64: .cfi_endproc 1924 1925 ; LINUX-KERNEL-X64-LABEL: test13b: 1926 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1927 ; LINUX-KERNEL-X64: .cfi_endproc 1928 1929 ; DARWIN-X64-LABEL: test13b: 1930 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1931 ; DARWIN-X64: .cfi_endproc 1932 1933 ; MSVC-I386-LABEL: test13b: 1934 ; MSVC-I386-NOT: calll @__security_check_cookie@4 1935 ; MSVC-I386: retl 1936 %c = alloca %struct.pair, align 4 1937 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i64 0, i32 1 1938 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %y) 1939 ret void 1940 } 1941 1942 ; test13c: Addr-of struct element, GEP followed by callinst. 1943 ; sspstrong attribute 1944 ; Requires protector. 1945 ; Function Attrs: sspstrong 1946 define void @test13c() #1 { 1947 entry: 1948 ; LINUX-I386-LABEL: test13c: 1949 ; LINUX-I386: mov{{l|q}} %gs: 1950 ; LINUX-I386: calll __stack_chk_fail 1951 1952 ; LINUX-X64-LABEL: test13c: 1953 ; LINUX-X64: mov{{l|q}} %fs: 1954 ; LINUX-X64: callq __stack_chk_fail 1955 1956 ; LINUX-KERNEL-X64-LABEL: test13c: 1957 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1958 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1959 1960 ; DARWIN-X64-LABEL: test13c: 1961 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1962 ; DARWIN-X64: callq ___stack_chk_fail 1963 1964 ; MSVC-I386-LABEL: test13c: 1965 ; MSVC-I386: movl ___security_cookie, 1966 ; MSVC-I386: calll @__security_check_cookie@4 1967 %c = alloca %struct.pair, align 4 1968 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i64 0, i32 1 1969 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %y) 1970 ret void 1971 } 1972 1973 ; test13d: Addr-of struct element, GEP followed by callinst. 1974 ; sspreq attribute 1975 ; Requires protector. 1976 ; Function Attrs: sspreq 1977 define void @test13d() #2 { 1978 entry: 1979 ; LINUX-I386-LABEL: test13d: 1980 ; LINUX-I386: mov{{l|q}} %gs: 1981 ; LINUX-I386: calll __stack_chk_fail 1982 1983 ; LINUX-X64-LABEL: test13d: 1984 ; LINUX-X64: mov{{l|q}} %fs: 1985 ; LINUX-X64: callq __stack_chk_fail 1986 1987 ; LINUX-KERNEL-X64-LABEL: test13d: 1988 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1989 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1990 1991 ; DARWIN-X64-LABEL: test13d: 1992 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1993 ; DARWIN-X64: callq ___stack_chk_fail 1994 1995 ; MSVC-I386-LABEL: test13d: 1996 ; MSVC-I386: movl ___security_cookie, 1997 ; MSVC-I386: calll @__security_check_cookie@4 1998 %c = alloca %struct.pair, align 4 1999 %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i64 0, i32 1 2000 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %y) 2001 ret void 2002 } 2003 2004 ; test14a: Addr-of a local, optimized into a GEP (e.g., &a - 12) 2005 ; no ssp attribute 2006 ; Requires no protector. 2007 define void @test14a() { 2008 entry: 2009 ; LINUX-I386-LABEL: test14a: 2010 ; LINUX-I386-NOT: calll __stack_chk_fail 2011 ; LINUX-I386: .cfi_endproc 2012 2013 ; LINUX-X64-LABEL: test14a: 2014 ; LINUX-X64-NOT: callq __stack_chk_fail 2015 ; LINUX-X64: .cfi_endproc 2016 2017 ; LINUX-KERNEL-X64-LABEL: test14a: 2018 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2019 ; LINUX-KERNEL-X64: .cfi_endproc 2020 2021 ; DARWIN-X64-LABEL: test14a: 2022 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2023 ; DARWIN-X64: .cfi_endproc 2024 2025 ; MSVC-I386-LABEL: test14a: 2026 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2027 ; MSVC-I386: retl 2028 %a = alloca i32, align 4 2029 %add.ptr5 = getelementptr inbounds i32, i32* %a, i64 -12 2030 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) 2031 ret void 2032 } 2033 2034 ; test14b: Addr-of a local, optimized into a GEP (e.g., &a - 12) 2035 ; ssp attribute 2036 ; Requires no protector. 2037 ; Function Attrs: ssp 2038 define void @test14b() #0 { 2039 entry: 2040 ; LINUX-I386-LABEL: test14b: 2041 ; LINUX-I386-NOT: calll __stack_chk_fail 2042 ; LINUX-I386: .cfi_endproc 2043 2044 ; LINUX-X64-LABEL: test14b: 2045 ; LINUX-X64-NOT: callq __stack_chk_fail 2046 ; LINUX-X64: .cfi_endproc 2047 2048 ; LINUX-KERNEL-X64-LABEL: test14b: 2049 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2050 ; LINUX-KERNEL-X64: .cfi_endproc 2051 2052 ; DARWIN-X64-LABEL: test14b: 2053 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2054 ; DARWIN-X64: .cfi_endproc 2055 2056 ; MSVC-I386-LABEL: test14b: 2057 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2058 ; MSVC-I386: retl 2059 %a = alloca i32, align 4 2060 %add.ptr5 = getelementptr inbounds i32, i32* %a, i64 -12 2061 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) 2062 ret void 2063 } 2064 2065 ; test14c: Addr-of a local, optimized into a GEP (e.g., &a - 12) 2066 ; sspstrong attribute 2067 ; Requires protector. 2068 ; Function Attrs: sspstrong 2069 define void @test14c() #1 { 2070 entry: 2071 ; LINUX-I386-LABEL: test14c: 2072 ; LINUX-I386: mov{{l|q}} %gs: 2073 ; LINUX-I386: calll __stack_chk_fail 2074 2075 ; LINUX-X64-LABEL: test14c: 2076 ; LINUX-X64: mov{{l|q}} %fs: 2077 ; LINUX-X64: callq __stack_chk_fail 2078 2079 ; LINUX-KERNEL-X64-LABEL: test14c: 2080 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2081 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2082 2083 ; DARWIN-X64-LABEL: test14c: 2084 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2085 ; DARWIN-X64: callq ___stack_chk_fail 2086 2087 ; MSVC-I386-LABEL: test14c: 2088 ; MSVC-I386: movl ___security_cookie, 2089 ; MSVC-I386: calll @__security_check_cookie@4 2090 %a = alloca i32, align 4 2091 %add.ptr5 = getelementptr inbounds i32, i32* %a, i64 -12 2092 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) 2093 ret void 2094 } 2095 2096 ; test14d: Addr-of a local, optimized into a GEP (e.g., &a - 12) 2097 ; sspreq attribute 2098 ; Requires protector. 2099 ; Function Attrs: sspreq 2100 define void @test14d() #2 { 2101 entry: 2102 ; LINUX-I386-LABEL: test14d: 2103 ; LINUX-I386: mov{{l|q}} %gs: 2104 ; LINUX-I386: calll __stack_chk_fail 2105 2106 ; LINUX-X64-LABEL: test14d: 2107 ; LINUX-X64: mov{{l|q}} %fs: 2108 ; LINUX-X64: callq __stack_chk_fail 2109 2110 ; LINUX-KERNEL-X64-LABEL: test14d: 2111 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2112 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2113 2114 ; DARWIN-X64-LABEL: test14d: 2115 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2116 ; DARWIN-X64: callq ___stack_chk_fail 2117 2118 ; MSVC-I386-LABEL: test14d: 2119 ; MSVC-I386: movl ___security_cookie, 2120 ; MSVC-I386: calll @__security_check_cookie@4 2121 %a = alloca i32, align 4 2122 %add.ptr5 = getelementptr inbounds i32, i32* %a, i64 -12 2123 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) 2124 ret void 2125 } 2126 2127 ; test15a: Addr-of a local cast to a ptr of a different type 2128 ; (e.g., int a; ... ; float *b = &a;) 2129 ; no ssp attribute 2130 ; Requires no protector. 2131 define void @test15a() { 2132 entry: 2133 ; LINUX-I386-LABEL: test15a: 2134 ; LINUX-I386-NOT: calll __stack_chk_fail 2135 ; LINUX-I386: .cfi_endproc 2136 2137 ; LINUX-X64-LABEL: test15a: 2138 ; LINUX-X64-NOT: callq __stack_chk_fail 2139 ; LINUX-X64: .cfi_endproc 2140 2141 ; LINUX-KERNEL-X64-LABEL: test15a: 2142 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2143 ; LINUX-KERNEL-X64: .cfi_endproc 2144 2145 ; DARWIN-X64-LABEL: test15a: 2146 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2147 ; DARWIN-X64: .cfi_endproc 2148 2149 ; MSVC-I386-LABEL: test15a: 2150 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2151 ; MSVC-I386: retl 2152 %a = alloca i32, align 4 2153 %b = alloca float*, align 8 2154 store i32 0, i32* %a, align 4 2155 %0 = bitcast i32* %a to float* 2156 store float* %0, float** %b, align 8 2157 %1 = load float*, float** %b, align 8 2158 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), float* %1) 2159 ret void 2160 } 2161 2162 ; test15b: Addr-of a local cast to a ptr of a different type 2163 ; (e.g., int a; ... ; float *b = &a;) 2164 ; ssp attribute 2165 ; Requires no protector. 2166 ; Function Attrs: ssp 2167 define void @test15b() #0 { 2168 entry: 2169 ; LINUX-I386-LABEL: test15b: 2170 ; LINUX-I386-NOT: calll __stack_chk_fail 2171 ; LINUX-I386: .cfi_endproc 2172 2173 ; LINUX-X64-LABEL: test15b: 2174 ; LINUX-X64-NOT: callq __stack_chk_fail 2175 ; LINUX-X64: .cfi_endproc 2176 2177 ; LINUX-KERNEL-X64-LABEL: test15b: 2178 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2179 ; LINUX-KERNEL-X64: .cfi_endproc 2180 2181 ; DARWIN-X64-LABEL: test15b: 2182 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2183 ; DARWIN-X64: .cfi_endproc 2184 2185 ; MSVC-I386-LABEL: test15b: 2186 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2187 ; MSVC-I386: retl 2188 %a = alloca i32, align 4 2189 %b = alloca float*, align 8 2190 store i32 0, i32* %a, align 4 2191 %0 = bitcast i32* %a to float* 2192 store float* %0, float** %b, align 8 2193 %1 = load float*, float** %b, align 8 2194 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), float* %1) 2195 ret void 2196 } 2197 2198 ; test15c: Addr-of a local cast to a ptr of a different type 2199 ; (e.g., int a; ... ; float *b = &a;) 2200 ; sspstrong attribute 2201 ; Requires protector. 2202 ; Function Attrs: sspstrong 2203 define void @test15c() #1 { 2204 entry: 2205 ; LINUX-I386-LABEL: test15c: 2206 ; LINUX-I386: mov{{l|q}} %gs: 2207 ; LINUX-I386: calll __stack_chk_fail 2208 2209 ; LINUX-X64-LABEL: test15c: 2210 ; LINUX-X64: mov{{l|q}} %fs: 2211 ; LINUX-X64: callq __stack_chk_fail 2212 2213 ; LINUX-KERNEL-X64-LABEL: test15c: 2214 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2215 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2216 2217 ; DARWIN-X64-LABEL: test15c: 2218 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2219 ; DARWIN-X64: callq ___stack_chk_fail 2220 2221 ; MSVC-I386-LABEL: test15c: 2222 ; MSVC-I386: movl ___security_cookie, 2223 ; MSVC-I386: calll @__security_check_cookie@4 2224 %a = alloca i32, align 4 2225 %b = alloca float*, align 8 2226 store i32 0, i32* %a, align 4 2227 %0 = bitcast i32* %a to float* 2228 store float* %0, float** %b, align 8 2229 %1 = load float*, float** %b, align 8 2230 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), float* %1) 2231 ret void 2232 } 2233 2234 ; test15d: Addr-of a local cast to a ptr of a different type 2235 ; (e.g., int a; ... ; float *b = &a;) 2236 ; sspreq attribute 2237 ; Requires protector. 2238 ; Function Attrs: sspreq 2239 define void @test15d() #2 { 2240 entry: 2241 ; LINUX-I386-LABEL: test15d: 2242 ; LINUX-I386: mov{{l|q}} %gs: 2243 ; LINUX-I386: calll __stack_chk_fail 2244 2245 ; LINUX-X64-LABEL: test15d: 2246 ; LINUX-X64: mov{{l|q}} %fs: 2247 ; LINUX-X64: callq __stack_chk_fail 2248 2249 ; LINUX-KERNEL-X64-LABEL: test15d: 2250 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2251 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2252 2253 ; DARWIN-X64-LABEL: test15d: 2254 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2255 ; DARWIN-X64: callq ___stack_chk_fail 2256 2257 ; MSVC-I386-LABEL: test15d: 2258 ; MSVC-I386: movl ___security_cookie, 2259 ; MSVC-I386: calll @__security_check_cookie@4 2260 %a = alloca i32, align 4 2261 %b = alloca float*, align 8 2262 store i32 0, i32* %a, align 4 2263 %0 = bitcast i32* %a to float* 2264 store float* %0, float** %b, align 8 2265 %1 = load float*, float** %b, align 8 2266 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), float* %1) 2267 ret void 2268 } 2269 2270 ; test16a: Addr-of a local cast to a ptr of a different type (optimized) 2271 ; (e.g., int a; ... ; float *b = &a;) 2272 ; no ssp attribute 2273 ; Requires no protector. 2274 define void @test16a() { 2275 entry: 2276 ; LINUX-I386-LABEL: test16a: 2277 ; LINUX-I386-NOT: calll __stack_chk_fail 2278 ; LINUX-I386: .cfi_endproc 2279 2280 ; LINUX-X64-LABEL: test16a: 2281 ; LINUX-X64-NOT: callq __stack_chk_fail 2282 ; LINUX-X64: .cfi_endproc 2283 2284 ; LINUX-KERNEL-X64-LABEL: test16a: 2285 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2286 ; LINUX-KERNEL-X64: .cfi_endproc 2287 2288 ; DARWIN-X64-LABEL: test16a: 2289 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2290 ; DARWIN-X64: .cfi_endproc 2291 2292 ; MSVC-I386-LABEL: test16a: 2293 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2294 ; MSVC-I386: retl 2295 %a = alloca i32, align 4 2296 store i32 0, i32* %a, align 4 2297 %0 = bitcast i32* %a to float* 2298 call void @funfloat(float* %0) 2299 ret void 2300 } 2301 2302 ; test16b: Addr-of a local cast to a ptr of a different type (optimized) 2303 ; (e.g., int a; ... ; float *b = &a;) 2304 ; ssp attribute 2305 ; Requires no protector. 2306 ; Function Attrs: ssp 2307 define void @test16b() #0 { 2308 entry: 2309 ; LINUX-I386-LABEL: test16b: 2310 ; LINUX-I386-NOT: calll __stack_chk_fail 2311 ; LINUX-I386: .cfi_endproc 2312 2313 ; LINUX-X64-LABEL: test16b: 2314 ; LINUX-X64-NOT: callq __stack_chk_fail 2315 ; LINUX-X64: .cfi_endproc 2316 2317 ; LINUX-KERNEL-X64-LABEL: test16b: 2318 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2319 ; LINUX-KERNEL-X64: .cfi_endproc 2320 2321 ; DARWIN-X64-LABEL: test16b: 2322 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2323 ; DARWIN-X64: .cfi_endproc 2324 2325 ; MSVC-I386-LABEL: test16b: 2326 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2327 ; MSVC-I386: retl 2328 %a = alloca i32, align 4 2329 store i32 0, i32* %a, align 4 2330 %0 = bitcast i32* %a to float* 2331 call void @funfloat(float* %0) 2332 ret void 2333 } 2334 2335 ; test16c: Addr-of a local cast to a ptr of a different type (optimized) 2336 ; (e.g., int a; ... ; float *b = &a;) 2337 ; sspstrong attribute 2338 ; Requires protector. 2339 ; Function Attrs: sspstrong 2340 define void @test16c() #1 { 2341 entry: 2342 ; LINUX-I386-LABEL: test16c: 2343 ; LINUX-I386: mov{{l|q}} %gs: 2344 ; LINUX-I386: calll __stack_chk_fail 2345 2346 ; LINUX-X64-LABEL: test16c: 2347 ; LINUX-X64: mov{{l|q}} %fs: 2348 ; LINUX-X64: callq __stack_chk_fail 2349 2350 ; LINUX-KERNEL-X64-LABEL: test16c: 2351 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2352 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2353 2354 ; DARWIN-X64-LABEL: test16c: 2355 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2356 ; DARWIN-X64: callq ___stack_chk_fail 2357 2358 ; MSVC-I386-LABEL: test16c: 2359 ; MSVC-I386: movl ___security_cookie, 2360 ; MSVC-I386: calll @__security_check_cookie@4 2361 %a = alloca i32, align 4 2362 store i32 0, i32* %a, align 4 2363 %0 = bitcast i32* %a to float* 2364 call void @funfloat(float* %0) 2365 ret void 2366 } 2367 2368 ; test16d: Addr-of a local cast to a ptr of a different type (optimized) 2369 ; (e.g., int a; ... ; float *b = &a;) 2370 ; sspreq attribute 2371 ; Requires protector. 2372 ; Function Attrs: sspreq 2373 define void @test16d() #2 { 2374 entry: 2375 ; LINUX-I386-LABEL: test16d: 2376 ; LINUX-I386: mov{{l|q}} %gs: 2377 ; LINUX-I386: calll __stack_chk_fail 2378 2379 ; LINUX-X64-LABEL: test16d: 2380 ; LINUX-X64: mov{{l|q}} %fs: 2381 ; LINUX-X64: callq __stack_chk_fail 2382 2383 ; LINUX-KERNEL-X64-LABEL: test16d: 2384 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2385 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2386 2387 ; DARWIN-X64-LABEL: test16d: 2388 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2389 ; DARWIN-X64: callq ___stack_chk_fail 2390 2391 ; MSVC-I386-LABEL: test16d: 2392 ; MSVC-I386: movl ___security_cookie, 2393 ; MSVC-I386: calll @__security_check_cookie@4 2394 %a = alloca i32, align 4 2395 store i32 0, i32* %a, align 4 2396 %0 = bitcast i32* %a to float* 2397 call void @funfloat(float* %0) 2398 ret void 2399 } 2400 2401 ; test17a: Addr-of a vector nested in a struct 2402 ; no ssp attribute 2403 ; Requires no protector. 2404 define void @test17a() { 2405 entry: 2406 ; LINUX-I386-LABEL: test17a: 2407 ; LINUX-I386-NOT: calll __stack_chk_fail 2408 ; LINUX-I386: .cfi_endproc 2409 2410 ; LINUX-X64-LABEL: test17a: 2411 ; LINUX-X64-NOT: callq __stack_chk_fail 2412 ; LINUX-X64: .cfi_endproc 2413 2414 ; LINUX-KERNEL-X64-LABEL: test17a: 2415 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2416 ; LINUX-KERNEL-X64: .cfi_endproc 2417 2418 ; DARWIN-X64-LABEL: test17a: 2419 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2420 ; DARWIN-X64: .cfi_endproc 2421 2422 ; MSVC-I386-LABEL: test17a: 2423 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2424 ; MSVC-I386: retl 2425 %c = alloca %struct.vec, align 16 2426 %y = getelementptr inbounds %struct.vec, %struct.vec* %c, i64 0, i32 0 2427 %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12 2428 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) 2429 ret void 2430 } 2431 2432 ; test17b: Addr-of a vector nested in a struct 2433 ; ssp attribute 2434 ; Requires no protector. 2435 ; Function Attrs: ssp 2436 define void @test17b() #0 { 2437 entry: 2438 ; LINUX-I386-LABEL: test17b: 2439 ; LINUX-I386-NOT: calll __stack_chk_fail 2440 ; LINUX-I386: .cfi_endproc 2441 2442 ; LINUX-X64-LABEL: test17b: 2443 ; LINUX-X64-NOT: callq __stack_chk_fail 2444 ; LINUX-X64: .cfi_endproc 2445 2446 ; LINUX-KERNEL-X64-LABEL: test17b: 2447 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2448 ; LINUX-KERNEL-X64: .cfi_endproc 2449 2450 ; DARWIN-X64-LABEL: test17b: 2451 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2452 ; DARWIN-X64: .cfi_endproc 2453 2454 ; MSVC-I386-LABEL: test17b: 2455 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2456 ; MSVC-I386: retl 2457 %c = alloca %struct.vec, align 16 2458 %y = getelementptr inbounds %struct.vec, %struct.vec* %c, i64 0, i32 0 2459 %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12 2460 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) 2461 ret void 2462 } 2463 2464 ; test17c: Addr-of a vector nested in a struct 2465 ; sspstrong attribute 2466 ; Requires protector. 2467 ; Function Attrs: sspstrong 2468 define void @test17c() #1 { 2469 entry: 2470 ; LINUX-I386-LABEL: test17c: 2471 ; LINUX-I386: mov{{l|q}} %gs: 2472 ; LINUX-I386: calll __stack_chk_fail 2473 2474 ; LINUX-X64-LABEL: test17c: 2475 ; LINUX-X64: mov{{l|q}} %fs: 2476 ; LINUX-X64: callq __stack_chk_fail 2477 2478 ; LINUX-KERNEL-X64-LABEL: test17c: 2479 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2480 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2481 2482 ; DARWIN-X64-LABEL: test17c: 2483 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2484 ; DARWIN-X64: callq ___stack_chk_fail 2485 2486 ; MSVC-I386-LABEL: test17c: 2487 ; MSVC-I386: movl ___security_cookie, 2488 ; MSVC-I386: calll @__security_check_cookie@4 2489 %c = alloca %struct.vec, align 16 2490 %y = getelementptr inbounds %struct.vec, %struct.vec* %c, i64 0, i32 0 2491 %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12 2492 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) 2493 ret void 2494 } 2495 2496 ; test17d: Addr-of a vector nested in a struct 2497 ; sspreq attribute 2498 ; Requires protector. 2499 ; Function Attrs: sspreq 2500 define void @test17d() #2 { 2501 entry: 2502 ; LINUX-I386-LABEL: test17d: 2503 ; LINUX-I386: mov{{l|q}} %gs: 2504 ; LINUX-I386: calll __stack_chk_fail 2505 2506 ; LINUX-X64-LABEL: test17d: 2507 ; LINUX-X64: mov{{l|q}} %fs: 2508 ; LINUX-X64: callq __stack_chk_fail 2509 2510 ; LINUX-KERNEL-X64-LABEL: test17d: 2511 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2512 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2513 2514 ; DARWIN-X64-LABEL: test17d: 2515 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2516 ; DARWIN-X64: callq ___stack_chk_fail 2517 2518 ; MSVC-I386-LABEL: test17d: 2519 ; MSVC-I386: movl ___security_cookie, 2520 ; MSVC-I386: calll @__security_check_cookie@4 2521 %c = alloca %struct.vec, align 16 2522 %y = getelementptr inbounds %struct.vec, %struct.vec* %c, i64 0, i32 0 2523 %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12 2524 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) 2525 ret void 2526 } 2527 2528 ; test18a: Addr-of a variable passed into an invoke instruction. 2529 ; no ssp attribute 2530 ; Requires no protector. 2531 define i32 @test18a() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2532 entry: 2533 ; LINUX-I386-LABEL: test18a: 2534 ; LINUX-I386-NOT: calll __stack_chk_fail 2535 ; LINUX-I386: .cfi_endproc 2536 2537 ; LINUX-X64-LABEL: test18a: 2538 ; LINUX-X64-NOT: callq __stack_chk_fail 2539 ; LINUX-X64: .cfi_endproc 2540 2541 ; LINUX-KERNEL-X64-LABEL: test18a: 2542 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2543 ; LINUX-KERNEL-X64: .cfi_endproc 2544 2545 ; DARWIN-X64-LABEL: test18a: 2546 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2547 ; DARWIN-X64: .cfi_endproc 2548 2549 ; MSVC-I386-LABEL: test18a: 2550 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2551 ; MSVC-I386: retl 2552 %a = alloca i32, align 4 2553 %exn.slot = alloca i8* 2554 %ehselector.slot = alloca i32 2555 store i32 0, i32* %a, align 4 2556 invoke void @_Z3exceptPi(i32* %a) 2557 to label %invoke.cont unwind label %lpad 2558 2559 invoke.cont: 2560 ret i32 0 2561 2562 lpad: 2563 %0 = landingpad { i8*, i32 } 2564 catch i8* null 2565 ret i32 0 2566 } 2567 2568 ; test18b: Addr-of a variable passed into an invoke instruction. 2569 ; ssp attribute 2570 ; Requires no protector. 2571 ; Function Attrs: ssp 2572 define i32 @test18b() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2573 entry: 2574 ; LINUX-I386-LABEL: test18b: 2575 ; LINUX-I386-NOT: calll __stack_chk_fail 2576 ; LINUX-I386: .cfi_endproc 2577 2578 ; LINUX-X64-LABEL: test18b: 2579 ; LINUX-X64-NOT: callq __stack_chk_fail 2580 ; LINUX-X64: .cfi_endproc 2581 2582 ; LINUX-KERNEL-X64-LABEL: test18b: 2583 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2584 ; LINUX-KERNEL-X64: .cfi_endproc 2585 2586 ; DARWIN-X64-LABEL: test18b: 2587 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2588 ; DARWIN-X64: .cfi_endproc 2589 2590 ; MSVC-I386-LABEL: test18b: 2591 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2592 ; MSVC-I386: retl 2593 %a = alloca i32, align 4 2594 %exn.slot = alloca i8* 2595 %ehselector.slot = alloca i32 2596 store i32 0, i32* %a, align 4 2597 invoke void @_Z3exceptPi(i32* %a) 2598 to label %invoke.cont unwind label %lpad 2599 2600 invoke.cont: 2601 ret i32 0 2602 2603 lpad: 2604 %0 = landingpad { i8*, i32 } 2605 catch i8* null 2606 ret i32 0 2607 } 2608 2609 ; test18c: Addr-of a variable passed into an invoke instruction. 2610 ; sspstrong attribute 2611 ; Requires protector. 2612 ; Function Attrs: sspstrong 2613 define i32 @test18c() #1 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2614 entry: 2615 ; LINUX-I386-LABEL: test18c: 2616 ; LINUX-I386: mov{{l|q}} %gs: 2617 ; LINUX-I386: calll __stack_chk_fail 2618 2619 ; LINUX-X64-LABEL: test18c: 2620 ; LINUX-X64: mov{{l|q}} %fs: 2621 ; LINUX-X64: callq __stack_chk_fail 2622 2623 ; LINUX-KERNEL-X64-LABEL: test18c: 2624 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2625 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2626 2627 ; DARWIN-X64-LABEL: test18c: 2628 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2629 ; DARWIN-X64: callq ___stack_chk_fail 2630 2631 ; MSVC-I386-LABEL: test18c: 2632 ; MSVC-I386: movl ___security_cookie, 2633 ; MSVC-I386: calll @__security_check_cookie@4 2634 %a = alloca i32, align 4 2635 %exn.slot = alloca i8* 2636 %ehselector.slot = alloca i32 2637 store i32 0, i32* %a, align 4 2638 invoke void @_Z3exceptPi(i32* %a) 2639 to label %invoke.cont unwind label %lpad 2640 2641 invoke.cont: 2642 ret i32 0 2643 2644 lpad: 2645 %0 = landingpad { i8*, i32 } 2646 catch i8* null 2647 ret i32 0 2648 } 2649 2650 ; test18d: Addr-of a variable passed into an invoke instruction. 2651 ; sspreq attribute 2652 ; Requires protector. 2653 ; Function Attrs: sspreq 2654 define i32 @test18d() #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2655 entry: 2656 ; LINUX-I386-LABEL: test18d: 2657 ; LINUX-I386: mov{{l|q}} %gs: 2658 ; LINUX-I386: calll __stack_chk_fail 2659 2660 ; LINUX-X64-LABEL: test18d: 2661 ; LINUX-X64: mov{{l|q}} %fs: 2662 ; LINUX-X64: callq __stack_chk_fail 2663 2664 ; LINUX-KERNEL-X64-LABEL: test18d: 2665 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2666 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2667 2668 ; DARWIN-X64-LABEL: test18d: 2669 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2670 ; DARWIN-X64: callq ___stack_chk_fail 2671 2672 ; MSVC-I386-LABEL: test18d: 2673 ; MSVC-I386: movl ___security_cookie, 2674 ; MSVC-I386: calll @__security_check_cookie@4 2675 %a = alloca i32, align 4 2676 %exn.slot = alloca i8* 2677 %ehselector.slot = alloca i32 2678 store i32 0, i32* %a, align 4 2679 invoke void @_Z3exceptPi(i32* %a) 2680 to label %invoke.cont unwind label %lpad 2681 2682 invoke.cont: 2683 ret i32 0 2684 2685 lpad: 2686 %0 = landingpad { i8*, i32 } 2687 catch i8* null 2688 ret i32 0 2689 } 2690 ; test19a: Addr-of a struct element passed into an invoke instruction. 2691 ; (GEP followed by an invoke) 2692 ; no ssp attribute 2693 ; Requires no protector. 2694 define i32 @test19a() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2695 entry: 2696 ; LINUX-I386-LABEL: test19a: 2697 ; LINUX-I386-NOT: calll __stack_chk_fail 2698 ; LINUX-I386: .cfi_endproc 2699 2700 ; LINUX-X64-LABEL: test19a: 2701 ; LINUX-X64-NOT: callq __stack_chk_fail 2702 ; LINUX-X64: .cfi_endproc 2703 2704 ; LINUX-KERNEL-X64-LABEL: test19a: 2705 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2706 ; LINUX-KERNEL-X64: .cfi_endproc 2707 2708 ; DARWIN-X64-LABEL: test19a: 2709 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2710 ; DARWIN-X64: .cfi_endproc 2711 2712 ; MSVC-I386-LABEL: test19a: 2713 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2714 ; MSVC-I386: retl 2715 %c = alloca %struct.pair, align 4 2716 %exn.slot = alloca i8* 2717 %ehselector.slot = alloca i32 2718 %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2719 store i32 0, i32* %a, align 4 2720 %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2721 invoke void @_Z3exceptPi(i32* %a1) 2722 to label %invoke.cont unwind label %lpad 2723 2724 invoke.cont: 2725 ret i32 0 2726 2727 lpad: 2728 %0 = landingpad { i8*, i32 } 2729 catch i8* null 2730 ret i32 0 2731 } 2732 2733 ; test19b: Addr-of a struct element passed into an invoke instruction. 2734 ; (GEP followed by an invoke) 2735 ; ssp attribute 2736 ; Requires no protector. 2737 ; Function Attrs: ssp 2738 define i32 @test19b() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2739 entry: 2740 ; LINUX-I386-LABEL: test19b: 2741 ; LINUX-I386-NOT: calll __stack_chk_fail 2742 ; LINUX-I386: .cfi_endproc 2743 2744 ; LINUX-X64-LABEL: test19b: 2745 ; LINUX-X64-NOT: callq __stack_chk_fail 2746 ; LINUX-X64: .cfi_endproc 2747 2748 ; LINUX-KERNEL-X64-LABEL: test19b: 2749 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2750 ; LINUX-KERNEL-X64: .cfi_endproc 2751 2752 ; DARWIN-X64-LABEL: test19b: 2753 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2754 ; DARWIN-X64: .cfi_endproc 2755 2756 ; MSVC-I386-LABEL: test19b: 2757 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2758 ; MSVC-I386: retl 2759 %c = alloca %struct.pair, align 4 2760 %exn.slot = alloca i8* 2761 %ehselector.slot = alloca i32 2762 %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2763 store i32 0, i32* %a, align 4 2764 %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2765 invoke void @_Z3exceptPi(i32* %a1) 2766 to label %invoke.cont unwind label %lpad 2767 2768 invoke.cont: 2769 ret i32 0 2770 2771 lpad: 2772 %0 = landingpad { i8*, i32 } 2773 catch i8* null 2774 ret i32 0 2775 } 2776 2777 ; test19c: Addr-of a struct element passed into an invoke instruction. 2778 ; (GEP followed by an invoke) 2779 ; sspstrong attribute 2780 ; Requires protector. 2781 ; Function Attrs: sspstrong 2782 define i32 @test19c() #1 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2783 entry: 2784 ; LINUX-I386-LABEL: test19c: 2785 ; LINUX-I386: mov{{l|q}} %gs: 2786 ; LINUX-I386: calll __stack_chk_fail 2787 2788 ; LINUX-X64-LABEL: test19c: 2789 ; LINUX-X64: mov{{l|q}} %fs: 2790 ; LINUX-X64: callq __stack_chk_fail 2791 2792 ; LINUX-KERNEL-X64-LABEL: test19c: 2793 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2794 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2795 2796 ; DARWIN-X64-LABEL: test19c: 2797 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2798 ; DARWIN-X64: callq ___stack_chk_fail 2799 2800 ; MSVC-I386-LABEL: test19c: 2801 ; MSVC-I386: movl ___security_cookie, 2802 ; MSVC-I386: calll @__security_check_cookie@4 2803 %c = alloca %struct.pair, align 4 2804 %exn.slot = alloca i8* 2805 %ehselector.slot = alloca i32 2806 %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2807 store i32 0, i32* %a, align 4 2808 %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2809 invoke void @_Z3exceptPi(i32* %a1) 2810 to label %invoke.cont unwind label %lpad 2811 2812 invoke.cont: 2813 ret i32 0 2814 2815 lpad: 2816 %0 = landingpad { i8*, i32 } 2817 catch i8* null 2818 ret i32 0 2819 } 2820 2821 ; test19d: Addr-of a struct element passed into an invoke instruction. 2822 ; (GEP followed by an invoke) 2823 ; sspreq attribute 2824 ; Requires protector. 2825 ; Function Attrs: sspreq 2826 define i32 @test19d() #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { 2827 entry: 2828 ; LINUX-I386-LABEL: test19d: 2829 ; LINUX-I386: mov{{l|q}} %gs: 2830 ; LINUX-I386: calll __stack_chk_fail 2831 ; LINUX-I386-NOT: calll __stack_chk_fail 2832 2833 ; LINUX-X64-LABEL: test19d: 2834 ; LINUX-X64: mov{{l|q}} %fs: 2835 ; LINUX-X64: callq __stack_chk_fail 2836 ; LINUX-X64-NOT: callq __stack_chk_fail 2837 2838 ; LINUX-KERNEL-X64-LABEL: test19d: 2839 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2840 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2841 ; LINUX-KERNEL-X64-NOT: callq ___stack_chk_fail 2842 2843 ; DARWIN-X64-LABEL: test19d: 2844 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2845 ; DARWIN-X64: callq ___stack_chk_fail 2846 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2847 2848 ; MSVC-I386-LABEL: test19d: 2849 ; MSVC-I386: movl ___security_cookie, 2850 ; MSVC-I386: calll @__security_check_cookie@4 2851 2852 ; MINGW-X64-LABEL: test19d: 2853 ; MINGW-X64: mov{{l|q}} __stack_chk_guard 2854 ; MINGW-X64: callq __stack_chk_fail 2855 2856 %c = alloca %struct.pair, align 4 2857 %exn.slot = alloca i8* 2858 %ehselector.slot = alloca i32 2859 %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2860 store i32 0, i32* %a, align 4 2861 %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0 2862 invoke void @_Z3exceptPi(i32* %a1) 2863 to label %invoke.cont unwind label %lpad 2864 2865 invoke.cont: 2866 ret i32 0 2867 2868 lpad: 2869 %0 = landingpad { i8*, i32 } 2870 catch i8* null 2871 ret i32 0 2872 } 2873 2874 ; test20a: Addr-of a pointer 2875 ; no ssp attribute 2876 ; Requires no protector. 2877 define void @test20a() { 2878 entry: 2879 ; LINUX-I386-LABEL: test20a: 2880 ; LINUX-I386-NOT: calll __stack_chk_fail 2881 ; LINUX-I386: .cfi_endproc 2882 2883 ; LINUX-X64-LABEL: test20a: 2884 ; LINUX-X64-NOT: callq __stack_chk_fail 2885 ; LINUX-X64: .cfi_endproc 2886 2887 ; LINUX-KERNEL-X64-LABEL: test20a: 2888 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2889 ; LINUX-KERNEL-X64: .cfi_endproc 2890 2891 ; DARWIN-X64-LABEL: test20a: 2892 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2893 ; DARWIN-X64: .cfi_endproc 2894 2895 ; MSVC-I386-LABEL: test20a: 2896 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2897 ; MSVC-I386: retl 2898 %a = alloca i32*, align 8 2899 %b = alloca i32**, align 8 2900 %call = call i32* @getp() 2901 store i32* %call, i32** %a, align 8 2902 store i32** %a, i32*** %b, align 8 2903 %0 = load i32**, i32*** %b, align 8 2904 call void @funcall2(i32** %0) 2905 ret void 2906 } 2907 2908 ; test20b: Addr-of a pointer 2909 ; ssp attribute 2910 ; Requires no protector. 2911 ; Function Attrs: ssp 2912 define void @test20b() #0 { 2913 entry: 2914 ; LINUX-I386-LABEL: test20b: 2915 ; LINUX-I386-NOT: calll __stack_chk_fail 2916 ; LINUX-I386: .cfi_endproc 2917 2918 ; LINUX-X64-LABEL: test20b: 2919 ; LINUX-X64-NOT: callq __stack_chk_fail 2920 ; LINUX-X64: .cfi_endproc 2921 2922 ; LINUX-KERNEL-X64-LABEL: test20b: 2923 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2924 ; LINUX-KERNEL-X64: .cfi_endproc 2925 2926 ; DARWIN-X64-LABEL: test20b: 2927 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2928 ; DARWIN-X64: .cfi_endproc 2929 2930 ; MSVC-I386-LABEL: test20b: 2931 ; MSVC-I386-NOT: calll @__security_check_cookie@4 2932 ; MSVC-I386: retl 2933 %a = alloca i32*, align 8 2934 %b = alloca i32**, align 8 2935 %call = call i32* @getp() 2936 store i32* %call, i32** %a, align 8 2937 store i32** %a, i32*** %b, align 8 2938 %0 = load i32**, i32*** %b, align 8 2939 call void @funcall2(i32** %0) 2940 ret void 2941 } 2942 2943 ; test20c: Addr-of a pointer 2944 ; sspstrong attribute 2945 ; Requires protector. 2946 ; Function Attrs: sspstrong 2947 define void @test20c() #1 { 2948 entry: 2949 ; LINUX-I386-LABEL: test20c: 2950 ; LINUX-I386: mov{{l|q}} %gs: 2951 ; LINUX-I386: calll __stack_chk_fail 2952 2953 ; LINUX-X64-LABEL: test20c: 2954 ; LINUX-X64: mov{{l|q}} %fs: 2955 ; LINUX-X64: callq __stack_chk_fail 2956 2957 ; LINUX-KERNEL-X64-LABEL: test20c: 2958 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2959 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2960 2961 ; DARWIN-X64-LABEL: test20c: 2962 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2963 ; DARWIN-X64: callq ___stack_chk_fail 2964 2965 ; MSVC-I386-LABEL: test20c: 2966 ; MSVC-I386: movl ___security_cookie, 2967 ; MSVC-I386: calll @__security_check_cookie@4 2968 %a = alloca i32*, align 8 2969 %b = alloca i32**, align 8 2970 %call = call i32* @getp() 2971 store i32* %call, i32** %a, align 8 2972 store i32** %a, i32*** %b, align 8 2973 %0 = load i32**, i32*** %b, align 8 2974 call void @funcall2(i32** %0) 2975 ret void 2976 } 2977 2978 ; test20d: Addr-of a pointer 2979 ; sspreq attribute 2980 ; Requires protector. 2981 ; Function Attrs: sspreq 2982 define void @test20d() #2 { 2983 entry: 2984 ; LINUX-I386-LABEL: test20d: 2985 ; LINUX-I386: mov{{l|q}} %gs: 2986 ; LINUX-I386: calll __stack_chk_fail 2987 2988 ; LINUX-X64-LABEL: test20d: 2989 ; LINUX-X64: mov{{l|q}} %fs: 2990 ; LINUX-X64: callq __stack_chk_fail 2991 2992 ; LINUX-KERNEL-X64-LABEL: test20d: 2993 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2994 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2995 2996 ; DARWIN-X64-LABEL: test20d: 2997 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2998 ; DARWIN-X64: callq ___stack_chk_fail 2999 3000 ; MSVC-I386-LABEL: test20d: 3001 ; MSVC-I386: movl ___security_cookie, 3002 ; MSVC-I386: calll @__security_check_cookie@4 3003 %a = alloca i32*, align 8 3004 %b = alloca i32**, align 8 3005 %call = call i32* @getp() 3006 store i32* %call, i32** %a, align 8 3007 store i32** %a, i32*** %b, align 8 3008 %0 = load i32**, i32*** %b, align 8 3009 call void @funcall2(i32** %0) 3010 ret void 3011 } 3012 3013 ; test21a: Addr-of a casted pointer 3014 ; no ssp attribute 3015 ; Requires no protector. 3016 define void @test21a() { 3017 entry: 3018 ; LINUX-I386-LABEL: test21a: 3019 ; LINUX-I386-NOT: calll __stack_chk_fail 3020 ; LINUX-I386: .cfi_endproc 3021 3022 ; LINUX-X64-LABEL: test21a: 3023 ; LINUX-X64-NOT: callq __stack_chk_fail 3024 ; LINUX-X64: .cfi_endproc 3025 3026 ; LINUX-KERNEL-X64-LABEL: test21a: 3027 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3028 ; LINUX-KERNEL-X64: .cfi_endproc 3029 3030 ; DARWIN-X64-LABEL: test21a: 3031 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3032 ; DARWIN-X64: .cfi_endproc 3033 3034 ; MSVC-I386-LABEL: test21a: 3035 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3036 ; MSVC-I386: retl 3037 %a = alloca i32*, align 8 3038 %b = alloca float**, align 8 3039 %call = call i32* @getp() 3040 store i32* %call, i32** %a, align 8 3041 %0 = bitcast i32** %a to float** 3042 store float** %0, float*** %b, align 8 3043 %1 = load float**, float*** %b, align 8 3044 call void @funfloat2(float** %1) 3045 ret void 3046 } 3047 3048 ; test21b: Addr-of a casted pointer 3049 ; ssp attribute 3050 ; Requires no protector. 3051 ; Function Attrs: ssp 3052 define void @test21b() #0 { 3053 entry: 3054 ; LINUX-I386-LABEL: test21b: 3055 ; LINUX-I386-NOT: calll __stack_chk_fail 3056 ; LINUX-I386: .cfi_endproc 3057 3058 ; LINUX-X64-LABEL: test21b: 3059 ; LINUX-X64-NOT: callq __stack_chk_fail 3060 ; LINUX-X64: .cfi_endproc 3061 3062 ; LINUX-KERNEL-X64-LABEL: test21b: 3063 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3064 ; LINUX-KERNEL-X64: .cfi_endproc 3065 3066 ; DARWIN-X64-LABEL: test21b: 3067 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3068 ; DARWIN-X64: .cfi_endproc 3069 3070 ; MSVC-I386-LABEL: test21b: 3071 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3072 ; MSVC-I386: retl 3073 %a = alloca i32*, align 8 3074 %b = alloca float**, align 8 3075 %call = call i32* @getp() 3076 store i32* %call, i32** %a, align 8 3077 %0 = bitcast i32** %a to float** 3078 store float** %0, float*** %b, align 8 3079 %1 = load float**, float*** %b, align 8 3080 call void @funfloat2(float** %1) 3081 ret void 3082 } 3083 3084 ; test21c: Addr-of a casted pointer 3085 ; sspstrong attribute 3086 ; Requires protector. 3087 ; Function Attrs: sspstrong 3088 define void @test21c() #1 { 3089 entry: 3090 ; LINUX-I386-LABEL: test21c: 3091 ; LINUX-I386: mov{{l|q}} %gs: 3092 ; LINUX-I386: calll __stack_chk_fail 3093 3094 ; LINUX-X64-LABEL: test21c: 3095 ; LINUX-X64: mov{{l|q}} %fs: 3096 ; LINUX-X64: callq __stack_chk_fail 3097 3098 ; LINUX-KERNEL-X64-LABEL: test21c: 3099 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3100 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3101 3102 ; DARWIN-X64-LABEL: test21c: 3103 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3104 ; DARWIN-X64: callq ___stack_chk_fail 3105 3106 ; MSVC-I386-LABEL: test21c: 3107 ; MSVC-I386: movl ___security_cookie, 3108 ; MSVC-I386: calll @__security_check_cookie@4 3109 %a = alloca i32*, align 8 3110 %b = alloca float**, align 8 3111 %call = call i32* @getp() 3112 store i32* %call, i32** %a, align 8 3113 %0 = bitcast i32** %a to float** 3114 store float** %0, float*** %b, align 8 3115 %1 = load float**, float*** %b, align 8 3116 call void @funfloat2(float** %1) 3117 ret void 3118 } 3119 3120 ; test21d: Addr-of a casted pointer 3121 ; sspreq attribute 3122 ; Requires protector. 3123 ; Function Attrs: sspreq 3124 define void @test21d() #2 { 3125 entry: 3126 ; LINUX-I386-LABEL: test21d: 3127 ; LINUX-I386: mov{{l|q}} %gs: 3128 ; LINUX-I386: calll __stack_chk_fail 3129 3130 ; LINUX-X64-LABEL: test21d: 3131 ; LINUX-X64: mov{{l|q}} %fs: 3132 ; LINUX-X64: callq __stack_chk_fail 3133 3134 ; LINUX-KERNEL-X64-LABEL: test21d: 3135 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3136 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3137 3138 ; DARWIN-X64-LABEL: test21d: 3139 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3140 ; DARWIN-X64: callq ___stack_chk_fail 3141 3142 ; MSVC-I386-LABEL: test21d: 3143 ; MSVC-I386: movl ___security_cookie, 3144 ; MSVC-I386: calll @__security_check_cookie@4 3145 %a = alloca i32*, align 8 3146 %b = alloca float**, align 8 3147 %call = call i32* @getp() 3148 store i32* %call, i32** %a, align 8 3149 %0 = bitcast i32** %a to float** 3150 store float** %0, float*** %b, align 8 3151 %1 = load float**, float*** %b, align 8 3152 call void @funfloat2(float** %1) 3153 ret void 3154 } 3155 3156 ; test22a: [2 x i8] in a class 3157 ; no ssp attribute 3158 ; Requires no protector. 3159 define signext i8 @test22a() { 3160 entry: 3161 ; LINUX-I386-LABEL: test22a: 3162 ; LINUX-I386-NOT: calll __stack_chk_fail 3163 ; LINUX-I386: .cfi_endproc 3164 3165 ; LINUX-X64-LABEL: test22a: 3166 ; LINUX-X64-NOT: callq __stack_chk_fail 3167 ; LINUX-X64: .cfi_endproc 3168 3169 ; LINUX-KERNEL-X64-LABEL: test22a: 3170 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3171 ; LINUX-KERNEL-X64: .cfi_endproc 3172 3173 ; DARWIN-X64-LABEL: test22a: 3174 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3175 ; DARWIN-X64: .cfi_endproc 3176 3177 ; MSVC-I386-LABEL: test22a: 3178 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3179 ; MSVC-I386: retl 3180 %a = alloca %class.A, align 1 3181 %array = getelementptr inbounds %class.A, %class.A* %a, i32 0, i32 0 3182 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3183 %0 = load i8, i8* %arrayidx, align 1 3184 ret i8 %0 3185 } 3186 3187 ; test22b: [2 x i8] in a class 3188 ; ssp attribute 3189 ; Requires no protector. 3190 ; Function Attrs: ssp 3191 define signext i8 @test22b() #0 { 3192 entry: 3193 ; LINUX-I386-LABEL: test22b: 3194 ; LINUX-I386-NOT: calll __stack_chk_fail 3195 ; LINUX-I386: .cfi_endproc 3196 3197 ; LINUX-X64-LABEL: test22b: 3198 ; LINUX-X64-NOT: callq __stack_chk_fail 3199 ; LINUX-X64: .cfi_endproc 3200 3201 ; LINUX-KERNEL-X64-LABEL: test22b: 3202 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3203 ; LINUX-KERNEL-X64: .cfi_endproc 3204 3205 ; DARWIN-X64-LABEL: test22b: 3206 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3207 ; DARWIN-X64: .cfi_endproc 3208 3209 ; MSVC-I386-LABEL: test22b: 3210 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3211 ; MSVC-I386: retl 3212 %a = alloca %class.A, align 1 3213 %array = getelementptr inbounds %class.A, %class.A* %a, i32 0, i32 0 3214 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3215 %0 = load i8, i8* %arrayidx, align 1 3216 ret i8 %0 3217 } 3218 3219 ; test22c: [2 x i8] in a class 3220 ; sspstrong attribute 3221 ; Requires protector. 3222 ; Function Attrs: sspstrong 3223 define signext i8 @test22c() #1 { 3224 entry: 3225 ; LINUX-I386-LABEL: test22c: 3226 ; LINUX-I386: mov{{l|q}} %gs: 3227 ; LINUX-I386: calll __stack_chk_fail 3228 3229 ; LINUX-X64-LABEL: test22c: 3230 ; LINUX-X64: mov{{l|q}} %fs: 3231 ; LINUX-X64: callq __stack_chk_fail 3232 3233 ; LINUX-KERNEL-X64-LABEL: test22c: 3234 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3235 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3236 3237 ; DARWIN-X64-LABEL: test22c: 3238 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3239 ; DARWIN-X64: callq ___stack_chk_fail 3240 3241 ; MSVC-I386-LABEL: test22c: 3242 ; MSVC-I386: movl ___security_cookie, 3243 ; MSVC-I386: calll @__security_check_cookie@4 3244 %a = alloca %class.A, align 1 3245 %array = getelementptr inbounds %class.A, %class.A* %a, i32 0, i32 0 3246 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3247 %0 = load i8, i8* %arrayidx, align 1 3248 ret i8 %0 3249 } 3250 3251 ; test22d: [2 x i8] in a class 3252 ; sspreq attribute 3253 ; Requires protector. 3254 ; Function Attrs: sspreq 3255 define signext i8 @test22d() #2 { 3256 entry: 3257 ; LINUX-I386-LABEL: test22d: 3258 ; LINUX-I386: mov{{l|q}} %gs: 3259 ; LINUX-I386: calll __stack_chk_fail 3260 3261 ; LINUX-X64-LABEL: test22d: 3262 ; LINUX-X64: mov{{l|q}} %fs: 3263 ; LINUX-X64: callq __stack_chk_fail 3264 3265 ; LINUX-KERNEL-X64-LABEL: test22d: 3266 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3267 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3268 3269 ; DARWIN-X64-LABEL: test22d: 3270 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3271 ; DARWIN-X64: callq ___stack_chk_fail 3272 3273 ; MSVC-I386-LABEL: test22d: 3274 ; MSVC-I386: movl ___security_cookie, 3275 ; MSVC-I386: calll @__security_check_cookie@4 3276 %a = alloca %class.A, align 1 3277 %array = getelementptr inbounds %class.A, %class.A* %a, i32 0, i32 0 3278 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3279 %0 = load i8, i8* %arrayidx, align 1 3280 ret i8 %0 3281 } 3282 3283 ; test23a: [2 x i8] nested in several layers of structs and unions 3284 ; no ssp attribute 3285 ; Requires no protector. 3286 define signext i8 @test23a() { 3287 entry: 3288 ; LINUX-I386-LABEL: test23a: 3289 ; LINUX-I386-NOT: calll __stack_chk_fail 3290 ; LINUX-I386: .cfi_endproc 3291 3292 ; LINUX-X64-LABEL: test23a: 3293 ; LINUX-X64-NOT: callq __stack_chk_fail 3294 ; LINUX-X64: .cfi_endproc 3295 3296 ; LINUX-KERNEL-X64-LABEL: test23a: 3297 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3298 ; LINUX-KERNEL-X64: .cfi_endproc 3299 3300 ; DARWIN-X64-LABEL: test23a: 3301 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3302 ; DARWIN-X64: .cfi_endproc 3303 3304 ; MSVC-I386-LABEL: test23a: 3305 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3306 ; MSVC-I386: retl 3307 %x = alloca %struct.deep, align 1 3308 %b = getelementptr inbounds %struct.deep, %struct.deep* %x, i32 0, i32 0 3309 %c = bitcast %union.anon* %b to %struct.anon* 3310 %d = getelementptr inbounds %struct.anon, %struct.anon* %c, i32 0, i32 0 3311 %e = getelementptr inbounds %struct.anon.0, %struct.anon.0* %d, i32 0, i32 0 3312 %array = bitcast %union.anon.1* %e to [2 x i8]* 3313 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3314 %0 = load i8, i8* %arrayidx, align 1 3315 ret i8 %0 3316 } 3317 3318 ; test23b: [2 x i8] nested in several layers of structs and unions 3319 ; ssp attribute 3320 ; Requires no protector. 3321 ; Function Attrs: ssp 3322 define signext i8 @test23b() #0 { 3323 entry: 3324 ; LINUX-I386-LABEL: test23b: 3325 ; LINUX-I386-NOT: calll __stack_chk_fail 3326 ; LINUX-I386: .cfi_endproc 3327 3328 ; LINUX-X64-LABEL: test23b: 3329 ; LINUX-X64-NOT: callq __stack_chk_fail 3330 ; LINUX-X64: .cfi_endproc 3331 3332 ; LINUX-KERNEL-X64-LABEL: test23b: 3333 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3334 ; LINUX-KERNEL-X64: .cfi_endproc 3335 3336 ; DARWIN-X64-LABEL: test23b: 3337 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3338 ; DARWIN-X64: .cfi_endproc 3339 3340 ; MSVC-I386-LABEL: test23b: 3341 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3342 ; MSVC-I386: retl 3343 %x = alloca %struct.deep, align 1 3344 %b = getelementptr inbounds %struct.deep, %struct.deep* %x, i32 0, i32 0 3345 %c = bitcast %union.anon* %b to %struct.anon* 3346 %d = getelementptr inbounds %struct.anon, %struct.anon* %c, i32 0, i32 0 3347 %e = getelementptr inbounds %struct.anon.0, %struct.anon.0* %d, i32 0, i32 0 3348 %array = bitcast %union.anon.1* %e to [2 x i8]* 3349 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3350 %0 = load i8, i8* %arrayidx, align 1 3351 ret i8 %0 3352 } 3353 3354 ; test23c: [2 x i8] nested in several layers of structs and unions 3355 ; sspstrong attribute 3356 ; Requires protector. 3357 ; Function Attrs: sspstrong 3358 define signext i8 @test23c() #1 { 3359 entry: 3360 ; LINUX-I386-LABEL: test23c: 3361 ; LINUX-I386: mov{{l|q}} %gs: 3362 ; LINUX-I386: calll __stack_chk_fail 3363 3364 ; LINUX-X64-LABEL: test23c: 3365 ; LINUX-X64: mov{{l|q}} %fs: 3366 ; LINUX-X64: callq __stack_chk_fail 3367 3368 ; LINUX-KERNEL-X64-LABEL: test23c: 3369 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3370 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3371 3372 ; DARWIN-X64-LABEL: test23c: 3373 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3374 ; DARWIN-X64: callq ___stack_chk_fail 3375 3376 ; MSVC-I386-LABEL: test23c: 3377 ; MSVC-I386: movl ___security_cookie, 3378 ; MSVC-I386: calll @__security_check_cookie@4 3379 %x = alloca %struct.deep, align 1 3380 %b = getelementptr inbounds %struct.deep, %struct.deep* %x, i32 0, i32 0 3381 %c = bitcast %union.anon* %b to %struct.anon* 3382 %d = getelementptr inbounds %struct.anon, %struct.anon* %c, i32 0, i32 0 3383 %e = getelementptr inbounds %struct.anon.0, %struct.anon.0* %d, i32 0, i32 0 3384 %array = bitcast %union.anon.1* %e to [2 x i8]* 3385 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3386 %0 = load i8, i8* %arrayidx, align 1 3387 ret i8 %0 3388 } 3389 3390 ; test23d: [2 x i8] nested in several layers of structs and unions 3391 ; sspreq attribute 3392 ; Requires protector. 3393 ; Function Attrs: sspreq 3394 define signext i8 @test23d() #2 { 3395 entry: 3396 ; LINUX-I386-LABEL: test23d: 3397 ; LINUX-I386: mov{{l|q}} %gs: 3398 ; LINUX-I386: calll __stack_chk_fail 3399 3400 ; LINUX-X64-LABEL: test23d: 3401 ; LINUX-X64: mov{{l|q}} %fs: 3402 ; LINUX-X64: callq __stack_chk_fail 3403 3404 ; LINUX-KERNEL-X64-LABEL: test23d: 3405 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3406 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3407 3408 ; DARWIN-X64-LABEL: test23d: 3409 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3410 ; DARWIN-X64: callq ___stack_chk_fail 3411 3412 ; MSVC-I386-LABEL: test23d: 3413 ; MSVC-I386: movl ___security_cookie, 3414 ; MSVC-I386: calll @__security_check_cookie@4 3415 %x = alloca %struct.deep, align 1 3416 %b = getelementptr inbounds %struct.deep, %struct.deep* %x, i32 0, i32 0 3417 %c = bitcast %union.anon* %b to %struct.anon* 3418 %d = getelementptr inbounds %struct.anon, %struct.anon* %c, i32 0, i32 0 3419 %e = getelementptr inbounds %struct.anon.0, %struct.anon.0* %d, i32 0, i32 0 3420 %array = bitcast %union.anon.1* %e to [2 x i8]* 3421 %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0 3422 %0 = load i8, i8* %arrayidx, align 1 3423 ret i8 %0 3424 } 3425 3426 ; test24a: Variable sized alloca 3427 ; no ssp attribute 3428 ; Requires no protector. 3429 define void @test24a(i32 %n) { 3430 entry: 3431 ; LINUX-I386-LABEL: test24a: 3432 ; LINUX-I386-NOT: calll __stack_chk_fail 3433 ; LINUX-I386: .cfi_endproc 3434 3435 ; LINUX-X64-LABEL: test24a: 3436 ; LINUX-X64-NOT: callq __stack_chk_fail 3437 ; LINUX-X64: .cfi_endproc 3438 3439 ; LINUX-KERNEL-X64-LABEL: test24a: 3440 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3441 ; LINUX-KERNEL-X64: .cfi_endproc 3442 3443 ; DARWIN-X64-LABEL: test24a: 3444 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3445 ; DARWIN-X64: .cfi_endproc 3446 3447 ; MSVC-I386-LABEL: test24a: 3448 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3449 ; MSVC-I386: retl 3450 %n.addr = alloca i32, align 4 3451 %a = alloca i32*, align 8 3452 store i32 %n, i32* %n.addr, align 4 3453 %0 = load i32, i32* %n.addr, align 4 3454 %conv = sext i32 %0 to i64 3455 %1 = alloca i8, i64 %conv 3456 %2 = bitcast i8* %1 to i32* 3457 store i32* %2, i32** %a, align 8 3458 ret void 3459 } 3460 3461 ; test24b: Variable sized alloca 3462 ; ssp attribute 3463 ; Requires protector. 3464 ; Function Attrs: ssp 3465 define void @test24b(i32 %n) #0 { 3466 entry: 3467 ; LINUX-I386-LABEL: test24b: 3468 ; LINUX-I386: mov{{l|q}} %gs: 3469 ; LINUX-I386: calll __stack_chk_fail 3470 3471 ; LINUX-X64-LABEL: test24b: 3472 ; LINUX-X64: mov{{l|q}} %fs: 3473 ; LINUX-X64: callq __stack_chk_fail 3474 3475 ; LINUX-KERNEL-X64-LABEL: test24b: 3476 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3477 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3478 3479 ; DARWIN-X64-LABEL: test24b: 3480 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3481 ; DARWIN-X64: callq ___stack_chk_fail 3482 3483 ; MSVC-I386-LABEL: test24b: 3484 ; MSVC-I386: movl ___security_cookie, 3485 ; MSVC-I386: calll @__security_check_cookie@4 3486 %n.addr = alloca i32, align 4 3487 %a = alloca i32*, align 8 3488 store i32 %n, i32* %n.addr, align 4 3489 %0 = load i32, i32* %n.addr, align 4 3490 %conv = sext i32 %0 to i64 3491 %1 = alloca i8, i64 %conv 3492 %2 = bitcast i8* %1 to i32* 3493 store i32* %2, i32** %a, align 8 3494 ret void 3495 } 3496 3497 ; test24c: Variable sized alloca 3498 ; sspstrong attribute 3499 ; Requires protector. 3500 ; Function Attrs: sspstrong 3501 define void @test24c(i32 %n) #1 { 3502 entry: 3503 ; LINUX-I386-LABEL: test24c: 3504 ; LINUX-I386: mov{{l|q}} %gs: 3505 ; LINUX-I386: calll __stack_chk_fail 3506 3507 ; LINUX-X64-LABEL: test24c: 3508 ; LINUX-X64: mov{{l|q}} %fs: 3509 ; LINUX-X64: callq __stack_chk_fail 3510 3511 ; LINUX-KERNEL-X64-LABEL: test24c: 3512 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3513 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3514 3515 ; DARWIN-X64-LABEL: test24c: 3516 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3517 ; DARWIN-X64: callq ___stack_chk_fail 3518 3519 ; MSVC-I386-LABEL: test24c: 3520 ; MSVC-I386: movl ___security_cookie, 3521 ; MSVC-I386: calll @__security_check_cookie@4 3522 %n.addr = alloca i32, align 4 3523 %a = alloca i32*, align 8 3524 store i32 %n, i32* %n.addr, align 4 3525 %0 = load i32, i32* %n.addr, align 4 3526 %conv = sext i32 %0 to i64 3527 %1 = alloca i8, i64 %conv 3528 %2 = bitcast i8* %1 to i32* 3529 store i32* %2, i32** %a, align 8 3530 ret void 3531 } 3532 3533 ; test24d: Variable sized alloca 3534 ; sspreq attribute 3535 ; Requires protector. 3536 ; Function Attrs: sspreq 3537 define void @test24d(i32 %n) #2 { 3538 entry: 3539 ; LINUX-I386-LABEL: test24d: 3540 ; LINUX-I386: mov{{l|q}} %gs: 3541 ; LINUX-I386: calll __stack_chk_fail 3542 3543 ; LINUX-X64-LABEL: test24d: 3544 ; LINUX-X64: mov{{l|q}} %fs: 3545 ; LINUX-X64: callq __stack_chk_fail 3546 3547 ; LINUX-KERNEL-X64-LABEL: test24d: 3548 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3549 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3550 3551 ; DARWIN-X64-LABEL: test24d: 3552 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3553 ; DARWIN-X64: callq ___stack_chk_fail 3554 3555 ; MSVC-I386-LABEL: test24d: 3556 ; MSVC-I386: movl ___security_cookie, 3557 ; MSVC-I386: calll @__security_check_cookie@4 3558 %n.addr = alloca i32, align 4 3559 %a = alloca i32*, align 8 3560 store i32 %n, i32* %n.addr, align 4 3561 %0 = load i32, i32* %n.addr, align 4 3562 %conv = sext i32 %0 to i64 3563 %1 = alloca i8, i64 %conv 3564 %2 = bitcast i8* %1 to i32* 3565 store i32* %2, i32** %a, align 8 3566 ret void 3567 } 3568 3569 ; test25a: array of [4 x i32] 3570 ; no ssp attribute 3571 ; Requires no protector. 3572 define i32 @test25a() { 3573 entry: 3574 ; LINUX-I386-LABEL: test25a: 3575 ; LINUX-I386-NOT: calll __stack_chk_fail 3576 ; LINUX-I386: .cfi_endproc 3577 3578 ; LINUX-X64-LABEL: test25a: 3579 ; LINUX-X64-NOT: callq __stack_chk_fail 3580 ; LINUX-X64: .cfi_endproc 3581 3582 ; LINUX-KERNEL-X64-LABEL: test25a: 3583 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3584 ; LINUX-KERNEL-X64: .cfi_endproc 3585 3586 ; DARWIN-X64-LABEL: test25a: 3587 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3588 ; DARWIN-X64: .cfi_endproc 3589 3590 ; MSVC-I386-LABEL: test25a: 3591 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3592 ; MSVC-I386: retl 3593 %a = alloca [4 x i32], align 16 3594 %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %a, i32 0, i64 0 3595 %0 = load i32, i32* %arrayidx, align 4 3596 ret i32 %0 3597 } 3598 3599 ; test25b: array of [4 x i32] 3600 ; ssp attribute 3601 ; Requires no protector, except for Darwin which _does_ require a protector. 3602 ; Function Attrs: ssp 3603 define i32 @test25b() #0 { 3604 entry: 3605 ; LINUX-I386-LABEL: test25b: 3606 ; LINUX-I386-NOT: calll __stack_chk_fail 3607 ; LINUX-I386: .cfi_endproc 3608 3609 ; LINUX-X64-LABEL: test25b: 3610 ; LINUX-X64-NOT: callq __stack_chk_fail 3611 ; LINUX-X64: .cfi_endproc 3612 3613 ; LINUX-KERNEL-X64-LABEL: test25b: 3614 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3615 ; LINUX-KERNEL-X64: .cfi_endproc 3616 3617 ; DARWIN-X64-LABEL: test25b: 3618 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3619 ; DARWIN-X64: callq ___stack_chk_fail 3620 3621 ; MSVC-I386-LABEL: test25b: 3622 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3623 ; MSVC-I386: retl 3624 3625 ; MINGW-X64-LABEL: test25b: 3626 ; MINGW-X64-NOT: callq __stack_chk_fail 3627 ; MINGW-X64: .seh_endproc 3628 3629 %a = alloca [4 x i32], align 16 3630 %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %a, i32 0, i64 0 3631 %0 = load i32, i32* %arrayidx, align 4 3632 ret i32 %0 3633 } 3634 3635 ; test25c: array of [4 x i32] 3636 ; sspstrong attribute 3637 ; Requires protector. 3638 ; Function Attrs: sspstrong 3639 define i32 @test25c() #1 { 3640 entry: 3641 ; LINUX-I386-LABEL: test25c: 3642 ; LINUX-I386: mov{{l|q}} %gs: 3643 ; LINUX-I386: calll __stack_chk_fail 3644 3645 ; LINUX-X64-LABEL: test25c: 3646 ; LINUX-X64: mov{{l|q}} %fs: 3647 ; LINUX-X64: callq __stack_chk_fail 3648 3649 ; LINUX-KERNEL-X64-LABEL: test25c: 3650 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3651 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3652 3653 ; DARWIN-X64-LABEL: test25c: 3654 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3655 ; DARWIN-X64: callq ___stack_chk_fail 3656 3657 ; MSVC-I386-LABEL: test25c: 3658 ; MSVC-I386: movl ___security_cookie, 3659 ; MSVC-I386: calll @__security_check_cookie@4 3660 %a = alloca [4 x i32], align 16 3661 %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %a, i32 0, i64 0 3662 %0 = load i32, i32* %arrayidx, align 4 3663 ret i32 %0 3664 } 3665 3666 ; test25d: array of [4 x i32] 3667 ; sspreq attribute 3668 ; Requires protector. 3669 ; Function Attrs: sspreq 3670 define i32 @test25d() #2 { 3671 entry: 3672 ; LINUX-I386-LABEL: test25d: 3673 ; LINUX-I386: mov{{l|q}} %gs: 3674 ; LINUX-I386: calll __stack_chk_fail 3675 3676 ; LINUX-X64-LABEL: test25d: 3677 ; LINUX-X64: mov{{l|q}} %fs: 3678 ; LINUX-X64: callq __stack_chk_fail 3679 3680 ; LINUX-KERNEL-X64-LABEL: test25d: 3681 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3682 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3683 3684 ; DARWIN-X64-LABEL: test25d: 3685 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3686 ; DARWIN-X64: callq ___stack_chk_fail 3687 3688 ; MSVC-I386-LABEL: test25d: 3689 ; MSVC-I386: movl ___security_cookie, 3690 ; MSVC-I386: calll @__security_check_cookie@4 3691 %a = alloca [4 x i32], align 16 3692 %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %a, i32 0, i64 0 3693 %0 = load i32, i32* %arrayidx, align 4 3694 ret i32 %0 3695 } 3696 3697 ; test26: Nested structure, no arrays, no address-of expressions. 3698 ; Verify that the resulting gep-of-gep does not incorrectly trigger 3699 ; a stack protector. 3700 ; ssptrong attribute 3701 ; Requires no protector. 3702 ; Function Attrs: sspstrong 3703 define void @test26() #1 { 3704 entry: 3705 ; LINUX-I386-LABEL: test26: 3706 ; LINUX-I386-NOT: calll __stack_chk_fail 3707 ; LINUX-I386: .cfi_endproc 3708 3709 ; LINUX-X64-LABEL: test26: 3710 ; LINUX-X64-NOT: callq __stack_chk_fail 3711 ; LINUX-X64: .cfi_endproc 3712 3713 ; LINUX-KERNEL-X64-LABEL: test26: 3714 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3715 ; LINUX-KERNEL-X64: .cfi_endproc 3716 3717 ; DARWIN-X64-LABEL: test26: 3718 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3719 ; DARWIN-X64: .cfi_endproc 3720 3721 ; MSVC-I386-LABEL: test26: 3722 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3723 ; MSVC-I386: retl 3724 %c = alloca %struct.nest, align 4 3725 %b = getelementptr inbounds %struct.nest, %struct.nest* %c, i32 0, i32 1 3726 %_a = getelementptr inbounds %struct.pair, %struct.pair* %b, i32 0, i32 0 3727 %0 = load i32, i32* %_a, align 4 3728 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %0) 3729 ret void 3730 } 3731 3732 ; test27: Address-of a structure taken in a function with a loop where 3733 ; the alloca is an incoming value to a PHI node and a use of that PHI 3734 ; node is also an incoming value. 3735 ; Verify that the address-of analysis does not get stuck in infinite 3736 ; recursion when chasing the alloca through the PHI nodes. 3737 ; Requires protector. 3738 ; Function Attrs: sspstrong 3739 define i32 @test27(i32 %arg) #1 { 3740 bb: 3741 ; LINUX-I386-LABEL: test27: 3742 ; LINUX-I386: mov{{l|q}} %gs: 3743 ; LINUX-I386: calll __stack_chk_fail 3744 3745 ; LINUX-X64-LABEL: test27: 3746 ; LINUX-X64: mov{{l|q}} %fs: 3747 ; LINUX-X64: callq __stack_chk_fail 3748 3749 ; LINUX-KERNEL-X64-LABEL: test27: 3750 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3751 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3752 3753 ; DARWIN-X64-LABEL: test27: 3754 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3755 ; DARWIN-X64: callq ___stack_chk_fail 3756 3757 ; MSVC-I386-LABEL: test27: 3758 ; MSVC-I386: movl ___security_cookie, 3759 ; MSVC-I386: calll @__security_check_cookie@4 3760 %tmp = alloca %struct.small*, align 8 3761 %tmp1 = call i32 (...) @dummy(%struct.small** %tmp) 3762 %tmp2 = load %struct.small*, %struct.small** %tmp, align 8 3763 %tmp3 = ptrtoint %struct.small* %tmp2 to i64 3764 %tmp4 = trunc i64 %tmp3 to i32 3765 %tmp5 = icmp sgt i32 %tmp4, 0 3766 br i1 %tmp5, label %bb6, label %bb21 3767 3768 bb6: ; preds = %bb17, %bb 3769 %tmp7 = phi %struct.small* [ %tmp19, %bb17 ], [ %tmp2, %bb ] 3770 %tmp8 = phi i64 [ %tmp20, %bb17 ], [ 1, %bb ] 3771 %tmp9 = phi i32 [ %tmp14, %bb17 ], [ %tmp1, %bb ] 3772 %tmp10 = getelementptr inbounds %struct.small, %struct.small* %tmp7, i64 0, i32 0 3773 %tmp11 = load i8, i8* %tmp10, align 1 3774 %tmp12 = icmp eq i8 %tmp11, 1 3775 %tmp13 = add nsw i32 %tmp9, 8 3776 %tmp14 = select i1 %tmp12, i32 %tmp13, i32 %tmp9 3777 %tmp15 = trunc i64 %tmp8 to i32 3778 %tmp16 = icmp eq i32 %tmp15, %tmp4 3779 br i1 %tmp16, label %bb21, label %bb17 3780 3781 bb17: ; preds = %bb6 3782 %tmp18 = getelementptr inbounds %struct.small*, %struct.small** %tmp, i64 %tmp8 3783 %tmp19 = load %struct.small*, %struct.small** %tmp18, align 8 3784 %tmp20 = add i64 %tmp8, 1 3785 br label %bb6 3786 3787 bb21: ; preds = %bb6, %bb 3788 %tmp22 = phi i32 [ %tmp1, %bb ], [ %tmp14, %bb6 ] 3789 %tmp23 = call i32 (...) @dummy(i32 %tmp22) 3790 ret i32 undef 3791 } 3792 3793 ; test28a: An array of [32 x i8] and a requested ssp-buffer-size of 33. 3794 ; Requires no protector. 3795 ; Function Attrs: ssp stack-protector-buffer-size=33 3796 define i32 @test28a() #3 { 3797 entry: 3798 ; LINUX-I386-LABEL: test28a: 3799 ; LINUX-I386-NOT: calll __stack_chk_fail 3800 ; LINUX-I386: .cfi_endproc 3801 3802 ; LINUX-X64-LABEL: test28a: 3803 ; LINUX-X64-NOT: callq __stack_chk_fail 3804 ; LINUX-X64: .cfi_endproc 3805 3806 ; LINUX-KERNEL-X64-LABEL: test28a: 3807 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3808 ; LINUX-KERNEL-X64: .cfi_endproc 3809 3810 ; DARWIN-X64-LABEL: test28a: 3811 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3812 ; DARWIN-X64: .cfi_endproc 3813 3814 ; MSVC-I386-LABEL: test28a: 3815 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3816 ; MSVC-I386: retl 3817 %test = alloca [32 x i8], align 16 3818 %arraydecay = getelementptr inbounds [32 x i8], [32 x i8]* %test, i32 0, i32 0 3819 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay) 3820 ret i32 %call 3821 } 3822 3823 ; test28b: An array of [33 x i8] and a requested ssp-buffer-size of 33. 3824 ; Requires protector. 3825 ; Function Attrs: ssp stack-protector-buffer-size=33 3826 define i32 @test28b() #3 { 3827 entry: 3828 ; LINUX-I386-LABEL: test28b: 3829 ; LINUX-I386: mov{{l|q}} %gs: 3830 ; LINUX-I386: calll __stack_chk_fail 3831 3832 ; LINUX-X64-LABEL: test28b: 3833 ; LINUX-X64: mov{{l|q}} %fs: 3834 ; LINUX-X64: callq __stack_chk_fail 3835 3836 ; LINUX-KERNEL-X64-LABEL: test28b: 3837 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3838 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3839 3840 ; DARWIN-X64-LABEL: test28b: 3841 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3842 ; DARWIN-X64: callq ___stack_chk_fail 3843 3844 ; MSVC-I386-LABEL: test28b: 3845 ; MSVC-I386: movl ___security_cookie, 3846 ; MSVC-I386: calll @__security_check_cookie@4 3847 %test = alloca [33 x i8], align 16 3848 %arraydecay = getelementptr inbounds [33 x i8], [33 x i8]* %test, i32 0, i32 0 3849 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay) 3850 ret i32 %call 3851 } 3852 3853 ; test29a: An array of [4 x i8] and a requested ssp-buffer-size of 5. 3854 ; Requires no protector. 3855 ; Function Attrs: ssp stack-protector-buffer-size=5 3856 define i32 @test29a() #4 { 3857 entry: 3858 ; LINUX-I386-LABEL: test29a: 3859 ; LINUX-I386-NOT: calll __stack_chk_fail 3860 ; LINUX-I386: .cfi_endproc 3861 3862 ; LINUX-X64-LABEL: test29a: 3863 ; LINUX-X64-NOT: callq __stack_chk_fail 3864 ; LINUX-X64: .cfi_endproc 3865 3866 ; LINUX-KERNEL-X64-LABEL: test29a: 3867 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3868 ; LINUX-KERNEL-X64: .cfi_endproc 3869 3870 ; DARWIN-X64-LABEL: test29a: 3871 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3872 ; DARWIN-X64: .cfi_endproc 3873 3874 ; MSVC-I386-LABEL: test29a: 3875 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3876 ; MSVC-I386: retl 3877 %test = alloca [4 x i8], align 1 3878 %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %test, i32 0, i32 0 3879 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay) 3880 ret i32 %call 3881 } 3882 3883 ; test29b: An array of [5 x i8] and a requested ssp-buffer-size of 5. 3884 ; Requires protector. 3885 ; Function Attrs: ssp stack-protector-buffer-size=5 3886 define i32 @test29b() #4 { 3887 entry: 3888 ; LINUX-I386-LABEL: test29b: 3889 ; LINUX-I386: mov{{l|q}} %gs: 3890 ; LINUX-I386: calll __stack_chk_fail 3891 3892 ; LINUX-X64-LABEL: test29b: 3893 ; LINUX-X64: mov{{l|q}} %fs: 3894 ; LINUX-X64: callq __stack_chk_fail 3895 3896 ; LINUX-KERNEL-X64-LABEL: test29b: 3897 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3898 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3899 3900 ; DARWIN-X64-LABEL: test29b: 3901 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3902 ; DARWIN-X64: callq ___stack_chk_fail 3903 3904 ; MSVC-I386-LABEL: test29b: 3905 ; MSVC-I386: movl ___security_cookie, 3906 ; MSVC-I386: calll @__security_check_cookie@4 3907 %test = alloca [5 x i8], align 1 3908 %arraydecay = getelementptr inbounds [5 x i8], [5 x i8]* %test, i32 0, i32 0 3909 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay) 3910 ret i32 %call 3911 } 3912 3913 ; test30a: An structure containing an i32 and an array of [5 x i8]. 3914 ; Requested ssp-buffer-size of 6. 3915 ; Requires no protector. 3916 ; Function Attrs: ssp stack-protector-buffer-size=6 3917 define i32 @test30a() #5 { 3918 entry: 3919 ; LINUX-I386-LABEL: test30a: 3920 ; LINUX-I386-NOT: calll __stack_chk_fail 3921 ; LINUX-I386: .cfi_endproc 3922 3923 ; LINUX-X64-LABEL: test30a: 3924 ; LINUX-X64-NOT: callq __stack_chk_fail 3925 ; LINUX-X64: .cfi_endproc 3926 3927 ; LINUX-KERNEL-X64-LABEL: test30a: 3928 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3929 ; LINUX-KERNEL-X64: .cfi_endproc 3930 3931 ; DARWIN-X64-LABEL: test30a: 3932 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3933 ; DARWIN-X64: .cfi_endproc 3934 3935 ; MSVC-I386-LABEL: test30a: 3936 ; MSVC-I386-NOT: calll @__security_check_cookie@4 3937 ; MSVC-I386: retl 3938 %test = alloca %struct.small_char, align 4 3939 %test.coerce = alloca { i64, i8 } 3940 %0 = bitcast { i64, i8 }* %test.coerce to i8* 3941 %1 = bitcast %struct.small_char* %test to i8* 3942 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* %1, i64 12, i1 false) 3943 %2 = getelementptr { i64, i8 }, { i64, i8 }* %test.coerce, i32 0, i32 0 3944 %3 = load i64, i64* %2, align 1 3945 %4 = getelementptr { i64, i8 }, { i64, i8 }* %test.coerce, i32 0, i32 1 3946 %5 = load i8, i8* %4, align 1 3947 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %3, i8 %5) 3948 ret i32 %call 3949 } 3950 3951 ; test30b: An structure containing an i32 and an array of [5 x i8]. 3952 ; Requested ssp-buffer-size of 5. 3953 ; Requires protector. 3954 ; Function Attrs: ssp stack-protector-buffer-size=5 3955 define i32 @test30b() #4 { 3956 entry: 3957 ; LINUX-I386-LABEL: test30b: 3958 ; LINUX-I386: mov{{l|q}} %gs: 3959 ; LINUX-I386: calll __stack_chk_fail 3960 3961 ; LINUX-X64-LABEL: test30b: 3962 ; LINUX-X64: mov{{l|q}} %fs: 3963 ; LINUX-X64: callq __stack_chk_fail 3964 3965 ; LINUX-KERNEL-X64-LABEL: test30b: 3966 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3967 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3968 3969 ; DARWIN-X64-LABEL: test30b: 3970 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3971 ; DARWIN-X64: callq ___stack_chk_fail 3972 3973 ; MSVC-I386-LABEL: test30b: 3974 ; MSVC-I386: movl ___security_cookie, 3975 ; MSVC-I386: calll @__security_check_cookie@4 3976 %test = alloca %struct.small_char, align 4 3977 %test.coerce = alloca { i64, i8 } 3978 %0 = bitcast { i64, i8 }* %test.coerce to i8* 3979 %1 = bitcast %struct.small_char* %test to i8* 3980 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* %1, i64 12, i1 false) 3981 %2 = getelementptr { i64, i8 }, { i64, i8 }* %test.coerce, i32 0, i32 0 3982 %3 = load i64, i64* %2, align 1 3983 %4 = getelementptr { i64, i8 }, { i64, i8 }* %test.coerce, i32 0, i32 1 3984 %5 = load i8, i8* %4, align 1 3985 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %3, i8 %5) 3986 ret i32 %call 3987 } 3988 3989 ; test31a: An alloca of size 5. 3990 ; Requested ssp-buffer-size of 6. 3991 ; Requires no protector. 3992 ; Function Attrs: ssp stack-protector-buffer-size=6 3993 define i32 @test31a() #5 { 3994 entry: 3995 ; LINUX-I386-LABEL: test31a: 3996 ; LINUX-I386-NOT: calll __stack_chk_fail 3997 ; LINUX-I386: .cfi_endproc 3998 3999 ; LINUX-X64-LABEL: test31a: 4000 ; LINUX-X64-NOT: callq __stack_chk_fail 4001 ; LINUX-X64: .cfi_endproc 4002 4003 ; LINUX-KERNEL-X64-LABEL: test31a: 4004 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 4005 ; LINUX-KERNEL-X64: .cfi_endproc 4006 4007 ; DARWIN-X64-LABEL: test31a: 4008 ; DARWIN-X64-NOT: callq ___stack_chk_fail 4009 ; DARWIN-X64: .cfi_endproc 4010 4011 ; MSVC-I386-LABEL: test31a: 4012 ; MSVC-I386-NOT: calll @__security_check_cookie@4 4013 ; MSVC-I386: retl 4014 %test = alloca i8*, align 8 4015 %0 = alloca i8, i64 4 4016 store i8* %0, i8** %test, align 8 4017 %1 = load i8*, i8** %test, align 8 4018 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %1) 4019 ret i32 %call 4020 } 4021 4022 ; test31b: An alloca of size 5. 4023 ; Requested ssp-buffer-size of 5. 4024 ; Requires protector. 4025 define i32 @test31b() #4 { 4026 entry: 4027 ; LINUX-I386-LABEL: test31b: 4028 ; LINUX-I386: mov{{l|q}} %gs: 4029 ; LINUX-I386: calll __stack_chk_fail 4030 4031 ; LINUX-X64-LABEL: test31b: 4032 ; LINUX-X64: mov{{l|q}} %fs: 4033 ; LINUX-X64: callq __stack_chk_fail 4034 4035 ; LINUX-KERNEL-X64-LABEL: test31b: 4036 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 4037 ; LINUX-KERNEL-X64: callq __stack_chk_fail 4038 4039 ; DARWIN-X64-LABEL: test31b: 4040 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 4041 ; DARWIN-X64: callq ___stack_chk_fail 4042 4043 ; MSVC-I386-LABEL: test31b: 4044 ; MSVC-I386: movl ___security_cookie, 4045 ; MSVC-I386: calll @__security_check_cookie@4 4046 %test = alloca i8*, align 8 4047 %0 = alloca i8, i64 5 4048 store i8* %0, i8** %test, align 8 4049 %1 = load i8*, i8** %test, align 8 4050 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %1) 4051 ret i32 %call 4052 } 4053 4054 define void @__stack_chk_fail() #1 !dbg !6 { 4055 entry: 4056 ret void 4057 } 4058 4059 define void @test32() #1 !dbg !7 { 4060 entry: 4061 ; LINUX-I386-LABEL: test32: 4062 ; LINUX-I386: .loc 1 4 2 prologue_end 4063 ; LINUX-I386: .loc 1 0 0 4064 ; LINUX-I386-NEXT: calll __stack_chk_fail 4065 4066 ; LINUX-X64-LABEL: test32: 4067 ; LINUX-X64: .loc 1 4 2 prologue_end 4068 ; LINUX-X64: .loc 1 0 0 4069 ; LINUX-X64-NEXT: callq __stack_chk_fail 4070 4071 ; LINUX-KERNEL-X64-LABEL: test32: 4072 ; LINUX-KERNEL-X64: .loc 1 4 2 prologue_end 4073 ; LINUX-KERNEL-X64: .loc 1 0 0 4074 ; LINUX-KERNEL-X64-NEXT: callq __stack_chk_fail 4075 4076 ; OPENBSD-AMD64-LABEL: test32: 4077 ; OPENBSD-AMD64: .loc 1 4 2 prologue_end 4078 ; OPENBSD-AMD64: .loc 1 0 0 4079 ; OPENBSD-AMD64-NEXT: movl 4080 ; OPENBSD-AMD64-NEXT: callq __stack_smash_handler 4081 %0 = alloca [5 x i8], align 1 4082 ret void, !dbg !9 4083 } 4084 4085 define i32 @IgnoreIntrinsicTest() #1 { 4086 ; IGNORE_INTRIN: IgnoreIntrinsicTest: 4087 %1 = alloca i32, align 4 4088 %2 = bitcast i32* %1 to i8* 4089 call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %2) 4090 store volatile i32 1, i32* %1, align 4 4091 %3 = load volatile i32, i32* %1, align 4 4092 %4 = mul nsw i32 %3, 42 4093 call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %2) 4094 ret i32 %4 4095 ; IGNORE_INTRIN-NOT: callq __stack_chk_fail 4096 ; IGNORE_INTRIN: .cfi_endproc 4097 } 4098 4099 declare double @testi_aux() 4100 declare i8* @strcpy(i8*, i8*) 4101 declare i32 @printf(i8*, ...) 4102 declare void @funcall(i32*) 4103 declare void @funcall2(i32**) 4104 declare void @funfloat(float*) 4105 declare void @funfloat2(float**) 4106 declare void @_Z3exceptPi(i32*) 4107 declare i32 @__gxx_personality_v0(...) 4108 declare i32* @getp() 4109 declare i32 @dummy(...) 4110 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) 4111 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) 4112 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) 4113 4114 attributes #0 = { ssp } 4115 attributes #1 = { sspstrong } 4116 attributes #2 = { sspreq } 4117 attributes #3 = { ssp "stack-protector-buffer-size"="33" } 4118 attributes #4 = { ssp "stack-protector-buffer-size"="5" } 4119 attributes #5 = { ssp "stack-protector-buffer-size"="6" } 4120 4121 !llvm.dbg.cu = !{!0} 4122 !llvm.module.flags = !{!3, !4} 4123 !llvm.ident = !{!5} 4124 4125 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug) 4126 !1 = !DIFile(filename: "test.c", directory: "/tmp") 4127 !2 = !{} 4128 !3 = !{i32 2, !"Dwarf Version", i32 4} 4129 !4 = !{i32 2, !"Debug Info Version", i32 3} 4130 !5 = !{!"clang version x.y.z"} 4131 !6 = distinct !DISubprogram(name: "__stack_chk_fail", scope: !1, type: !8, unit: !0) 4132 !7 = distinct !DISubprogram(name: "test32", scope: !1, type: !8, unit: !0) 4133 !8 = !DISubroutineType(types: !2) 4134 !9 = !DILocation(line: 4, column: 2, scope: !7) 4135
