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 7 %struct.foo = type { [16 x i8] } 8 %struct.foo.0 = type { [4 x i8] } 9 %struct.pair = type { i32, i32 } 10 %struct.nest = type { %struct.pair, %struct.pair } 11 %struct.vec = type { <4 x i32> } 12 %class.A = type { [2 x i8] } 13 %struct.deep = type { %union.anon } 14 %union.anon = type { %struct.anon } 15 %struct.anon = type { %struct.anon.0 } 16 %struct.anon.0 = type { %union.anon.1 } 17 %union.anon.1 = type { [2 x i8] } 18 %struct.small = type { i8 } 19 20 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 21 22 ; test1a: array of [16 x i8] 23 ; no ssp attribute 24 ; Requires no protector. 25 define void @test1a(i8* %a) nounwind uwtable { 26 entry: 27 ; LINUX-I386-LABEL: test1a: 28 ; LINUX-I386-NOT: calll __stack_chk_fail 29 ; LINUX-I386: .cfi_endproc 30 31 ; LINUX-X64-LABEL: test1a: 32 ; LINUX-X64-NOT: callq __stack_chk_fail 33 ; LINUX-X64: .cfi_endproc 34 35 ; LINUX-KERNEL-X64-LABEL: test1a: 36 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 37 ; LINUX-KERNEL-X64: .cfi_endproc 38 39 ; DARWIN-X64-LABEL: test1a: 40 ; DARWIN-X64-NOT: callq ___stack_chk_fail 41 ; DARWIN-X64: .cfi_endproc 42 %a.addr = alloca i8*, align 8 43 %buf = alloca [16 x i8], align 16 44 store i8* %a, i8** %a.addr, align 8 45 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 46 %0 = load i8** %a.addr, align 8 47 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 48 %arraydecay1 = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 49 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 50 ret void 51 } 52 53 ; test1b: array of [16 x i8] 54 ; ssp attribute 55 ; Requires protector. 56 define void @test1b(i8* %a) nounwind uwtable ssp { 57 entry: 58 ; LINUX-I386-LABEL: test1b: 59 ; LINUX-I386: mov{{l|q}} %gs: 60 ; LINUX-I386: calll __stack_chk_fail 61 62 ; LINUX-X64-LABEL: test1b: 63 ; LINUX-X64: mov{{l|q}} %fs: 64 ; LINUX-X64: callq __stack_chk_fail 65 66 ; LINUX-KERNEL-X64-LABEL: test1b: 67 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 68 ; LINUX-KERNEL-X64: callq __stack_chk_fail 69 70 ; DARWIN-X64-LABEL: test1b: 71 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 72 ; DARWIN-X64: callq ___stack_chk_fail 73 74 ; OPENBSD-AMD64-LABEL: test1b: 75 ; OPENBSD-AMD64: movq __guard_local(%rip) 76 ; OPENBSD-AMD64: callq __stack_smash_handler 77 %a.addr = alloca i8*, align 8 78 %buf = alloca [16 x i8], align 16 79 store i8* %a, i8** %a.addr, align 8 80 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 81 %0 = load i8** %a.addr, align 8 82 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 83 %arraydecay1 = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 84 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 85 ret void 86 } 87 88 ; test1c: array of [16 x i8] 89 ; sspstrong attribute 90 ; Requires protector. 91 define void @test1c(i8* %a) nounwind uwtable sspstrong { 92 entry: 93 ; LINUX-I386-LABEL: test1c: 94 ; LINUX-I386: mov{{l|q}} %gs: 95 ; LINUX-I386: calll __stack_chk_fail 96 97 ; LINUX-X64-LABEL: test1c: 98 ; LINUX-X64: mov{{l|q}} %fs: 99 ; LINUX-X64: callq __stack_chk_fail 100 101 ; LINUX-KERNEL-X64-LABEL: test1c: 102 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 103 ; LINUX-KERNEL-X64: callq __stack_chk_fail 104 105 ; DARWIN-X64-LABEL: test1c: 106 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 107 ; DARWIN-X64: callq ___stack_chk_fail 108 %a.addr = alloca i8*, align 8 109 %buf = alloca [16 x i8], align 16 110 store i8* %a, i8** %a.addr, align 8 111 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 112 %0 = load i8** %a.addr, align 8 113 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 114 %arraydecay1 = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 115 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 116 ret void 117 } 118 119 ; test1d: array of [16 x i8] 120 ; sspreq attribute 121 ; Requires protector. 122 define void @test1d(i8* %a) nounwind uwtable sspreq { 123 entry: 124 ; LINUX-I386-LABEL: test1d: 125 ; LINUX-I386: mov{{l|q}} %gs: 126 ; LINUX-I386: calll __stack_chk_fail 127 128 ; LINUX-X64-LABEL: test1d: 129 ; LINUX-X64: mov{{l|q}} %fs: 130 ; LINUX-X64: callq __stack_chk_fail 131 132 ; LINUX-KERNEL-X64-LABEL: test1d: 133 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 134 ; LINUX-KERNEL-X64: callq __stack_chk_fail 135 136 ; DARWIN-X64-LABEL: test1d: 137 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 138 ; DARWIN-X64: callq ___stack_chk_fail 139 %a.addr = alloca i8*, align 8 140 %buf = alloca [16 x i8], align 16 141 store i8* %a, i8** %a.addr, align 8 142 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 143 %0 = load i8** %a.addr, align 8 144 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 145 %arraydecay1 = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 146 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 147 ret void 148 } 149 150 ; test2a: struct { [16 x i8] } 151 ; no ssp attribute 152 ; Requires no protector. 153 define void @test2a(i8* %a) nounwind uwtable { 154 entry: 155 ; LINUX-I386-LABEL: test2a: 156 ; LINUX-I386-NOT: calll __stack_chk_fail 157 ; LINUX-I386: .cfi_endproc 158 159 ; LINUX-X64-LABEL: test2a: 160 ; LINUX-X64-NOT: callq __stack_chk_fail 161 ; LINUX-X64: .cfi_endproc 162 163 ; LINUX-KERNEL-X64-LABEL: test2a: 164 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 165 ; LINUX-KERNEL-X64: .cfi_endproc 166 167 ; DARWIN-X64-LABEL: test2a: 168 ; DARWIN-X64-NOT: callq ___stack_chk_fail 169 ; DARWIN-X64: .cfi_endproc 170 %a.addr = alloca i8*, align 8 171 %b = alloca %struct.foo, align 1 172 store i8* %a, i8** %a.addr, align 8 173 %buf = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 174 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 175 %0 = load i8** %a.addr, align 8 176 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 177 %buf1 = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 178 %arraydecay2 = getelementptr inbounds [16 x i8]* %buf1, i32 0, i32 0 179 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 180 ret void 181 } 182 183 ; test2b: struct { [16 x i8] } 184 ; ssp attribute 185 ; Requires protector. 186 define void @test2b(i8* %a) nounwind uwtable ssp { 187 entry: 188 ; LINUX-I386-LABEL: test2b: 189 ; LINUX-I386: mov{{l|q}} %gs: 190 ; LINUX-I386: calll __stack_chk_fail 191 192 ; LINUX-X64-LABEL: test2b: 193 ; LINUX-X64: mov{{l|q}} %fs: 194 ; LINUX-X64: callq __stack_chk_fail 195 196 ; LINUX-KERNEL-X64-LABEL: test2b: 197 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 198 ; LINUX-KERNEL-X64: callq __stack_chk_fail 199 200 ; DARWIN-X64-LABEL: test2b: 201 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 202 ; DARWIN-X64: callq ___stack_chk_fail 203 %a.addr = alloca i8*, align 8 204 %b = alloca %struct.foo, align 1 205 store i8* %a, i8** %a.addr, align 8 206 %buf = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 207 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 208 %0 = load i8** %a.addr, align 8 209 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 210 %buf1 = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 211 %arraydecay2 = getelementptr inbounds [16 x i8]* %buf1, i32 0, i32 0 212 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 213 ret void 214 } 215 216 ; test2c: struct { [16 x i8] } 217 ; sspstrong attribute 218 ; Requires protector. 219 define void @test2c(i8* %a) nounwind uwtable sspstrong { 220 entry: 221 ; LINUX-I386-LABEL: test2c: 222 ; LINUX-I386: mov{{l|q}} %gs: 223 ; LINUX-I386: calll __stack_chk_fail 224 225 ; LINUX-X64-LABEL: test2c: 226 ; LINUX-X64: mov{{l|q}} %fs: 227 ; LINUX-X64: callq __stack_chk_fail 228 229 ; LINUX-KERNEL-X64-LABEL: test2c: 230 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 231 ; LINUX-KERNEL-X64: callq __stack_chk_fail 232 233 ; DARWIN-X64-LABEL: test2c: 234 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 235 ; DARWIN-X64: callq ___stack_chk_fail 236 %a.addr = alloca i8*, align 8 237 %b = alloca %struct.foo, align 1 238 store i8* %a, i8** %a.addr, align 8 239 %buf = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 240 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 241 %0 = load i8** %a.addr, align 8 242 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 243 %buf1 = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 244 %arraydecay2 = getelementptr inbounds [16 x i8]* %buf1, i32 0, i32 0 245 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 246 ret void 247 } 248 249 ; test2d: struct { [16 x i8] } 250 ; sspreq attribute 251 ; Requires protector. 252 define void @test2d(i8* %a) nounwind uwtable sspreq { 253 entry: 254 ; LINUX-I386-LABEL: test2d: 255 ; LINUX-I386: mov{{l|q}} %gs: 256 ; LINUX-I386: calll __stack_chk_fail 257 258 ; LINUX-X64-LABEL: test2d: 259 ; LINUX-X64: mov{{l|q}} %fs: 260 ; LINUX-X64: callq __stack_chk_fail 261 262 ; LINUX-KERNEL-X64-LABEL: test2d: 263 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 264 ; LINUX-KERNEL-X64: callq __stack_chk_fail 265 266 ; DARWIN-X64-LABEL: test2d: 267 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 268 ; DARWIN-X64: callq ___stack_chk_fail 269 %a.addr = alloca i8*, align 8 270 %b = alloca %struct.foo, align 1 271 store i8* %a, i8** %a.addr, align 8 272 %buf = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 273 %arraydecay = getelementptr inbounds [16 x i8]* %buf, i32 0, i32 0 274 %0 = load i8** %a.addr, align 8 275 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 276 %buf1 = getelementptr inbounds %struct.foo* %b, i32 0, i32 0 277 %arraydecay2 = getelementptr inbounds [16 x i8]* %buf1, i32 0, i32 0 278 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 279 ret void 280 } 281 282 ; test3a: array of [4 x i8] 283 ; no ssp attribute 284 ; Requires no protector. 285 define void @test3a(i8* %a) nounwind uwtable { 286 entry: 287 ; LINUX-I386-LABEL: test3a: 288 ; LINUX-I386-NOT: calll __stack_chk_fail 289 ; LINUX-I386: .cfi_endproc 290 291 ; LINUX-X64-LABEL: test3a: 292 ; LINUX-X64-NOT: callq __stack_chk_fail 293 ; LINUX-X64: .cfi_endproc 294 295 ; LINUX-KERNEL-X64-LABEL: test3a: 296 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 297 ; LINUX-KERNEL-X64: .cfi_endproc 298 299 ; DARWIN-X64-LABEL: test3a: 300 ; DARWIN-X64-NOT: callq ___stack_chk_fail 301 ; DARWIN-X64: .cfi_endproc 302 %a.addr = alloca i8*, align 8 303 %buf = alloca [4 x i8], align 1 304 store i8* %a, i8** %a.addr, align 8 305 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 306 %0 = load i8** %a.addr, align 8 307 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 308 %arraydecay1 = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 309 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 310 ret void 311 } 312 313 ; test3b: array [4 x i8] 314 ; ssp attribute 315 ; Requires no protector. 316 define void @test3b(i8* %a) nounwind uwtable ssp { 317 entry: 318 ; LINUX-I386-LABEL: test3b: 319 ; LINUX-I386-NOT: calll __stack_chk_fail 320 ; LINUX-I386: .cfi_endproc 321 322 ; LINUX-X64-LABEL: test3b: 323 ; LINUX-X64-NOT: callq __stack_chk_fail 324 ; LINUX-X64: .cfi_endproc 325 326 ; LINUX-KERNEL-X64-LABEL: test3b: 327 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 328 ; LINUX-KERNEL-X64: .cfi_endproc 329 330 ; DARWIN-X64-LABEL: test3b: 331 ; DARWIN-X64-NOT: callq ___stack_chk_fail 332 ; DARWIN-X64: .cfi_endproc 333 %a.addr = alloca i8*, align 8 334 %buf = alloca [4 x i8], align 1 335 store i8* %a, i8** %a.addr, align 8 336 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 337 %0 = load i8** %a.addr, align 8 338 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 339 %arraydecay1 = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 340 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 341 ret void 342 } 343 344 ; test3c: array of [4 x i8] 345 ; sspstrong attribute 346 ; Requires protector. 347 define void @test3c(i8* %a) nounwind uwtable sspstrong { 348 entry: 349 ; LINUX-I386-LABEL: test3c: 350 ; LINUX-I386: mov{{l|q}} %gs: 351 ; LINUX-I386: calll __stack_chk_fail 352 353 ; LINUX-X64-LABEL: test3c: 354 ; LINUX-X64: mov{{l|q}} %fs: 355 ; LINUX-X64: callq __stack_chk_fail 356 357 ; LINUX-KERNEL-X64-LABEL: test3c: 358 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 359 ; LINUX-KERNEL-X64: callq __stack_chk_fail 360 361 ; DARWIN-X64-LABEL: test3c: 362 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 363 ; DARWIN-X64: callq ___stack_chk_fail 364 %a.addr = alloca i8*, align 8 365 %buf = alloca [4 x i8], align 1 366 store i8* %a, i8** %a.addr, align 8 367 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 368 %0 = load i8** %a.addr, align 8 369 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 370 %arraydecay1 = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 371 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 372 ret void 373 } 374 375 ; test3d: array of [4 x i8] 376 ; sspreq attribute 377 ; Requires protector. 378 define void @test3d(i8* %a) nounwind uwtable sspreq { 379 entry: 380 ; LINUX-I386-LABEL: test3d: 381 ; LINUX-I386: mov{{l|q}} %gs: 382 ; LINUX-I386: calll __stack_chk_fail 383 384 ; LINUX-X64-LABEL: test3d: 385 ; LINUX-X64: mov{{l|q}} %fs: 386 ; LINUX-X64: callq __stack_chk_fail 387 388 ; LINUX-KERNEL-X64-LABEL: test3d: 389 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 390 ; LINUX-KERNEL-X64: callq __stack_chk_fail 391 392 ; DARWIN-X64-LABEL: test3d: 393 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 394 ; DARWIN-X64: callq ___stack_chk_fail 395 %a.addr = alloca i8*, align 8 396 %buf = alloca [4 x i8], align 1 397 store i8* %a, i8** %a.addr, align 8 398 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 399 %0 = load i8** %a.addr, align 8 400 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 401 %arraydecay1 = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 402 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1) 403 ret void 404 } 405 406 ; test4a: struct { [4 x i8] } 407 ; no ssp attribute 408 ; Requires no protector. 409 define void @test4a(i8* %a) nounwind uwtable { 410 entry: 411 ; LINUX-I386-LABEL: test4a: 412 ; LINUX-I386-NOT: calll __stack_chk_fail 413 ; LINUX-I386: .cfi_endproc 414 415 ; LINUX-X64-LABEL: test4a: 416 ; LINUX-X64-NOT: callq __stack_chk_fail 417 ; LINUX-X64: .cfi_endproc 418 419 ; LINUX-KERNEL-X64-LABEL: test4a: 420 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 421 ; LINUX-KERNEL-X64: .cfi_endproc 422 423 ; DARWIN-X64-LABEL: test4a: 424 ; DARWIN-X64-NOT: callq ___stack_chk_fail 425 ; DARWIN-X64: .cfi_endproc 426 %a.addr = alloca i8*, align 8 427 %b = alloca %struct.foo.0, align 1 428 store i8* %a, i8** %a.addr, align 8 429 %buf = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 430 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 431 %0 = load i8** %a.addr, align 8 432 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 433 %buf1 = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 434 %arraydecay2 = getelementptr inbounds [4 x i8]* %buf1, i32 0, i32 0 435 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 436 ret void 437 } 438 439 ; test4b: struct { [4 x i8] } 440 ; ssp attribute 441 ; Requires no protector. 442 define void @test4b(i8* %a) nounwind uwtable ssp { 443 entry: 444 ; LINUX-I386-LABEL: test4b: 445 ; LINUX-I386-NOT: calll __stack_chk_fail 446 ; LINUX-I386: .cfi_endproc 447 448 ; LINUX-X64-LABEL: test4b: 449 ; LINUX-X64-NOT: callq __stack_chk_fail 450 ; LINUX-X64: .cfi_endproc 451 452 ; LINUX-KERNEL-X64-LABEL: test4b: 453 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 454 ; LINUX-KERNEL-X64: .cfi_endproc 455 456 ; DARWIN-X64-LABEL: test4b: 457 ; DARWIN-X64-NOT: callq ___stack_chk_fail 458 ; DARWIN-X64: .cfi_endproc 459 %a.addr = alloca i8*, align 8 460 %b = alloca %struct.foo.0, align 1 461 store i8* %a, i8** %a.addr, align 8 462 %buf = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 463 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 464 %0 = load i8** %a.addr, align 8 465 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 466 %buf1 = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 467 %arraydecay2 = getelementptr inbounds [4 x i8]* %buf1, i32 0, i32 0 468 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 469 ret void 470 } 471 472 ; test4c: struct { [4 x i8] } 473 ; sspstrong attribute 474 ; Requires protector. 475 define void @test4c(i8* %a) nounwind uwtable sspstrong { 476 entry: 477 ; LINUX-I386-LABEL: test4c: 478 ; LINUX-I386: mov{{l|q}} %gs: 479 ; LINUX-I386: calll __stack_chk_fail 480 481 ; LINUX-X64-LABEL: test4c: 482 ; LINUX-X64: mov{{l|q}} %fs: 483 ; LINUX-X64: callq __stack_chk_fail 484 485 ; LINUX-KERNEL-X64-LABEL: test4c: 486 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 487 ; LINUX-KERNEL-X64: callq __stack_chk_fail 488 489 ; DARWIN-X64-LABEL: test4c: 490 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 491 ; DARWIN-X64: callq ___stack_chk_fail 492 %a.addr = alloca i8*, align 8 493 %b = alloca %struct.foo.0, align 1 494 store i8* %a, i8** %a.addr, align 8 495 %buf = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 496 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 497 %0 = load i8** %a.addr, align 8 498 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 499 %buf1 = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 500 %arraydecay2 = getelementptr inbounds [4 x i8]* %buf1, i32 0, i32 0 501 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 502 ret void 503 } 504 505 ; test4d: struct { [4 x i8] } 506 ; sspreq attribute 507 ; Requires protector. 508 define void @test4d(i8* %a) nounwind uwtable sspreq { 509 entry: 510 ; LINUX-I386-LABEL: test4d: 511 ; LINUX-I386: mov{{l|q}} %gs: 512 ; LINUX-I386: calll __stack_chk_fail 513 514 ; LINUX-X64-LABEL: test4d: 515 ; LINUX-X64: mov{{l|q}} %fs: 516 ; LINUX-X64: callq __stack_chk_fail 517 518 ; LINUX-KERNEL-X64-LABEL: test4d: 519 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 520 ; LINUX-KERNEL-X64: callq __stack_chk_fail 521 522 ; DARWIN-X64-LABEL: test4d: 523 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 524 ; DARWIN-X64: callq ___stack_chk_fail 525 %a.addr = alloca i8*, align 8 526 %b = alloca %struct.foo.0, align 1 527 store i8* %a, i8** %a.addr, align 8 528 %buf = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 529 %arraydecay = getelementptr inbounds [4 x i8]* %buf, i32 0, i32 0 530 %0 = load i8** %a.addr, align 8 531 %call = call i8* @strcpy(i8* %arraydecay, i8* %0) 532 %buf1 = getelementptr inbounds %struct.foo.0* %b, i32 0, i32 0 533 %arraydecay2 = getelementptr inbounds [4 x i8]* %buf1, i32 0, i32 0 534 %call3 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay2) 535 ret void 536 } 537 538 ; test5a: no arrays / no nested arrays 539 ; no ssp attribute 540 ; Requires no protector. 541 define void @test5a(i8* %a) nounwind uwtable { 542 entry: 543 ; LINUX-I386-LABEL: test5a: 544 ; LINUX-I386-NOT: calll __stack_chk_fail 545 ; LINUX-I386: .cfi_endproc 546 547 ; LINUX-X64-LABEL: test5a: 548 ; LINUX-X64-NOT: callq __stack_chk_fail 549 ; LINUX-X64: .cfi_endproc 550 551 ; LINUX-KERNEL-X64-LABEL: test5a: 552 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 553 ; LINUX-KERNEL-X64: .cfi_endproc 554 555 ; DARWIN-X64-LABEL: test5a: 556 ; DARWIN-X64-NOT: callq ___stack_chk_fail 557 ; DARWIN-X64: .cfi_endproc 558 %a.addr = alloca i8*, align 8 559 store i8* %a, i8** %a.addr, align 8 560 %0 = load i8** %a.addr, align 8 561 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %0) 562 ret void 563 } 564 565 ; test5b: no arrays / no nested arrays 566 ; ssp attribute 567 ; Requires no protector. 568 define void @test5b(i8* %a) nounwind uwtable ssp { 569 entry: 570 ; LINUX-I386-LABEL: test5b: 571 ; LINUX-I386-NOT: calll __stack_chk_fail 572 ; LINUX-I386: .cfi_endproc 573 574 ; LINUX-X64-LABEL: test5b: 575 ; LINUX-X64-NOT: callq __stack_chk_fail 576 ; LINUX-X64: .cfi_endproc 577 578 ; LINUX-KERNEL-X64-LABEL: test5b: 579 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 580 ; LINUX-KERNEL-X64: .cfi_endproc 581 582 ; DARWIN-X64-LABEL: test5b: 583 ; DARWIN-X64-NOT: callq ___stack_chk_fail 584 ; DARWIN-X64: .cfi_endproc 585 %a.addr = alloca i8*, align 8 586 store i8* %a, i8** %a.addr, align 8 587 %0 = load i8** %a.addr, align 8 588 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %0) 589 ret void 590 } 591 592 ; test5c: no arrays / no nested arrays 593 ; sspstrong attribute 594 ; Requires no protector. 595 define void @test5c(i8* %a) nounwind uwtable sspstrong { 596 entry: 597 ; LINUX-I386-LABEL: test5c: 598 ; LINUX-I386-NOT: calll __stack_chk_fail 599 ; LINUX-I386: .cfi_endproc 600 601 ; LINUX-X64-LABEL: test5c: 602 ; LINUX-X64-NOT: callq __stack_chk_fail 603 ; LINUX-X64: .cfi_endproc 604 605 ; LINUX-KERNEL-X64-LABEL: test5c: 606 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 607 ; LINUX-KERNEL-X64: .cfi_endproc 608 609 ; DARWIN-X64-LABEL: test5c: 610 ; DARWIN-X64-NOT: callq ___stack_chk_fail 611 ; DARWIN-X64: .cfi_endproc 612 %a.addr = alloca i8*, align 8 613 store i8* %a, i8** %a.addr, align 8 614 %0 = load i8** %a.addr, align 8 615 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %0) 616 ret void 617 } 618 619 ; test5d: no arrays / no nested arrays 620 ; sspreq attribute 621 ; Requires protector. 622 define void @test5d(i8* %a) nounwind uwtable sspreq { 623 entry: 624 ; LINUX-I386-LABEL: test5d: 625 ; LINUX-I386: mov{{l|q}} %gs: 626 ; LINUX-I386: calll __stack_chk_fail 627 628 ; LINUX-X64-LABEL: test5d: 629 ; LINUX-X64: mov{{l|q}} %fs: 630 ; LINUX-X64: callq __stack_chk_fail 631 632 ; LINUX-KERNEL-X64-LABEL: test5d: 633 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 634 ; LINUX-KERNEL-X64: callq __stack_chk_fail 635 636 ; DARWIN-X64-LABEL: test5d: 637 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 638 ; DARWIN-X64: callq ___stack_chk_fail 639 %a.addr = alloca i8*, align 8 640 store i8* %a, i8** %a.addr, align 8 641 %0 = load i8** %a.addr, align 8 642 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i8* %0) 643 ret void 644 } 645 646 ; test6a: Address-of local taken (j = &a) 647 ; no ssp attribute 648 ; Requires no protector. 649 define void @test6a() nounwind uwtable { 650 entry: 651 ; LINUX-I386-LABEL: test6a: 652 ; LINUX-I386-NOT: calll __stack_chk_fail 653 ; LINUX-I386: .cfi_endproc 654 655 ; LINUX-X64-LABEL: test6a: 656 ; LINUX-X64-NOT: callq __stack_chk_fail 657 ; LINUX-X64: .cfi_endproc 658 659 ; LINUX-KERNEL-X64-LABEL: test6a: 660 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 661 ; LINUX-KERNEL-X64: .cfi_endproc 662 663 ; DARWIN-X64-LABEL: test6a: 664 ; DARWIN-X64-NOT: callq ___stack_chk_fail 665 ; DARWIN-X64: .cfi_endproc 666 %retval = alloca i32, align 4 667 %a = alloca i32, align 4 668 %j = alloca i32*, align 8 669 store i32 0, i32* %retval 670 %0 = load i32* %a, align 4 671 %add = add nsw i32 %0, 1 672 store i32 %add, i32* %a, align 4 673 store i32* %a, i32** %j, align 8 674 ret void 675 } 676 677 ; test6b: Address-of local taken (j = &a) 678 ; ssp attribute 679 ; Requires no protector. 680 define void @test6b() nounwind uwtable ssp { 681 entry: 682 ; LINUX-I386-LABEL: test6b: 683 ; LINUX-I386-NOT: calll __stack_chk_fail 684 ; LINUX-I386: .cfi_endproc 685 686 ; LINUX-X64-LABEL: test6b: 687 ; LINUX-X64-NOT: callq __stack_chk_fail 688 ; LINUX-X64: .cfi_endproc 689 690 ; LINUX-KERNEL-X64-LABEL: test6b: 691 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 692 ; LINUX-KERNEL-X64: .cfi_endproc 693 694 ; DARWIN-X64-LABEL: test6b: 695 ; DARWIN-X64-NOT: callq ___stack_chk_fail 696 ; DARWIN-X64: .cfi_endproc 697 %retval = alloca i32, align 4 698 %a = alloca i32, align 4 699 %j = alloca i32*, align 8 700 store i32 0, i32* %retval 701 %0 = load i32* %a, align 4 702 %add = add nsw i32 %0, 1 703 store i32 %add, i32* %a, align 4 704 store i32* %a, i32** %j, align 8 705 ret void 706 } 707 708 ; test6c: Address-of local taken (j = &a) 709 ; sspstrong attribute 710 ; Requires protector. 711 define void @test6c() nounwind uwtable sspstrong { 712 entry: 713 ; LINUX-I386-LABEL: test6c: 714 ; LINUX-I386: mov{{l|q}} %gs: 715 ; LINUX-I386: calll __stack_chk_fail 716 717 ; LINUX-X64-LABEL: test6c: 718 ; LINUX-X64: mov{{l|q}} %fs: 719 ; LINUX-X64: callq __stack_chk_fail 720 721 ; LINUX-KERNEL-X64-LABEL: test6c: 722 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 723 ; LINUX-KERNEL-X64: callq __stack_chk_fail 724 725 ; DARWIN-X64-LABEL: test6c: 726 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 727 ; DARWIN-X64: callq ___stack_chk_fail 728 %retval = alloca i32, align 4 729 %a = alloca i32, align 4 730 %j = alloca i32*, align 8 731 store i32 0, i32* %retval 732 %0 = load i32* %a, align 4 733 %add = add nsw i32 %0, 1 734 store i32 %add, i32* %a, align 4 735 store i32* %a, i32** %j, align 8 736 ret void 737 } 738 739 ; test6d: Address-of local taken (j = &a) 740 ; sspreq attribute 741 ; Requires protector. 742 define void @test6d() nounwind uwtable sspreq { 743 entry: 744 ; LINUX-I386-LABEL: test6d: 745 ; LINUX-I386: mov{{l|q}} %gs: 746 ; LINUX-I386: calll __stack_chk_fail 747 748 ; LINUX-X64-LABEL: test6d: 749 ; LINUX-X64: mov{{l|q}} %fs: 750 ; LINUX-X64: callq __stack_chk_fail 751 752 ; LINUX-KERNEL-X64-LABEL: test6d: 753 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 754 ; LINUX-KERNEL-X64: callq __stack_chk_fail 755 756 ; DARWIN-X64-LABEL: test6d: 757 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 758 ; DARWIN-X64: callq ___stack_chk_fail 759 %retval = alloca i32, align 4 760 %a = alloca i32, align 4 761 %j = alloca i32*, align 8 762 store i32 0, i32* %retval 763 %0 = load i32* %a, align 4 764 %add = add nsw i32 %0, 1 765 store i32 %add, i32* %a, align 4 766 store i32* %a, i32** %j, align 8 767 ret void 768 } 769 770 ; test7a: PtrToInt Cast 771 ; no ssp attribute 772 ; Requires no protector. 773 define void @test7a() nounwind uwtable readnone { 774 entry: 775 ; LINUX-I386-LABEL: test7a: 776 ; LINUX-I386-NOT: calll __stack_chk_fail 777 ; LINUX-I386: .cfi_endproc 778 779 ; LINUX-X64-LABEL: test7a: 780 ; LINUX-X64-NOT: callq __stack_chk_fail 781 ; LINUX-X64: .cfi_endproc 782 783 ; LINUX-KERNEL-X64-LABEL: test7a: 784 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 785 ; LINUX-KERNEL-X64: .cfi_endproc 786 787 ; DARWIN-X64-LABEL: test7a: 788 ; DARWIN-X64-NOT: callq ___stack_chk_fail 789 ; DARWIN-X64: .cfi_endproc 790 %a = alloca i32, align 4 791 %0 = ptrtoint i32* %a to i64 792 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 793 ret void 794 } 795 796 ; test7b: PtrToInt Cast 797 ; ssp attribute 798 ; Requires no protector. 799 define void @test7b() nounwind uwtable readnone ssp { 800 entry: 801 ; LINUX-I386-LABEL: test7b: 802 ; LINUX-I386-NOT: calll __stack_chk_fail 803 ; LINUX-I386: .cfi_endproc 804 805 ; LINUX-X64-LABEL: test7b: 806 ; LINUX-X64-NOT: callq __stack_chk_fail 807 ; LINUX-X64: .cfi_endproc 808 809 ; LINUX-KERNEL-X64-LABEL: test7b: 810 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 811 ; LINUX-KERNEL-X64: .cfi_endproc 812 813 ; DARWIN-X64-LABEL: test7b: 814 ; DARWIN-X64-NOT: callq ___stack_chk_fail 815 ; DARWIN-X64: .cfi_endproc 816 %a = alloca i32, align 4 817 %0 = ptrtoint i32* %a to i64 818 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 819 ret void 820 } 821 822 ; test7c: PtrToInt Cast 823 ; sspstrong attribute 824 ; Requires protector. 825 define void @test7c() nounwind uwtable readnone sspstrong { 826 entry: 827 ; LINUX-I386-LABEL: test7c: 828 ; LINUX-I386: mov{{l|q}} %gs: 829 ; LINUX-I386: calll __stack_chk_fail 830 831 ; LINUX-X64-LABEL: test7c: 832 ; LINUX-X64: mov{{l|q}} %fs: 833 ; LINUX-X64: callq __stack_chk_fail 834 835 ; LINUX-KERNEL-X64-LABEL: test7c: 836 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 837 ; LINUX-KERNEL-X64: callq __stack_chk_fail 838 839 ; DARWIN-X64-LABEL: test7c: 840 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 841 ; DARWIN-X64: callq ___stack_chk_fail 842 %a = alloca i32, align 4 843 %0 = ptrtoint i32* %a to i64 844 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 845 ret void 846 } 847 848 ; test7d: PtrToInt Cast 849 ; sspreq attribute 850 ; Requires protector. 851 define void @test7d() nounwind uwtable readnone sspreq { 852 entry: 853 ; LINUX-I386-LABEL: test7d: 854 ; LINUX-I386: mov{{l|q}} %gs: 855 ; LINUX-I386: calll __stack_chk_fail 856 857 ; LINUX-X64-LABEL: test7d: 858 ; LINUX-X64: mov{{l|q}} %fs: 859 ; LINUX-X64: callq __stack_chk_fail 860 861 ; LINUX-KERNEL-X64-LABEL: test7d: 862 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 863 ; LINUX-KERNEL-X64: callq __stack_chk_fail 864 865 ; DARWIN-X64-LABEL: test7d: 866 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 867 ; DARWIN-X64: callq ___stack_chk_fail 868 %a = alloca i32, align 4 869 %0 = ptrtoint i32* %a to i64 870 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 871 ret void 872 } 873 874 ; test8a: Passing addr-of to function call 875 ; no ssp attribute 876 ; Requires no protector. 877 define void @test8a() nounwind uwtable { 878 entry: 879 ; LINUX-I386-LABEL: test8a: 880 ; LINUX-I386-NOT: calll __stack_chk_fail 881 ; LINUX-I386: .cfi_endproc 882 883 ; LINUX-X64-LABEL: test8a: 884 ; LINUX-X64-NOT: callq __stack_chk_fail 885 ; LINUX-X64: .cfi_endproc 886 887 ; LINUX-KERNEL-X64-LABEL: test8a: 888 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 889 ; LINUX-KERNEL-X64: .cfi_endproc 890 891 ; DARWIN-X64-LABEL: test8a: 892 ; DARWIN-X64-NOT: callq ___stack_chk_fail 893 ; DARWIN-X64: .cfi_endproc 894 %b = alloca i32, align 4 895 call void @funcall(i32* %b) nounwind 896 ret void 897 } 898 899 ; test8b: Passing addr-of to function call 900 ; ssp attribute 901 ; Requires no protector. 902 define void @test8b() nounwind uwtable ssp { 903 entry: 904 ; LINUX-I386-LABEL: test8b: 905 ; LINUX-I386-NOT: calll __stack_chk_fail 906 ; LINUX-I386: .cfi_endproc 907 908 ; LINUX-X64-LABEL: test8b: 909 ; LINUX-X64-NOT: callq __stack_chk_fail 910 ; LINUX-X64: .cfi_endproc 911 912 ; LINUX-KERNEL-X64-LABEL: test8b: 913 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 914 ; LINUX-KERNEL-X64: .cfi_endproc 915 916 ; DARWIN-X64-LABEL: test8b: 917 ; DARWIN-X64-NOT: callq ___stack_chk_fail 918 ; DARWIN-X64: .cfi_endproc 919 %b = alloca i32, align 4 920 call void @funcall(i32* %b) nounwind 921 ret void 922 } 923 924 ; test8c: Passing addr-of to function call 925 ; sspstrong attribute 926 ; Requires protector. 927 define void @test8c() nounwind uwtable sspstrong { 928 entry: 929 ; LINUX-I386-LABEL: test8c: 930 ; LINUX-I386: mov{{l|q}} %gs: 931 ; LINUX-I386: calll __stack_chk_fail 932 933 ; LINUX-X64-LABEL: test8c: 934 ; LINUX-X64: mov{{l|q}} %fs: 935 ; LINUX-X64: callq __stack_chk_fail 936 937 ; LINUX-KERNEL-X64-LABEL: test8c: 938 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 939 ; LINUX-KERNEL-X64: callq __stack_chk_fail 940 941 ; DARWIN-X64-LABEL: test8c: 942 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 943 ; DARWIN-X64: callq ___stack_chk_fail 944 %b = alloca i32, align 4 945 call void @funcall(i32* %b) nounwind 946 ret void 947 } 948 949 ; test8d: Passing addr-of to function call 950 ; sspreq attribute 951 ; Requires protector. 952 define void @test8d() nounwind uwtable sspreq { 953 entry: 954 ; LINUX-I386-LABEL: test8d: 955 ; LINUX-I386: mov{{l|q}} %gs: 956 ; LINUX-I386: calll __stack_chk_fail 957 958 ; LINUX-X64-LABEL: test8d: 959 ; LINUX-X64: mov{{l|q}} %fs: 960 ; LINUX-X64: callq __stack_chk_fail 961 962 ; LINUX-KERNEL-X64-LABEL: test8d: 963 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 964 ; LINUX-KERNEL-X64: callq __stack_chk_fail 965 966 ; DARWIN-X64-LABEL: test8d: 967 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 968 ; DARWIN-X64: callq ___stack_chk_fail 969 %b = alloca i32, align 4 970 call void @funcall(i32* %b) nounwind 971 ret void 972 } 973 974 ; test9a: Addr-of in select instruction 975 ; no ssp attribute 976 ; Requires no protector. 977 define void @test9a() nounwind uwtable { 978 entry: 979 ; LINUX-I386-LABEL: test9a: 980 ; LINUX-I386-NOT: calll __stack_chk_fail 981 ; LINUX-I386: .cfi_endproc 982 983 ; LINUX-X64-LABEL: test9a: 984 ; LINUX-X64-NOT: callq __stack_chk_fail 985 ; LINUX-X64: .cfi_endproc 986 987 ; LINUX-KERNEL-X64-LABEL: test9a: 988 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 989 ; LINUX-KERNEL-X64: .cfi_endproc 990 991 ; DARWIN-X64-LABEL: test9a: 992 ; DARWIN-X64-NOT: callq ___stack_chk_fail 993 ; DARWIN-X64: .cfi_endproc 994 %x = alloca double, align 8 995 %call = call double @testi_aux() nounwind 996 store double %call, double* %x, align 8 997 %cmp2 = fcmp ogt double %call, 0.000000e+00 998 %y.1 = select i1 %cmp2, double* %x, double* null 999 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1000 ret void 1001 } 1002 1003 ; test9b: Addr-of in select instruction 1004 ; ssp attribute 1005 ; Requires no protector. 1006 define void @test9b() nounwind uwtable ssp { 1007 entry: 1008 ; LINUX-I386-LABEL: test9b: 1009 ; LINUX-I386-NOT: calll __stack_chk_fail 1010 ; LINUX-I386: .cfi_endproc 1011 1012 ; LINUX-X64-LABEL: test9b: 1013 ; LINUX-X64-NOT: callq __stack_chk_fail 1014 ; LINUX-X64: .cfi_endproc 1015 1016 ; LINUX-KERNEL-X64-LABEL: test9b: 1017 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1018 ; LINUX-KERNEL-X64: .cfi_endproc 1019 1020 ; DARWIN-X64-LABEL: test9b: 1021 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1022 ; DARWIN-X64: .cfi_endproc 1023 %x = alloca double, align 8 1024 %call = call double @testi_aux() nounwind 1025 store double %call, double* %x, align 8 1026 %cmp2 = fcmp ogt double %call, 0.000000e+00 1027 %y.1 = select i1 %cmp2, double* %x, double* null 1028 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1029 ret void 1030 } 1031 1032 ; test9c: Addr-of in select instruction 1033 ; sspstrong attribute 1034 ; Requires protector. 1035 define void @test9c() nounwind uwtable sspstrong { 1036 entry: 1037 ; LINUX-I386-LABEL: test9c: 1038 ; LINUX-I386: mov{{l|q}} %gs: 1039 ; LINUX-I386: calll __stack_chk_fail 1040 1041 ; LINUX-X64-LABEL: test9c: 1042 ; LINUX-X64: mov{{l|q}} %fs: 1043 ; LINUX-X64: callq __stack_chk_fail 1044 1045 ; LINUX-KERNEL-X64-LABEL: test9c: 1046 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1047 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1048 1049 ; DARWIN-X64-LABEL: test9c: 1050 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1051 ; DARWIN-X64: callq ___stack_chk_fail 1052 %x = alloca double, align 8 1053 %call = call double @testi_aux() nounwind 1054 store double %call, double* %x, align 8 1055 %cmp2 = fcmp ogt double %call, 0.000000e+00 1056 %y.1 = select i1 %cmp2, double* %x, double* null 1057 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1058 ret void 1059 } 1060 1061 ; test9d: Addr-of in select instruction 1062 ; sspreq attribute 1063 ; Requires protector. 1064 define void @test9d() nounwind uwtable sspreq { 1065 entry: 1066 ; LINUX-I386-LABEL: test9d: 1067 ; LINUX-I386: mov{{l|q}} %gs: 1068 ; LINUX-I386: calll __stack_chk_fail 1069 1070 ; LINUX-X64-LABEL: test9d: 1071 ; LINUX-X64: mov{{l|q}} %fs: 1072 ; LINUX-X64: callq __stack_chk_fail 1073 1074 ; LINUX-KERNEL-X64-LABEL: test9d: 1075 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1076 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1077 1078 ; DARWIN-X64-LABEL: test9d: 1079 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1080 ; DARWIN-X64: callq ___stack_chk_fail 1081 %x = alloca double, align 8 1082 %call = call double @testi_aux() nounwind 1083 store double %call, double* %x, align 8 1084 %cmp2 = fcmp ogt double %call, 0.000000e+00 1085 %y.1 = select i1 %cmp2, double* %x, double* null 1086 %call2 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), double* %y.1) 1087 ret void 1088 } 1089 1090 ; test10a: Addr-of in phi instruction 1091 ; no ssp attribute 1092 ; Requires no protector. 1093 define void @test10a() nounwind uwtable { 1094 entry: 1095 ; LINUX-I386-LABEL: test10a: 1096 ; LINUX-I386-NOT: calll __stack_chk_fail 1097 ; LINUX-I386: .cfi_endproc 1098 1099 ; LINUX-X64-LABEL: test10a: 1100 ; LINUX-X64-NOT: callq __stack_chk_fail 1101 ; LINUX-X64: .cfi_endproc 1102 1103 ; LINUX-KERNEL-X64-LABEL: test10a: 1104 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1105 ; LINUX-KERNEL-X64: .cfi_endproc 1106 1107 ; DARWIN-X64-LABEL: test10a: 1108 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1109 ; DARWIN-X64: .cfi_endproc 1110 %x = alloca double, align 8 1111 %call = call double @testi_aux() nounwind 1112 store double %call, double* %x, align 8 1113 %cmp = fcmp ogt double %call, 3.140000e+00 1114 br i1 %cmp, label %if.then, label %if.else 1115 1116 if.then: ; preds = %entry 1117 %call1 = call double @testi_aux() nounwind 1118 store double %call1, double* %x, align 8 1119 br label %if.end4 1120 1121 if.else: ; preds = %entry 1122 %cmp2 = fcmp ogt double %call, 1.000000e+00 1123 br i1 %cmp2, label %if.then3, label %if.end4 1124 1125 if.then3: ; preds = %if.else 1126 br label %if.end4 1127 1128 if.end4: ; preds = %if.else, %if.then3, %if.then 1129 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1130 %call5 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), double* %y.0) nounwind 1131 ret void 1132 } 1133 1134 ; test10b: Addr-of in phi instruction 1135 ; ssp attribute 1136 ; Requires no protector. 1137 define void @test10b() nounwind uwtable ssp { 1138 entry: 1139 ; LINUX-I386-LABEL: test10b: 1140 ; LINUX-I386-NOT: calll __stack_chk_fail 1141 ; LINUX-I386: .cfi_endproc 1142 1143 ; LINUX-X64-LABEL: test10b: 1144 ; LINUX-X64-NOT: callq __stack_chk_fail 1145 ; LINUX-X64: .cfi_endproc 1146 1147 ; LINUX-KERNEL-X64-LABEL: test10b: 1148 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1149 ; LINUX-KERNEL-X64: .cfi_endproc 1150 1151 ; DARWIN-X64-LABEL: test10b: 1152 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1153 ; DARWIN-X64: .cfi_endproc 1154 %x = alloca double, align 8 1155 %call = call double @testi_aux() nounwind 1156 store double %call, double* %x, align 8 1157 %cmp = fcmp ogt double %call, 3.140000e+00 1158 br i1 %cmp, label %if.then, label %if.else 1159 1160 if.then: ; preds = %entry 1161 %call1 = call double @testi_aux() nounwind 1162 store double %call1, double* %x, align 8 1163 br label %if.end4 1164 1165 if.else: ; preds = %entry 1166 %cmp2 = fcmp ogt double %call, 1.000000e+00 1167 br i1 %cmp2, label %if.then3, label %if.end4 1168 1169 if.then3: ; preds = %if.else 1170 br label %if.end4 1171 1172 if.end4: ; preds = %if.else, %if.then3, %if.then 1173 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1174 %call5 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), double* %y.0) nounwind 1175 ret void 1176 } 1177 1178 ; test10c: Addr-of in phi instruction 1179 ; sspstrong attribute 1180 ; Requires protector. 1181 define void @test10c() nounwind uwtable sspstrong { 1182 entry: 1183 ; LINUX-I386-LABEL: test10c: 1184 ; LINUX-I386: mov{{l|q}} %gs: 1185 ; LINUX-I386: calll __stack_chk_fail 1186 1187 ; LINUX-X64-LABEL: test10c: 1188 ; LINUX-X64: mov{{l|q}} %fs: 1189 ; LINUX-X64: callq __stack_chk_fail 1190 1191 ; LINUX-KERNEL-X64-LABEL: test10c: 1192 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1193 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1194 1195 ; DARWIN-X64-LABEL: test10c: 1196 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1197 ; DARWIN-X64: callq ___stack_chk_fail 1198 %x = alloca double, align 8 1199 %call = call double @testi_aux() nounwind 1200 store double %call, double* %x, align 8 1201 %cmp = fcmp ogt double %call, 3.140000e+00 1202 br i1 %cmp, label %if.then, label %if.else 1203 1204 if.then: ; preds = %entry 1205 %call1 = call double @testi_aux() nounwind 1206 store double %call1, double* %x, align 8 1207 br label %if.end4 1208 1209 if.else: ; preds = %entry 1210 %cmp2 = fcmp ogt double %call, 1.000000e+00 1211 br i1 %cmp2, label %if.then3, label %if.end4 1212 1213 if.then3: ; preds = %if.else 1214 br label %if.end4 1215 1216 if.end4: ; preds = %if.else, %if.then3, %if.then 1217 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1218 %call5 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), double* %y.0) nounwind 1219 ret void 1220 } 1221 1222 ; test10d: Addr-of in phi instruction 1223 ; sspreq attribute 1224 ; Requires protector. 1225 define void @test10d() nounwind uwtable sspreq { 1226 entry: 1227 ; LINUX-I386-LABEL: test10d: 1228 ; LINUX-I386: mov{{l|q}} %gs: 1229 ; LINUX-I386: calll __stack_chk_fail 1230 1231 ; LINUX-X64-LABEL: test10d: 1232 ; LINUX-X64: mov{{l|q}} %fs: 1233 ; LINUX-X64: callq __stack_chk_fail 1234 1235 ; LINUX-KERNEL-X64-LABEL: test10d: 1236 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1237 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1238 1239 ; DARWIN-X64-LABEL: test10d: 1240 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1241 ; DARWIN-X64: callq ___stack_chk_fail 1242 %x = alloca double, align 8 1243 %call = call double @testi_aux() nounwind 1244 store double %call, double* %x, align 8 1245 %cmp = fcmp ogt double %call, 3.140000e+00 1246 br i1 %cmp, label %if.then, label %if.else 1247 1248 if.then: ; preds = %entry 1249 %call1 = call double @testi_aux() nounwind 1250 store double %call1, double* %x, align 8 1251 br label %if.end4 1252 1253 if.else: ; preds = %entry 1254 %cmp2 = fcmp ogt double %call, 1.000000e+00 1255 br i1 %cmp2, label %if.then3, label %if.end4 1256 1257 if.then3: ; preds = %if.else 1258 br label %if.end4 1259 1260 if.end4: ; preds = %if.else, %if.then3, %if.then 1261 %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ] 1262 %call5 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), double* %y.0) nounwind 1263 ret void 1264 } 1265 1266 ; test11a: Addr-of struct element. (GEP followed by store). 1267 ; no ssp attribute 1268 ; Requires no protector. 1269 define void @test11a() nounwind uwtable { 1270 entry: 1271 ; LINUX-I386-LABEL: test11a: 1272 ; LINUX-I386-NOT: calll __stack_chk_fail 1273 ; LINUX-I386: .cfi_endproc 1274 1275 ; LINUX-X64-LABEL: test11a: 1276 ; LINUX-X64-NOT: callq __stack_chk_fail 1277 ; LINUX-X64: .cfi_endproc 1278 1279 ; LINUX-KERNEL-X64-LABEL: test11a: 1280 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1281 ; LINUX-KERNEL-X64: .cfi_endproc 1282 1283 ; DARWIN-X64-LABEL: test11a: 1284 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1285 ; DARWIN-X64: .cfi_endproc 1286 %c = alloca %struct.pair, align 4 1287 %b = alloca i32*, align 8 1288 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1289 store i32* %y, i32** %b, align 8 1290 %0 = load i32** %b, align 8 1291 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32* %0) 1292 ret void 1293 } 1294 1295 ; test11b: Addr-of struct element. (GEP followed by store). 1296 ; ssp attribute 1297 ; Requires no protector. 1298 define void @test11b() nounwind uwtable ssp { 1299 entry: 1300 ; LINUX-I386-LABEL: test11b: 1301 ; LINUX-I386-NOT: calll __stack_chk_fail 1302 ; LINUX-I386: .cfi_endproc 1303 1304 ; LINUX-X64-LABEL: test11b: 1305 ; LINUX-X64-NOT: callq __stack_chk_fail 1306 ; LINUX-X64: .cfi_endproc 1307 1308 ; LINUX-KERNEL-X64-LABEL: test11b: 1309 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1310 ; LINUX-KERNEL-X64: .cfi_endproc 1311 1312 ; DARWIN-X64-LABEL: test11b: 1313 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1314 ; DARWIN-X64: .cfi_endproc 1315 %c = alloca %struct.pair, align 4 1316 %b = alloca i32*, align 8 1317 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1318 store i32* %y, i32** %b, align 8 1319 %0 = load i32** %b, align 8 1320 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32* %0) 1321 ret void 1322 } 1323 1324 ; test11c: Addr-of struct element. (GEP followed by store). 1325 ; sspstrong attribute 1326 ; Requires protector. 1327 define void @test11c() nounwind uwtable sspstrong { 1328 entry: 1329 ; LINUX-I386-LABEL: test11c: 1330 ; LINUX-I386: mov{{l|q}} %gs: 1331 ; LINUX-I386: calll __stack_chk_fail 1332 1333 ; LINUX-X64-LABEL: test11c: 1334 ; LINUX-X64: mov{{l|q}} %fs: 1335 ; LINUX-X64: callq __stack_chk_fail 1336 1337 ; LINUX-KERNEL-X64-LABEL: test11c: 1338 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1339 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1340 1341 ; DARWIN-X64-LABEL: test11c: 1342 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1343 ; DARWIN-X64: callq ___stack_chk_fail 1344 %c = alloca %struct.pair, align 4 1345 %b = alloca i32*, align 8 1346 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1347 store i32* %y, i32** %b, align 8 1348 %0 = load i32** %b, align 8 1349 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32* %0) 1350 ret void 1351 } 1352 1353 ; test11d: Addr-of struct element. (GEP followed by store). 1354 ; sspreq attribute 1355 ; Requires protector. 1356 define void @test11d() nounwind uwtable sspreq { 1357 entry: 1358 ; LINUX-I386-LABEL: test11d: 1359 ; LINUX-I386: mov{{l|q}} %gs: 1360 ; LINUX-I386: calll __stack_chk_fail 1361 1362 ; LINUX-X64-LABEL: test11d: 1363 ; LINUX-X64: mov{{l|q}} %fs: 1364 ; LINUX-X64: callq __stack_chk_fail 1365 1366 ; LINUX-KERNEL-X64-LABEL: test11d: 1367 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1368 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1369 1370 ; DARWIN-X64-LABEL: test11d: 1371 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1372 ; DARWIN-X64: callq ___stack_chk_fail 1373 %c = alloca %struct.pair, align 4 1374 %b = alloca i32*, align 8 1375 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1376 store i32* %y, i32** %b, align 8 1377 %0 = load i32** %b, align 8 1378 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32* %0) 1379 ret void 1380 } 1381 1382 ; test12a: Addr-of struct element, GEP followed by ptrtoint. 1383 ; no ssp attribute 1384 ; Requires no protector. 1385 define void @test12a() nounwind uwtable { 1386 entry: 1387 ; LINUX-I386-LABEL: test12a: 1388 ; LINUX-I386-NOT: calll __stack_chk_fail 1389 ; LINUX-I386: .cfi_endproc 1390 1391 ; LINUX-X64-LABEL: test12a: 1392 ; LINUX-X64-NOT: callq __stack_chk_fail 1393 ; LINUX-X64: .cfi_endproc 1394 1395 ; LINUX-KERNEL-X64-LABEL: test12a: 1396 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1397 ; LINUX-KERNEL-X64: .cfi_endproc 1398 1399 ; DARWIN-X64-LABEL: test12a: 1400 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1401 ; DARWIN-X64: .cfi_endproc 1402 %c = alloca %struct.pair, align 4 1403 %b = alloca i32*, align 8 1404 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1405 %0 = ptrtoint i32* %y to i64 1406 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 1407 ret void 1408 } 1409 1410 ; test12b: Addr-of struct element, GEP followed by ptrtoint. 1411 ; ssp attribute 1412 ; Requires no protector. 1413 define void @test12b() nounwind uwtable ssp { 1414 entry: 1415 ; LINUX-I386-LABEL: test12b: 1416 ; LINUX-I386-NOT: calll __stack_chk_fail 1417 ; LINUX-I386: .cfi_endproc 1418 1419 ; LINUX-X64-LABEL: test12b: 1420 ; LINUX-X64-NOT: callq __stack_chk_fail 1421 ; LINUX-X64: .cfi_endproc 1422 1423 ; LINUX-KERNEL-X64-LABEL: test12b: 1424 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1425 ; LINUX-KERNEL-X64: .cfi_endproc 1426 1427 ; DARWIN-X64-LABEL: test12b: 1428 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1429 ; DARWIN-X64: .cfi_endproc 1430 %c = alloca %struct.pair, align 4 1431 %b = alloca i32*, align 8 1432 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1433 %0 = ptrtoint i32* %y to i64 1434 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 1435 ret void 1436 } 1437 1438 ; test12c: Addr-of struct element, GEP followed by ptrtoint. 1439 ; sspstrong attribute 1440 ; Requires protector. 1441 define void @test12c() nounwind uwtable sspstrong { 1442 entry: 1443 ; LINUX-I386-LABEL: test12c: 1444 ; LINUX-I386: mov{{l|q}} %gs: 1445 ; LINUX-I386: calll __stack_chk_fail 1446 1447 ; LINUX-X64-LABEL: test12c: 1448 ; LINUX-X64: mov{{l|q}} %fs: 1449 ; LINUX-X64: callq __stack_chk_fail 1450 1451 ; LINUX-KERNEL-X64-LABEL: test12c: 1452 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1453 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1454 1455 ; DARWIN-X64-LABEL: test12c: 1456 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1457 ; DARWIN-X64: callq ___stack_chk_fail 1458 %c = alloca %struct.pair, align 4 1459 %b = alloca i32*, align 8 1460 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1461 %0 = ptrtoint i32* %y to i64 1462 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 1463 ret void 1464 } 1465 1466 ; test12d: Addr-of struct element, GEP followed by ptrtoint. 1467 ; sspreq attribute 1468 ; Requires protector. 1469 define void @test12d() nounwind uwtable sspreq { 1470 entry: 1471 ; LINUX-I386-LABEL: test12d: 1472 ; LINUX-I386: mov{{l|q}} %gs: 1473 ; LINUX-I386: calll __stack_chk_fail 1474 1475 ; LINUX-X64-LABEL: test12d: 1476 ; LINUX-X64: mov{{l|q}} %fs: 1477 ; LINUX-X64: callq __stack_chk_fail 1478 1479 ; LINUX-KERNEL-X64-LABEL: test12d: 1480 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1481 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1482 1483 ; DARWIN-X64-LABEL: test12d: 1484 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1485 ; DARWIN-X64: callq ___stack_chk_fail 1486 %c = alloca %struct.pair, align 4 1487 %b = alloca i32*, align 8 1488 %y = getelementptr inbounds %struct.pair* %c, i32 0, i32 1 1489 %0 = ptrtoint i32* %y to i64 1490 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i64 %0) 1491 ret void 1492 } 1493 1494 ; test13a: Addr-of struct element, GEP followed by callinst. 1495 ; no ssp attribute 1496 ; Requires no protector. 1497 define void @test13a() nounwind uwtable { 1498 entry: 1499 ; LINUX-I386-LABEL: test13a: 1500 ; LINUX-I386-NOT: calll __stack_chk_fail 1501 ; LINUX-I386: .cfi_endproc 1502 1503 ; LINUX-X64-LABEL: test13a: 1504 ; LINUX-X64-NOT: callq __stack_chk_fail 1505 ; LINUX-X64: .cfi_endproc 1506 1507 ; LINUX-KERNEL-X64-LABEL: test13a: 1508 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1509 ; LINUX-KERNEL-X64: .cfi_endproc 1510 1511 ; DARWIN-X64-LABEL: test13a: 1512 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1513 ; DARWIN-X64: .cfi_endproc 1514 %c = alloca %struct.pair, align 4 1515 %y = getelementptr inbounds %struct.pair* %c, i64 0, i32 1 1516 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %y) nounwind 1517 ret void 1518 } 1519 1520 ; test13b: Addr-of struct element, GEP followed by callinst. 1521 ; ssp attribute 1522 ; Requires no protector. 1523 define void @test13b() nounwind uwtable ssp { 1524 entry: 1525 ; LINUX-I386-LABEL: test13b: 1526 ; LINUX-I386-NOT: calll __stack_chk_fail 1527 ; LINUX-I386: .cfi_endproc 1528 1529 ; LINUX-X64-LABEL: test13b: 1530 ; LINUX-X64-NOT: callq __stack_chk_fail 1531 ; LINUX-X64: .cfi_endproc 1532 1533 ; LINUX-KERNEL-X64-LABEL: test13b: 1534 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1535 ; LINUX-KERNEL-X64: .cfi_endproc 1536 1537 ; DARWIN-X64-LABEL: test13b: 1538 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1539 ; DARWIN-X64: .cfi_endproc 1540 %c = alloca %struct.pair, align 4 1541 %y = getelementptr inbounds %struct.pair* %c, i64 0, i32 1 1542 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %y) nounwind 1543 ret void 1544 } 1545 1546 ; test13c: Addr-of struct element, GEP followed by callinst. 1547 ; sspstrong attribute 1548 ; Requires protector. 1549 define void @test13c() nounwind uwtable sspstrong { 1550 entry: 1551 ; LINUX-I386-LABEL: test13c: 1552 ; LINUX-I386: mov{{l|q}} %gs: 1553 ; LINUX-I386: calll __stack_chk_fail 1554 1555 ; LINUX-X64-LABEL: test13c: 1556 ; LINUX-X64: mov{{l|q}} %fs: 1557 ; LINUX-X64: callq __stack_chk_fail 1558 1559 ; LINUX-KERNEL-X64-LABEL: test13c: 1560 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1561 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1562 1563 ; DARWIN-X64-LABEL: test13c: 1564 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1565 ; DARWIN-X64: callq ___stack_chk_fail 1566 %c = alloca %struct.pair, align 4 1567 %y = getelementptr inbounds %struct.pair* %c, i64 0, i32 1 1568 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %y) nounwind 1569 ret void 1570 } 1571 1572 ; test13d: Addr-of struct element, GEP followed by callinst. 1573 ; sspreq attribute 1574 ; Requires protector. 1575 define void @test13d() nounwind uwtable sspreq { 1576 entry: 1577 ; LINUX-I386-LABEL: test13d: 1578 ; LINUX-I386: mov{{l|q}} %gs: 1579 ; LINUX-I386: calll __stack_chk_fail 1580 1581 ; LINUX-X64-LABEL: test13d: 1582 ; LINUX-X64: mov{{l|q}} %fs: 1583 ; LINUX-X64: callq __stack_chk_fail 1584 1585 ; LINUX-KERNEL-X64-LABEL: test13d: 1586 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1587 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1588 1589 ; DARWIN-X64-LABEL: test13d: 1590 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1591 ; DARWIN-X64: callq ___stack_chk_fail 1592 %c = alloca %struct.pair, align 4 1593 %y = getelementptr inbounds %struct.pair* %c, i64 0, i32 1 1594 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %y) nounwind 1595 ret void 1596 } 1597 1598 ; test14a: Addr-of a local, optimized into a GEP (e.g., &a - 12) 1599 ; no ssp attribute 1600 ; Requires no protector. 1601 define void @test14a() nounwind uwtable { 1602 entry: 1603 ; LINUX-I386-LABEL: test14a: 1604 ; LINUX-I386-NOT: calll __stack_chk_fail 1605 ; LINUX-I386: .cfi_endproc 1606 1607 ; LINUX-X64-LABEL: test14a: 1608 ; LINUX-X64-NOT: callq __stack_chk_fail 1609 ; LINUX-X64: .cfi_endproc 1610 1611 ; LINUX-KERNEL-X64-LABEL: test14a: 1612 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1613 ; LINUX-KERNEL-X64: .cfi_endproc 1614 1615 ; DARWIN-X64-LABEL: test14a: 1616 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1617 ; DARWIN-X64: .cfi_endproc 1618 %a = alloca i32, align 4 1619 %add.ptr5 = getelementptr inbounds i32* %a, i64 -12 1620 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) nounwind 1621 ret void 1622 } 1623 1624 ; test14b: Addr-of a local, optimized into a GEP (e.g., &a - 12) 1625 ; ssp attribute 1626 ; Requires no protector. 1627 define void @test14b() nounwind uwtable ssp { 1628 entry: 1629 ; LINUX-I386-LABEL: test14b: 1630 ; LINUX-I386-NOT: calll __stack_chk_fail 1631 ; LINUX-I386: .cfi_endproc 1632 1633 ; LINUX-X64-LABEL: test14b: 1634 ; LINUX-X64-NOT: callq __stack_chk_fail 1635 ; LINUX-X64: .cfi_endproc 1636 1637 ; LINUX-KERNEL-X64-LABEL: test14b: 1638 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1639 ; LINUX-KERNEL-X64: .cfi_endproc 1640 1641 ; DARWIN-X64-LABEL: test14b: 1642 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1643 ; DARWIN-X64: .cfi_endproc 1644 %a = alloca i32, align 4 1645 %add.ptr5 = getelementptr inbounds i32* %a, i64 -12 1646 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) nounwind 1647 ret void 1648 } 1649 1650 ; test14c: Addr-of a local, optimized into a GEP (e.g., &a - 12) 1651 ; sspstrong attribute 1652 ; Requires protector. 1653 define void @test14c() nounwind uwtable sspstrong { 1654 entry: 1655 ; LINUX-I386-LABEL: test14c: 1656 ; LINUX-I386: mov{{l|q}} %gs: 1657 ; LINUX-I386: calll __stack_chk_fail 1658 1659 ; LINUX-X64-LABEL: test14c: 1660 ; LINUX-X64: mov{{l|q}} %fs: 1661 ; LINUX-X64: callq __stack_chk_fail 1662 1663 ; LINUX-KERNEL-X64-LABEL: test14c: 1664 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1665 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1666 1667 ; DARWIN-X64-LABEL: test14c: 1668 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1669 ; DARWIN-X64: callq ___stack_chk_fail 1670 %a = alloca i32, align 4 1671 %add.ptr5 = getelementptr inbounds i32* %a, i64 -12 1672 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) nounwind 1673 ret void 1674 } 1675 1676 ; test14d: Addr-of a local, optimized into a GEP (e.g., &a - 12) 1677 ; sspreq attribute 1678 ; Requires protector. 1679 define void @test14d() nounwind uwtable sspreq { 1680 entry: 1681 ; LINUX-I386-LABEL: test14d: 1682 ; LINUX-I386: mov{{l|q}} %gs: 1683 ; LINUX-I386: calll __stack_chk_fail 1684 1685 ; LINUX-X64-LABEL: test14d: 1686 ; LINUX-X64: mov{{l|q}} %fs: 1687 ; LINUX-X64: callq __stack_chk_fail 1688 1689 ; LINUX-KERNEL-X64-LABEL: test14d: 1690 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1691 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1692 1693 ; DARWIN-X64-LABEL: test14d: 1694 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1695 ; DARWIN-X64: callq ___stack_chk_fail 1696 %a = alloca i32, align 4 1697 %add.ptr5 = getelementptr inbounds i32* %a, i64 -12 1698 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) nounwind 1699 ret void 1700 } 1701 1702 ; test15a: Addr-of a local cast to a ptr of a different type 1703 ; (e.g., int a; ... ; float *b = &a;) 1704 ; no ssp attribute 1705 ; Requires no protector. 1706 define void @test15a() nounwind uwtable { 1707 entry: 1708 ; LINUX-I386-LABEL: test15a: 1709 ; LINUX-I386-NOT: calll __stack_chk_fail 1710 ; LINUX-I386: .cfi_endproc 1711 1712 ; LINUX-X64-LABEL: test15a: 1713 ; LINUX-X64-NOT: callq __stack_chk_fail 1714 ; LINUX-X64: .cfi_endproc 1715 1716 ; LINUX-KERNEL-X64-LABEL: test15a: 1717 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1718 ; LINUX-KERNEL-X64: .cfi_endproc 1719 1720 ; DARWIN-X64-LABEL: test15a: 1721 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1722 ; DARWIN-X64: .cfi_endproc 1723 %a = alloca i32, align 4 1724 %b = alloca float*, align 8 1725 store i32 0, i32* %a, align 4 1726 %0 = bitcast i32* %a to float* 1727 store float* %0, float** %b, align 8 1728 %1 = load float** %b, align 8 1729 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), float* %1) 1730 ret void 1731 } 1732 1733 ; test15b: Addr-of a local cast to a ptr of a different type 1734 ; (e.g., int a; ... ; float *b = &a;) 1735 ; ssp attribute 1736 ; Requires no protector. 1737 define void @test15b() nounwind uwtable ssp { 1738 entry: 1739 ; LINUX-I386-LABEL: test15b: 1740 ; LINUX-I386-NOT: calll __stack_chk_fail 1741 ; LINUX-I386: .cfi_endproc 1742 1743 ; LINUX-X64-LABEL: test15b: 1744 ; LINUX-X64-NOT: callq __stack_chk_fail 1745 ; LINUX-X64: .cfi_endproc 1746 1747 ; LINUX-KERNEL-X64-LABEL: test15b: 1748 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1749 ; LINUX-KERNEL-X64: .cfi_endproc 1750 1751 ; DARWIN-X64-LABEL: test15b: 1752 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1753 ; DARWIN-X64: .cfi_endproc 1754 %a = alloca i32, align 4 1755 %b = alloca float*, align 8 1756 store i32 0, i32* %a, align 4 1757 %0 = bitcast i32* %a to float* 1758 store float* %0, float** %b, align 8 1759 %1 = load float** %b, align 8 1760 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), float* %1) 1761 ret void 1762 } 1763 1764 ; test15c: Addr-of a local cast to a ptr of a different type 1765 ; (e.g., int a; ... ; float *b = &a;) 1766 ; sspstrong attribute 1767 ; Requires protector. 1768 define void @test15c() nounwind uwtable sspstrong { 1769 entry: 1770 ; LINUX-I386-LABEL: test15c: 1771 ; LINUX-I386: mov{{l|q}} %gs: 1772 ; LINUX-I386: calll __stack_chk_fail 1773 1774 ; LINUX-X64-LABEL: test15c: 1775 ; LINUX-X64: mov{{l|q}} %fs: 1776 ; LINUX-X64: callq __stack_chk_fail 1777 1778 ; LINUX-KERNEL-X64-LABEL: test15c: 1779 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1780 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1781 1782 ; DARWIN-X64-LABEL: test15c: 1783 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1784 ; DARWIN-X64: callq ___stack_chk_fail 1785 %a = alloca i32, align 4 1786 %b = alloca float*, align 8 1787 store i32 0, i32* %a, align 4 1788 %0 = bitcast i32* %a to float* 1789 store float* %0, float** %b, align 8 1790 %1 = load float** %b, align 8 1791 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), float* %1) 1792 ret void 1793 } 1794 1795 ; test15d: Addr-of a local cast to a ptr of a different type 1796 ; (e.g., int a; ... ; float *b = &a;) 1797 ; sspreq attribute 1798 ; Requires protector. 1799 define void @test15d() nounwind uwtable sspreq { 1800 entry: 1801 ; LINUX-I386-LABEL: test15d: 1802 ; LINUX-I386: mov{{l|q}} %gs: 1803 ; LINUX-I386: calll __stack_chk_fail 1804 1805 ; LINUX-X64-LABEL: test15d: 1806 ; LINUX-X64: mov{{l|q}} %fs: 1807 ; LINUX-X64: callq __stack_chk_fail 1808 1809 ; LINUX-KERNEL-X64-LABEL: test15d: 1810 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1811 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1812 1813 ; DARWIN-X64-LABEL: test15d: 1814 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1815 ; DARWIN-X64: callq ___stack_chk_fail 1816 %a = alloca i32, align 4 1817 %b = alloca float*, align 8 1818 store i32 0, i32* %a, align 4 1819 %0 = bitcast i32* %a to float* 1820 store float* %0, float** %b, align 8 1821 %1 = load float** %b, align 8 1822 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), float* %1) 1823 ret void 1824 } 1825 1826 ; test16a: Addr-of a local cast to a ptr of a different type (optimized) 1827 ; (e.g., int a; ... ; float *b = &a;) 1828 ; no ssp attribute 1829 ; Requires no protector. 1830 define void @test16a() nounwind uwtable { 1831 entry: 1832 ; LINUX-I386-LABEL: test16a: 1833 ; LINUX-I386-NOT: calll __stack_chk_fail 1834 ; LINUX-I386: .cfi_endproc 1835 1836 ; LINUX-X64-LABEL: test16a: 1837 ; LINUX-X64-NOT: callq __stack_chk_fail 1838 ; LINUX-X64: .cfi_endproc 1839 1840 ; LINUX-KERNEL-X64-LABEL: test16a: 1841 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1842 ; LINUX-KERNEL-X64: .cfi_endproc 1843 1844 ; DARWIN-X64-LABEL: test16a: 1845 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1846 ; DARWIN-X64: .cfi_endproc 1847 %a = alloca i32, align 4 1848 store i32 0, i32* %a, align 4 1849 %0 = bitcast i32* %a to float* 1850 call void @funfloat(float* %0) nounwind 1851 ret void 1852 } 1853 1854 ; test16b: Addr-of a local cast to a ptr of a different type (optimized) 1855 ; (e.g., int a; ... ; float *b = &a;) 1856 ; ssp attribute 1857 ; Requires no protector. 1858 define void @test16b() nounwind uwtable ssp { 1859 entry: 1860 ; LINUX-I386-LABEL: test16b: 1861 ; LINUX-I386-NOT: calll __stack_chk_fail 1862 ; LINUX-I386: .cfi_endproc 1863 1864 ; LINUX-X64-LABEL: test16b: 1865 ; LINUX-X64-NOT: callq __stack_chk_fail 1866 ; LINUX-X64: .cfi_endproc 1867 1868 ; LINUX-KERNEL-X64-LABEL: test16b: 1869 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1870 ; LINUX-KERNEL-X64: .cfi_endproc 1871 1872 ; DARWIN-X64-LABEL: test16b: 1873 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1874 ; DARWIN-X64: .cfi_endproc 1875 %a = alloca i32, align 4 1876 store i32 0, i32* %a, align 4 1877 %0 = bitcast i32* %a to float* 1878 call void @funfloat(float* %0) nounwind 1879 ret void 1880 } 1881 1882 ; test16c: Addr-of a local cast to a ptr of a different type (optimized) 1883 ; (e.g., int a; ... ; float *b = &a;) 1884 ; sspstrong attribute 1885 ; Requires protector. 1886 define void @test16c() nounwind uwtable sspstrong { 1887 entry: 1888 ; LINUX-I386-LABEL: test16c: 1889 ; LINUX-I386: mov{{l|q}} %gs: 1890 ; LINUX-I386: calll __stack_chk_fail 1891 1892 ; LINUX-X64-LABEL: test16c: 1893 ; LINUX-X64: mov{{l|q}} %fs: 1894 ; LINUX-X64: callq __stack_chk_fail 1895 1896 ; LINUX-KERNEL-X64-LABEL: test16c: 1897 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1898 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1899 1900 ; DARWIN-X64-LABEL: test16c: 1901 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1902 ; DARWIN-X64: callq ___stack_chk_fail 1903 %a = alloca i32, align 4 1904 store i32 0, i32* %a, align 4 1905 %0 = bitcast i32* %a to float* 1906 call void @funfloat(float* %0) nounwind 1907 ret void 1908 } 1909 1910 ; test16d: Addr-of a local cast to a ptr of a different type (optimized) 1911 ; (e.g., int a; ... ; float *b = &a;) 1912 ; sspreq attribute 1913 ; Requires protector. 1914 define void @test16d() nounwind uwtable sspreq { 1915 entry: 1916 ; LINUX-I386-LABEL: test16d: 1917 ; LINUX-I386: mov{{l|q}} %gs: 1918 ; LINUX-I386: calll __stack_chk_fail 1919 1920 ; LINUX-X64-LABEL: test16d: 1921 ; LINUX-X64: mov{{l|q}} %fs: 1922 ; LINUX-X64: callq __stack_chk_fail 1923 1924 ; LINUX-KERNEL-X64-LABEL: test16d: 1925 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 1926 ; LINUX-KERNEL-X64: callq __stack_chk_fail 1927 1928 ; DARWIN-X64-LABEL: test16d: 1929 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 1930 ; DARWIN-X64: callq ___stack_chk_fail 1931 %a = alloca i32, align 4 1932 store i32 0, i32* %a, align 4 1933 %0 = bitcast i32* %a to float* 1934 call void @funfloat(float* %0) nounwind 1935 ret void 1936 } 1937 1938 ; test17a: Addr-of a vector nested in a struct 1939 ; no ssp attribute 1940 ; Requires no protector. 1941 define void @test17a() nounwind uwtable { 1942 entry: 1943 ; LINUX-I386-LABEL: test17a: 1944 ; LINUX-I386-NOT: calll __stack_chk_fail 1945 ; LINUX-I386: .cfi_endproc 1946 1947 ; LINUX-X64-LABEL: test17a: 1948 ; LINUX-X64-NOT: callq __stack_chk_fail 1949 ; LINUX-X64: .cfi_endproc 1950 1951 ; LINUX-KERNEL-X64-LABEL: test17a: 1952 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1953 ; LINUX-KERNEL-X64: .cfi_endproc 1954 1955 ; DARWIN-X64-LABEL: test17a: 1956 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1957 ; DARWIN-X64: .cfi_endproc 1958 %c = alloca %struct.vec, align 16 1959 %y = getelementptr inbounds %struct.vec* %c, i64 0, i32 0 1960 %add.ptr = getelementptr inbounds <4 x i32>* %y, i64 -12 1961 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) nounwind 1962 ret void 1963 } 1964 1965 ; test17b: Addr-of a vector nested in a struct 1966 ; ssp attribute 1967 ; Requires no protector. 1968 define void @test17b() nounwind uwtable ssp { 1969 entry: 1970 ; LINUX-I386-LABEL: test17b: 1971 ; LINUX-I386-NOT: calll __stack_chk_fail 1972 ; LINUX-I386: .cfi_endproc 1973 1974 ; LINUX-X64-LABEL: test17b: 1975 ; LINUX-X64-NOT: callq __stack_chk_fail 1976 ; LINUX-X64: .cfi_endproc 1977 1978 ; LINUX-KERNEL-X64-LABEL: test17b: 1979 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 1980 ; LINUX-KERNEL-X64: .cfi_endproc 1981 1982 ; DARWIN-X64-LABEL: test17b: 1983 ; DARWIN-X64-NOT: callq ___stack_chk_fail 1984 ; DARWIN-X64: .cfi_endproc 1985 %c = alloca %struct.vec, align 16 1986 %y = getelementptr inbounds %struct.vec* %c, i64 0, i32 0 1987 %add.ptr = getelementptr inbounds <4 x i32>* %y, i64 -12 1988 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) nounwind 1989 ret void 1990 } 1991 1992 ; test17c: Addr-of a vector nested in a struct 1993 ; sspstrong attribute 1994 ; Requires protector. 1995 define void @test17c() nounwind uwtable sspstrong { 1996 entry: 1997 ; LINUX-I386-LABEL: test17c: 1998 ; LINUX-I386: mov{{l|q}} %gs: 1999 ; LINUX-I386: calll __stack_chk_fail 2000 2001 ; LINUX-X64-LABEL: test17c: 2002 ; LINUX-X64: mov{{l|q}} %fs: 2003 ; LINUX-X64: callq __stack_chk_fail 2004 2005 ; LINUX-KERNEL-X64-LABEL: test17c: 2006 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2007 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2008 2009 ; DARWIN-X64-LABEL: test17c: 2010 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2011 ; DARWIN-X64: callq ___stack_chk_fail 2012 %c = alloca %struct.vec, align 16 2013 %y = getelementptr inbounds %struct.vec* %c, i64 0, i32 0 2014 %add.ptr = getelementptr inbounds <4 x i32>* %y, i64 -12 2015 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) nounwind 2016 ret void 2017 } 2018 2019 ; test17d: Addr-of a vector nested in a struct 2020 ; sspreq attribute 2021 ; Requires protector. 2022 define void @test17d() nounwind uwtable sspreq { 2023 entry: 2024 ; LINUX-I386-LABEL: test17d: 2025 ; LINUX-I386: mov{{l|q}} %gs: 2026 ; LINUX-I386: calll __stack_chk_fail 2027 2028 ; LINUX-X64-LABEL: test17d: 2029 ; LINUX-X64: mov{{l|q}} %fs: 2030 ; LINUX-X64: callq __stack_chk_fail 2031 2032 ; LINUX-KERNEL-X64-LABEL: test17d: 2033 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2034 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2035 2036 ; DARWIN-X64-LABEL: test17d: 2037 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2038 ; DARWIN-X64: callq ___stack_chk_fail 2039 %c = alloca %struct.vec, align 16 2040 %y = getelementptr inbounds %struct.vec* %c, i64 0, i32 0 2041 %add.ptr = getelementptr inbounds <4 x i32>* %y, i64 -12 2042 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) nounwind 2043 ret void 2044 } 2045 2046 ; test18a: Addr-of a variable passed into an invoke instruction. 2047 ; no ssp attribute 2048 ; Requires no protector. 2049 define i32 @test18a() uwtable { 2050 entry: 2051 ; LINUX-I386-LABEL: test18a: 2052 ; LINUX-I386-NOT: calll __stack_chk_fail 2053 ; LINUX-I386: .cfi_endproc 2054 2055 ; LINUX-X64-LABEL: test18a: 2056 ; LINUX-X64-NOT: callq __stack_chk_fail 2057 ; LINUX-X64: .cfi_endproc 2058 2059 ; LINUX-KERNEL-X64-LABEL: test18a: 2060 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2061 ; LINUX-KERNEL-X64: .cfi_endproc 2062 2063 ; DARWIN-X64-LABEL: test18a: 2064 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2065 ; DARWIN-X64: .cfi_endproc 2066 %a = alloca i32, align 4 2067 %exn.slot = alloca i8* 2068 %ehselector.slot = alloca i32 2069 store i32 0, i32* %a, align 4 2070 invoke void @_Z3exceptPi(i32* %a) 2071 to label %invoke.cont unwind label %lpad 2072 2073 invoke.cont: 2074 ret i32 0 2075 2076 lpad: 2077 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2078 catch i8* null 2079 ret i32 0 2080 } 2081 2082 ; test18b: Addr-of a variable passed into an invoke instruction. 2083 ; ssp attribute 2084 ; Requires no protector. 2085 define i32 @test18b() uwtable ssp { 2086 entry: 2087 ; LINUX-I386-LABEL: test18b: 2088 ; LINUX-I386-NOT: calll __stack_chk_fail 2089 ; LINUX-I386: .cfi_endproc 2090 2091 ; LINUX-X64-LABEL: test18b: 2092 ; LINUX-X64-NOT: callq __stack_chk_fail 2093 ; LINUX-X64: .cfi_endproc 2094 2095 ; LINUX-KERNEL-X64-LABEL: test18b: 2096 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2097 ; LINUX-KERNEL-X64: .cfi_endproc 2098 2099 ; DARWIN-X64-LABEL: test18b: 2100 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2101 ; DARWIN-X64: .cfi_endproc 2102 %a = alloca i32, align 4 2103 %exn.slot = alloca i8* 2104 %ehselector.slot = alloca i32 2105 store i32 0, i32* %a, align 4 2106 invoke void @_Z3exceptPi(i32* %a) 2107 to label %invoke.cont unwind label %lpad 2108 2109 invoke.cont: 2110 ret i32 0 2111 2112 lpad: 2113 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2114 catch i8* null 2115 ret i32 0 2116 } 2117 2118 ; test18c: Addr-of a variable passed into an invoke instruction. 2119 ; sspstrong attribute 2120 ; Requires protector. 2121 define i32 @test18c() uwtable sspstrong { 2122 entry: 2123 ; LINUX-I386-LABEL: test18c: 2124 ; LINUX-I386: mov{{l|q}} %gs: 2125 ; LINUX-I386: calll __stack_chk_fail 2126 2127 ; LINUX-X64-LABEL: test18c: 2128 ; LINUX-X64: mov{{l|q}} %fs: 2129 ; LINUX-X64: callq __stack_chk_fail 2130 2131 ; LINUX-KERNEL-X64-LABEL: test18c: 2132 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2133 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2134 2135 ; DARWIN-X64-LABEL: test18c: 2136 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2137 ; DARWIN-X64: callq ___stack_chk_fail 2138 %a = alloca i32, align 4 2139 %exn.slot = alloca i8* 2140 %ehselector.slot = alloca i32 2141 store i32 0, i32* %a, align 4 2142 invoke void @_Z3exceptPi(i32* %a) 2143 to label %invoke.cont unwind label %lpad 2144 2145 invoke.cont: 2146 ret i32 0 2147 2148 lpad: 2149 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2150 catch i8* null 2151 ret i32 0 2152 } 2153 2154 ; test18d: Addr-of a variable passed into an invoke instruction. 2155 ; sspreq attribute 2156 ; Requires protector. 2157 define i32 @test18d() uwtable sspreq { 2158 entry: 2159 ; LINUX-I386-LABEL: test18d: 2160 ; LINUX-I386: mov{{l|q}} %gs: 2161 ; LINUX-I386: calll __stack_chk_fail 2162 2163 ; LINUX-X64-LABEL: test18d: 2164 ; LINUX-X64: mov{{l|q}} %fs: 2165 ; LINUX-X64: callq __stack_chk_fail 2166 2167 ; LINUX-KERNEL-X64-LABEL: test18d: 2168 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2169 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2170 2171 ; DARWIN-X64-LABEL: test18d: 2172 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2173 ; DARWIN-X64: callq ___stack_chk_fail 2174 %a = alloca i32, align 4 2175 %exn.slot = alloca i8* 2176 %ehselector.slot = alloca i32 2177 store i32 0, i32* %a, align 4 2178 invoke void @_Z3exceptPi(i32* %a) 2179 to label %invoke.cont unwind label %lpad 2180 2181 invoke.cont: 2182 ret i32 0 2183 2184 lpad: 2185 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2186 catch i8* null 2187 ret i32 0 2188 } 2189 2190 ; test19a: Addr-of a struct element passed into an invoke instruction. 2191 ; (GEP followed by an invoke) 2192 ; no ssp attribute 2193 ; Requires no protector. 2194 define i32 @test19a() uwtable { 2195 entry: 2196 ; LINUX-I386-LABEL: test19a: 2197 ; LINUX-I386-NOT: calll __stack_chk_fail 2198 ; LINUX-I386: .cfi_endproc 2199 2200 ; LINUX-X64-LABEL: test19a: 2201 ; LINUX-X64-NOT: callq __stack_chk_fail 2202 ; LINUX-X64: .cfi_endproc 2203 2204 ; LINUX-KERNEL-X64-LABEL: test19a: 2205 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2206 ; LINUX-KERNEL-X64: .cfi_endproc 2207 2208 ; DARWIN-X64-LABEL: test19a: 2209 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2210 ; DARWIN-X64: .cfi_endproc 2211 %c = alloca %struct.pair, align 4 2212 %exn.slot = alloca i8* 2213 %ehselector.slot = alloca i32 2214 %a = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2215 store i32 0, i32* %a, align 4 2216 %a1 = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2217 invoke void @_Z3exceptPi(i32* %a1) 2218 to label %invoke.cont unwind label %lpad 2219 2220 invoke.cont: 2221 ret i32 0 2222 2223 lpad: 2224 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2225 catch i8* null 2226 ret i32 0 2227 } 2228 2229 ; test19b: Addr-of a struct element passed into an invoke instruction. 2230 ; (GEP followed by an invoke) 2231 ; ssp attribute 2232 ; Requires no protector. 2233 define i32 @test19b() uwtable ssp { 2234 entry: 2235 ; LINUX-I386-LABEL: test19b: 2236 ; LINUX-I386-NOT: calll __stack_chk_fail 2237 ; LINUX-I386: .cfi_endproc 2238 2239 ; LINUX-X64-LABEL: test19b: 2240 ; LINUX-X64-NOT: callq __stack_chk_fail 2241 ; LINUX-X64: .cfi_endproc 2242 2243 ; LINUX-KERNEL-X64-LABEL: test19b: 2244 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2245 ; LINUX-KERNEL-X64: .cfi_endproc 2246 2247 ; DARWIN-X64-LABEL: test19b: 2248 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2249 ; DARWIN-X64: .cfi_endproc 2250 %c = alloca %struct.pair, align 4 2251 %exn.slot = alloca i8* 2252 %ehselector.slot = alloca i32 2253 %a = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2254 store i32 0, i32* %a, align 4 2255 %a1 = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2256 invoke void @_Z3exceptPi(i32* %a1) 2257 to label %invoke.cont unwind label %lpad 2258 2259 invoke.cont: 2260 ret i32 0 2261 2262 lpad: 2263 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2264 catch i8* null 2265 ret i32 0 2266 } 2267 2268 ; test19c: Addr-of a struct element passed into an invoke instruction. 2269 ; (GEP followed by an invoke) 2270 ; sspstrong attribute 2271 ; Requires protector. 2272 define i32 @test19c() uwtable sspstrong { 2273 entry: 2274 ; LINUX-I386-LABEL: test19c: 2275 ; LINUX-I386: mov{{l|q}} %gs: 2276 ; LINUX-I386: calll __stack_chk_fail 2277 2278 ; LINUX-X64-LABEL: test19c: 2279 ; LINUX-X64: mov{{l|q}} %fs: 2280 ; LINUX-X64: callq __stack_chk_fail 2281 2282 ; LINUX-KERNEL-X64-LABEL: test19c: 2283 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2284 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2285 2286 ; DARWIN-X64-LABEL: test19c: 2287 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2288 ; DARWIN-X64: callq ___stack_chk_fail 2289 %c = alloca %struct.pair, align 4 2290 %exn.slot = alloca i8* 2291 %ehselector.slot = alloca i32 2292 %a = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2293 store i32 0, i32* %a, align 4 2294 %a1 = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2295 invoke void @_Z3exceptPi(i32* %a1) 2296 to label %invoke.cont unwind label %lpad 2297 2298 invoke.cont: 2299 ret i32 0 2300 2301 lpad: 2302 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2303 catch i8* null 2304 ret i32 0 2305 } 2306 2307 ; test19d: Addr-of a struct element passed into an invoke instruction. 2308 ; (GEP followed by an invoke) 2309 ; sspreq attribute 2310 ; Requires protector. 2311 define i32 @test19d() uwtable sspreq { 2312 entry: 2313 ; LINUX-I386-LABEL: test19d: 2314 ; LINUX-I386: mov{{l|q}} %gs: 2315 ; LINUX-I386: calll __stack_chk_fail 2316 2317 ; LINUX-X64-LABEL: test19d: 2318 ; LINUX-X64: mov{{l|q}} %fs: 2319 ; LINUX-X64: callq __stack_chk_fail 2320 2321 ; LINUX-KERNEL-X64-LABEL: test19d: 2322 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2323 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2324 2325 ; DARWIN-X64-LABEL: test19d: 2326 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2327 ; DARWIN-X64: callq ___stack_chk_fail 2328 %c = alloca %struct.pair, align 4 2329 %exn.slot = alloca i8* 2330 %ehselector.slot = alloca i32 2331 %a = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2332 store i32 0, i32* %a, align 4 2333 %a1 = getelementptr inbounds %struct.pair* %c, i32 0, i32 0 2334 invoke void @_Z3exceptPi(i32* %a1) 2335 to label %invoke.cont unwind label %lpad 2336 2337 invoke.cont: 2338 ret i32 0 2339 2340 lpad: 2341 %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 2342 catch i8* null 2343 ret i32 0 2344 } 2345 2346 ; test20a: Addr-of a pointer 2347 ; no ssp attribute 2348 ; Requires no protector. 2349 define void @test20a() nounwind uwtable { 2350 entry: 2351 ; LINUX-I386-LABEL: test20a: 2352 ; LINUX-I386-NOT: calll __stack_chk_fail 2353 ; LINUX-I386: .cfi_endproc 2354 2355 ; LINUX-X64-LABEL: test20a: 2356 ; LINUX-X64-NOT: callq __stack_chk_fail 2357 ; LINUX-X64: .cfi_endproc 2358 2359 ; LINUX-KERNEL-X64-LABEL: test20a: 2360 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2361 ; LINUX-KERNEL-X64: .cfi_endproc 2362 2363 ; DARWIN-X64-LABEL: test20a: 2364 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2365 ; DARWIN-X64: .cfi_endproc 2366 %a = alloca i32*, align 8 2367 %b = alloca i32**, align 8 2368 %call = call i32* @getp() 2369 store i32* %call, i32** %a, align 8 2370 store i32** %a, i32*** %b, align 8 2371 %0 = load i32*** %b, align 8 2372 call void @funcall2(i32** %0) 2373 ret void 2374 } 2375 2376 ; test20b: Addr-of a pointer 2377 ; ssp attribute 2378 ; Requires no protector. 2379 define void @test20b() nounwind uwtable ssp { 2380 entry: 2381 ; LINUX-I386-LABEL: test20b: 2382 ; LINUX-I386-NOT: calll __stack_chk_fail 2383 ; LINUX-I386: .cfi_endproc 2384 2385 ; LINUX-X64-LABEL: test20b: 2386 ; LINUX-X64-NOT: callq __stack_chk_fail 2387 ; LINUX-X64: .cfi_endproc 2388 2389 ; LINUX-KERNEL-X64-LABEL: test20b: 2390 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2391 ; LINUX-KERNEL-X64: .cfi_endproc 2392 2393 ; DARWIN-X64-LABEL: test20b: 2394 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2395 ; DARWIN-X64: .cfi_endproc 2396 %a = alloca i32*, align 8 2397 %b = alloca i32**, align 8 2398 %call = call i32* @getp() 2399 store i32* %call, i32** %a, align 8 2400 store i32** %a, i32*** %b, align 8 2401 %0 = load i32*** %b, align 8 2402 call void @funcall2(i32** %0) 2403 ret void 2404 } 2405 2406 ; test20c: Addr-of a pointer 2407 ; sspstrong attribute 2408 ; Requires protector. 2409 define void @test20c() nounwind uwtable sspstrong { 2410 entry: 2411 ; LINUX-I386-LABEL: test20c: 2412 ; LINUX-I386: mov{{l|q}} %gs: 2413 ; LINUX-I386: calll __stack_chk_fail 2414 2415 ; LINUX-X64-LABEL: test20c: 2416 ; LINUX-X64: mov{{l|q}} %fs: 2417 ; LINUX-X64: callq __stack_chk_fail 2418 2419 ; LINUX-KERNEL-X64-LABEL: test20c: 2420 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2421 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2422 2423 ; DARWIN-X64-LABEL: test20c: 2424 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2425 ; DARWIN-X64: callq ___stack_chk_fail 2426 %a = alloca i32*, align 8 2427 %b = alloca i32**, align 8 2428 %call = call i32* @getp() 2429 store i32* %call, i32** %a, align 8 2430 store i32** %a, i32*** %b, align 8 2431 %0 = load i32*** %b, align 8 2432 call void @funcall2(i32** %0) 2433 ret void 2434 } 2435 2436 ; test20d: Addr-of a pointer 2437 ; sspreq attribute 2438 ; Requires protector. 2439 define void @test20d() nounwind uwtable sspreq { 2440 entry: 2441 ; LINUX-I386-LABEL: test20d: 2442 ; LINUX-I386: mov{{l|q}} %gs: 2443 ; LINUX-I386: calll __stack_chk_fail 2444 2445 ; LINUX-X64-LABEL: test20d: 2446 ; LINUX-X64: mov{{l|q}} %fs: 2447 ; LINUX-X64: callq __stack_chk_fail 2448 2449 ; LINUX-KERNEL-X64-LABEL: test20d: 2450 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2451 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2452 2453 ; DARWIN-X64-LABEL: test20d: 2454 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2455 ; DARWIN-X64: callq ___stack_chk_fail 2456 %a = alloca i32*, align 8 2457 %b = alloca i32**, align 8 2458 %call = call i32* @getp() 2459 store i32* %call, i32** %a, align 8 2460 store i32** %a, i32*** %b, align 8 2461 %0 = load i32*** %b, align 8 2462 call void @funcall2(i32** %0) 2463 ret void 2464 } 2465 2466 ; test21a: Addr-of a casted pointer 2467 ; no ssp attribute 2468 ; Requires no protector. 2469 define void @test21a() nounwind uwtable { 2470 entry: 2471 ; LINUX-I386-LABEL: test21a: 2472 ; LINUX-I386-NOT: calll __stack_chk_fail 2473 ; LINUX-I386: .cfi_endproc 2474 2475 ; LINUX-X64-LABEL: test21a: 2476 ; LINUX-X64-NOT: callq __stack_chk_fail 2477 ; LINUX-X64: .cfi_endproc 2478 2479 ; LINUX-KERNEL-X64-LABEL: test21a: 2480 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2481 ; LINUX-KERNEL-X64: .cfi_endproc 2482 2483 ; DARWIN-X64-LABEL: test21a: 2484 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2485 ; DARWIN-X64: .cfi_endproc 2486 %a = alloca i32*, align 8 2487 %b = alloca float**, align 8 2488 %call = call i32* @getp() 2489 store i32* %call, i32** %a, align 8 2490 %0 = bitcast i32** %a to float** 2491 store float** %0, float*** %b, align 8 2492 %1 = load float*** %b, align 8 2493 call void @funfloat2(float** %1) 2494 ret void 2495 } 2496 2497 ; test21b: Addr-of a casted pointer 2498 ; ssp attribute 2499 ; Requires no protector. 2500 define void @test21b() nounwind uwtable ssp { 2501 entry: 2502 ; LINUX-I386-LABEL: test21b: 2503 ; LINUX-I386-NOT: calll __stack_chk_fail 2504 ; LINUX-I386: .cfi_endproc 2505 2506 ; LINUX-X64-LABEL: test21b: 2507 ; LINUX-X64-NOT: callq __stack_chk_fail 2508 ; LINUX-X64: .cfi_endproc 2509 2510 ; LINUX-KERNEL-X64-LABEL: test21b: 2511 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2512 ; LINUX-KERNEL-X64: .cfi_endproc 2513 2514 ; DARWIN-X64-LABEL: test21b: 2515 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2516 ; DARWIN-X64: .cfi_endproc 2517 %a = alloca i32*, align 8 2518 %b = alloca float**, align 8 2519 %call = call i32* @getp() 2520 store i32* %call, i32** %a, align 8 2521 %0 = bitcast i32** %a to float** 2522 store float** %0, float*** %b, align 8 2523 %1 = load float*** %b, align 8 2524 call void @funfloat2(float** %1) 2525 ret void 2526 } 2527 2528 ; test21c: Addr-of a casted pointer 2529 ; sspstrong attribute 2530 ; Requires protector. 2531 define void @test21c() nounwind uwtable sspstrong { 2532 entry: 2533 ; LINUX-I386-LABEL: test21c: 2534 ; LINUX-I386: mov{{l|q}} %gs: 2535 ; LINUX-I386: calll __stack_chk_fail 2536 2537 ; LINUX-X64-LABEL: test21c: 2538 ; LINUX-X64: mov{{l|q}} %fs: 2539 ; LINUX-X64: callq __stack_chk_fail 2540 2541 ; LINUX-KERNEL-X64-LABEL: test21c: 2542 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2543 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2544 2545 ; DARWIN-X64-LABEL: test21c: 2546 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2547 ; DARWIN-X64: callq ___stack_chk_fail 2548 %a = alloca i32*, align 8 2549 %b = alloca float**, align 8 2550 %call = call i32* @getp() 2551 store i32* %call, i32** %a, align 8 2552 %0 = bitcast i32** %a to float** 2553 store float** %0, float*** %b, align 8 2554 %1 = load float*** %b, align 8 2555 call void @funfloat2(float** %1) 2556 ret void 2557 } 2558 2559 ; test21d: Addr-of a casted pointer 2560 ; sspreq attribute 2561 ; Requires protector. 2562 define void @test21d() nounwind uwtable sspreq { 2563 entry: 2564 ; LINUX-I386-LABEL: test21d: 2565 ; LINUX-I386: mov{{l|q}} %gs: 2566 ; LINUX-I386: calll __stack_chk_fail 2567 2568 ; LINUX-X64-LABEL: test21d: 2569 ; LINUX-X64: mov{{l|q}} %fs: 2570 ; LINUX-X64: callq __stack_chk_fail 2571 2572 ; LINUX-KERNEL-X64-LABEL: test21d: 2573 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2574 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2575 2576 ; DARWIN-X64-LABEL: test21d: 2577 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2578 ; DARWIN-X64: callq ___stack_chk_fail 2579 %a = alloca i32*, align 8 2580 %b = alloca float**, align 8 2581 %call = call i32* @getp() 2582 store i32* %call, i32** %a, align 8 2583 %0 = bitcast i32** %a to float** 2584 store float** %0, float*** %b, align 8 2585 %1 = load float*** %b, align 8 2586 call void @funfloat2(float** %1) 2587 ret void 2588 } 2589 2590 ; test22a: [2 x i8] in a class 2591 ; no ssp attribute 2592 ; Requires no protector. 2593 define signext i8 @test22a() nounwind uwtable { 2594 entry: 2595 ; LINUX-I386-LABEL: test22a: 2596 ; LINUX-I386-NOT: calll __stack_chk_fail 2597 ; LINUX-I386: .cfi_endproc 2598 2599 ; LINUX-X64-LABEL: test22a: 2600 ; LINUX-X64-NOT: callq __stack_chk_fail 2601 ; LINUX-X64: .cfi_endproc 2602 2603 ; LINUX-KERNEL-X64-LABEL: test22a: 2604 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2605 ; LINUX-KERNEL-X64: .cfi_endproc 2606 2607 ; DARWIN-X64-LABEL: test22a: 2608 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2609 ; DARWIN-X64: .cfi_endproc 2610 %a = alloca %class.A, align 1 2611 %array = getelementptr inbounds %class.A* %a, i32 0, i32 0 2612 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2613 %0 = load i8* %arrayidx, align 1 2614 ret i8 %0 2615 } 2616 2617 ; test22b: [2 x i8] in a class 2618 ; ssp attribute 2619 ; Requires no protector. 2620 define signext i8 @test22b() nounwind uwtable ssp { 2621 entry: 2622 ; LINUX-I386-LABEL: test22b: 2623 ; LINUX-I386-NOT: calll __stack_chk_fail 2624 ; LINUX-I386: .cfi_endproc 2625 2626 ; LINUX-X64-LABEL: test22b: 2627 ; LINUX-X64-NOT: callq __stack_chk_fail 2628 ; LINUX-X64: .cfi_endproc 2629 2630 ; LINUX-KERNEL-X64-LABEL: test22b: 2631 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2632 ; LINUX-KERNEL-X64: .cfi_endproc 2633 2634 ; DARWIN-X64-LABEL: test22b: 2635 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2636 ; DARWIN-X64: .cfi_endproc 2637 %a = alloca %class.A, align 1 2638 %array = getelementptr inbounds %class.A* %a, i32 0, i32 0 2639 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2640 %0 = load i8* %arrayidx, align 1 2641 ret i8 %0 2642 } 2643 2644 ; test22c: [2 x i8] in a class 2645 ; sspstrong attribute 2646 ; Requires protector. 2647 define signext i8 @test22c() nounwind uwtable sspstrong { 2648 entry: 2649 ; LINUX-I386-LABEL: test22c: 2650 ; LINUX-I386: mov{{l|q}} %gs: 2651 ; LINUX-I386: calll __stack_chk_fail 2652 2653 ; LINUX-X64-LABEL: test22c: 2654 ; LINUX-X64: mov{{l|q}} %fs: 2655 ; LINUX-X64: callq __stack_chk_fail 2656 2657 ; LINUX-KERNEL-X64-LABEL: test22c: 2658 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2659 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2660 2661 ; DARWIN-X64-LABEL: test22c: 2662 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2663 ; DARWIN-X64: callq ___stack_chk_fail 2664 %a = alloca %class.A, align 1 2665 %array = getelementptr inbounds %class.A* %a, i32 0, i32 0 2666 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2667 %0 = load i8* %arrayidx, align 1 2668 ret i8 %0 2669 } 2670 2671 ; test22d: [2 x i8] in a class 2672 ; sspreq attribute 2673 ; Requires protector. 2674 define signext i8 @test22d() nounwind uwtable sspreq { 2675 entry: 2676 ; LINUX-I386-LABEL: test22d: 2677 ; LINUX-I386: mov{{l|q}} %gs: 2678 ; LINUX-I386: calll __stack_chk_fail 2679 2680 ; LINUX-X64-LABEL: test22d: 2681 ; LINUX-X64: mov{{l|q}} %fs: 2682 ; LINUX-X64: callq __stack_chk_fail 2683 2684 ; LINUX-KERNEL-X64-LABEL: test22d: 2685 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2686 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2687 2688 ; DARWIN-X64-LABEL: test22d: 2689 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2690 ; DARWIN-X64: callq ___stack_chk_fail 2691 %a = alloca %class.A, align 1 2692 %array = getelementptr inbounds %class.A* %a, i32 0, i32 0 2693 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2694 %0 = load i8* %arrayidx, align 1 2695 ret i8 %0 2696 } 2697 2698 ; test23a: [2 x i8] nested in several layers of structs and unions 2699 ; no ssp attribute 2700 ; Requires no protector. 2701 define signext i8 @test23a() nounwind uwtable { 2702 entry: 2703 ; LINUX-I386-LABEL: test23a: 2704 ; LINUX-I386-NOT: calll __stack_chk_fail 2705 ; LINUX-I386: .cfi_endproc 2706 2707 ; LINUX-X64-LABEL: test23a: 2708 ; LINUX-X64-NOT: callq __stack_chk_fail 2709 ; LINUX-X64: .cfi_endproc 2710 2711 ; LINUX-KERNEL-X64-LABEL: test23a: 2712 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2713 ; LINUX-KERNEL-X64: .cfi_endproc 2714 2715 ; DARWIN-X64-LABEL: test23a: 2716 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2717 ; DARWIN-X64: .cfi_endproc 2718 %x = alloca %struct.deep, align 1 2719 %b = getelementptr inbounds %struct.deep* %x, i32 0, i32 0 2720 %c = bitcast %union.anon* %b to %struct.anon* 2721 %d = getelementptr inbounds %struct.anon* %c, i32 0, i32 0 2722 %e = getelementptr inbounds %struct.anon.0* %d, i32 0, i32 0 2723 %array = bitcast %union.anon.1* %e to [2 x i8]* 2724 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2725 %0 = load i8* %arrayidx, align 1 2726 ret i8 %0 2727 } 2728 2729 ; test23b: [2 x i8] nested in several layers of structs and unions 2730 ; ssp attribute 2731 ; Requires no protector. 2732 define signext i8 @test23b() nounwind uwtable ssp { 2733 entry: 2734 ; LINUX-I386-LABEL: test23b: 2735 ; LINUX-I386-NOT: calll __stack_chk_fail 2736 ; LINUX-I386: .cfi_endproc 2737 2738 ; LINUX-X64-LABEL: test23b: 2739 ; LINUX-X64-NOT: callq __stack_chk_fail 2740 ; LINUX-X64: .cfi_endproc 2741 2742 ; LINUX-KERNEL-X64-LABEL: test23b: 2743 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2744 ; LINUX-KERNEL-X64: .cfi_endproc 2745 2746 ; DARWIN-X64-LABEL: test23b: 2747 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2748 ; DARWIN-X64: .cfi_endproc 2749 %x = alloca %struct.deep, align 1 2750 %b = getelementptr inbounds %struct.deep* %x, i32 0, i32 0 2751 %c = bitcast %union.anon* %b to %struct.anon* 2752 %d = getelementptr inbounds %struct.anon* %c, i32 0, i32 0 2753 %e = getelementptr inbounds %struct.anon.0* %d, i32 0, i32 0 2754 %array = bitcast %union.anon.1* %e to [2 x i8]* 2755 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2756 %0 = load i8* %arrayidx, align 1 2757 ret i8 %0 2758 } 2759 2760 ; test23c: [2 x i8] nested in several layers of structs and unions 2761 ; sspstrong attribute 2762 ; Requires protector. 2763 define signext i8 @test23c() nounwind uwtable sspstrong { 2764 entry: 2765 ; LINUX-I386-LABEL: test23c: 2766 ; LINUX-I386: mov{{l|q}} %gs: 2767 ; LINUX-I386: calll __stack_chk_fail 2768 2769 ; LINUX-X64-LABEL: test23c: 2770 ; LINUX-X64: mov{{l|q}} %fs: 2771 ; LINUX-X64: callq __stack_chk_fail 2772 2773 ; LINUX-KERNEL-X64-LABEL: test23c: 2774 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2775 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2776 2777 ; DARWIN-X64-LABEL: test23c: 2778 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2779 ; DARWIN-X64: callq ___stack_chk_fail 2780 %x = alloca %struct.deep, align 1 2781 %b = getelementptr inbounds %struct.deep* %x, i32 0, i32 0 2782 %c = bitcast %union.anon* %b to %struct.anon* 2783 %d = getelementptr inbounds %struct.anon* %c, i32 0, i32 0 2784 %e = getelementptr inbounds %struct.anon.0* %d, i32 0, i32 0 2785 %array = bitcast %union.anon.1* %e to [2 x i8]* 2786 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2787 %0 = load i8* %arrayidx, align 1 2788 ret i8 %0 2789 } 2790 2791 ; test23d: [2 x i8] nested in several layers of structs and unions 2792 ; sspreq attribute 2793 ; Requires protector. 2794 define signext i8 @test23d() nounwind uwtable sspreq { 2795 entry: 2796 ; LINUX-I386-LABEL: test23d: 2797 ; LINUX-I386: mov{{l|q}} %gs: 2798 ; LINUX-I386: calll __stack_chk_fail 2799 2800 ; LINUX-X64-LABEL: test23d: 2801 ; LINUX-X64: mov{{l|q}} %fs: 2802 ; LINUX-X64: callq __stack_chk_fail 2803 2804 ; LINUX-KERNEL-X64-LABEL: test23d: 2805 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2806 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2807 2808 ; DARWIN-X64-LABEL: test23d: 2809 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2810 ; DARWIN-X64: callq ___stack_chk_fail 2811 %x = alloca %struct.deep, align 1 2812 %b = getelementptr inbounds %struct.deep* %x, i32 0, i32 0 2813 %c = bitcast %union.anon* %b to %struct.anon* 2814 %d = getelementptr inbounds %struct.anon* %c, i32 0, i32 0 2815 %e = getelementptr inbounds %struct.anon.0* %d, i32 0, i32 0 2816 %array = bitcast %union.anon.1* %e to [2 x i8]* 2817 %arrayidx = getelementptr inbounds [2 x i8]* %array, i32 0, i64 0 2818 %0 = load i8* %arrayidx, align 1 2819 ret i8 %0 2820 } 2821 2822 ; test24a: Variable sized alloca 2823 ; no ssp attribute 2824 ; Requires no protector. 2825 define void @test24a(i32 %n) nounwind uwtable { 2826 entry: 2827 ; LINUX-I386-LABEL: test24a: 2828 ; LINUX-I386-NOT: calll __stack_chk_fail 2829 ; LINUX-I386: .cfi_endproc 2830 2831 ; LINUX-X64-LABEL: test24a: 2832 ; LINUX-X64-NOT: callq __stack_chk_fail 2833 ; LINUX-X64: .cfi_endproc 2834 2835 ; LINUX-KERNEL-X64-LABEL: test24a: 2836 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2837 ; LINUX-KERNEL-X64: .cfi_endproc 2838 2839 ; DARWIN-X64-LABEL: test24a: 2840 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2841 ; DARWIN-X64: .cfi_endproc 2842 %n.addr = alloca i32, align 4 2843 %a = alloca i32*, align 8 2844 store i32 %n, i32* %n.addr, align 4 2845 %0 = load i32* %n.addr, align 4 2846 %conv = sext i32 %0 to i64 2847 %1 = alloca i8, i64 %conv 2848 %2 = bitcast i8* %1 to i32* 2849 store i32* %2, i32** %a, align 8 2850 ret void 2851 } 2852 2853 ; test24b: Variable sized alloca 2854 ; ssp attribute 2855 ; Requires protector. 2856 define void @test24b(i32 %n) nounwind uwtable ssp { 2857 entry: 2858 ; LINUX-I386-LABEL: test24b: 2859 ; LINUX-I386: mov{{l|q}} %gs: 2860 ; LINUX-I386: calll __stack_chk_fail 2861 2862 ; LINUX-X64-LABEL: test24b: 2863 ; LINUX-X64: mov{{l|q}} %fs: 2864 ; LINUX-X64: callq __stack_chk_fail 2865 2866 ; LINUX-KERNEL-X64-LABEL: test24b: 2867 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2868 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2869 2870 ; DARWIN-X64-LABEL: test24b: 2871 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2872 ; DARWIN-X64: callq ___stack_chk_fail 2873 %n.addr = alloca i32, align 4 2874 %a = alloca i32*, align 8 2875 store i32 %n, i32* %n.addr, align 4 2876 %0 = load i32* %n.addr, align 4 2877 %conv = sext i32 %0 to i64 2878 %1 = alloca i8, i64 %conv 2879 %2 = bitcast i8* %1 to i32* 2880 store i32* %2, i32** %a, align 8 2881 ret void 2882 } 2883 2884 ; test24c: Variable sized alloca 2885 ; sspstrong attribute 2886 ; Requires protector. 2887 define void @test24c(i32 %n) nounwind uwtable sspstrong { 2888 entry: 2889 ; LINUX-I386-LABEL: test24c: 2890 ; LINUX-I386: mov{{l|q}} %gs: 2891 ; LINUX-I386: calll __stack_chk_fail 2892 2893 ; LINUX-X64-LABEL: test24c: 2894 ; LINUX-X64: mov{{l|q}} %fs: 2895 ; LINUX-X64: callq __stack_chk_fail 2896 2897 ; LINUX-KERNEL-X64-LABEL: test24c: 2898 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2899 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2900 2901 ; DARWIN-X64-LABEL: test24c: 2902 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2903 ; DARWIN-X64: callq ___stack_chk_fail 2904 %n.addr = alloca i32, align 4 2905 %a = alloca i32*, align 8 2906 store i32 %n, i32* %n.addr, align 4 2907 %0 = load i32* %n.addr, align 4 2908 %conv = sext i32 %0 to i64 2909 %1 = alloca i8, i64 %conv 2910 %2 = bitcast i8* %1 to i32* 2911 store i32* %2, i32** %a, align 8 2912 ret void 2913 } 2914 2915 ; test24d: Variable sized alloca 2916 ; sspreq attribute 2917 ; Requires protector. 2918 define void @test24d(i32 %n) nounwind uwtable sspreq { 2919 entry: 2920 ; LINUX-I386-LABEL: test24d: 2921 ; LINUX-I386: mov{{l|q}} %gs: 2922 ; LINUX-I386: calll __stack_chk_fail 2923 2924 ; LINUX-X64-LABEL: test24d: 2925 ; LINUX-X64: mov{{l|q}} %fs: 2926 ; LINUX-X64: callq __stack_chk_fail 2927 2928 ; LINUX-KERNEL-X64-LABEL: test24d: 2929 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 2930 ; LINUX-KERNEL-X64: callq __stack_chk_fail 2931 2932 ; DARWIN-X64-LABEL: test24d: 2933 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2934 ; DARWIN-X64: callq ___stack_chk_fail 2935 %n.addr = alloca i32, align 4 2936 %a = alloca i32*, align 8 2937 store i32 %n, i32* %n.addr, align 4 2938 %0 = load i32* %n.addr, align 4 2939 %conv = sext i32 %0 to i64 2940 %1 = alloca i8, i64 %conv 2941 %2 = bitcast i8* %1 to i32* 2942 store i32* %2, i32** %a, align 8 2943 ret void 2944 } 2945 2946 ; test25a: array of [4 x i32] 2947 ; no ssp attribute 2948 ; Requires no protector. 2949 define i32 @test25a() nounwind uwtable { 2950 entry: 2951 ; LINUX-I386-LABEL: test25a: 2952 ; LINUX-I386-NOT: calll __stack_chk_fail 2953 ; LINUX-I386: .cfi_endproc 2954 2955 ; LINUX-X64-LABEL: test25a: 2956 ; LINUX-X64-NOT: callq __stack_chk_fail 2957 ; LINUX-X64: .cfi_endproc 2958 2959 ; LINUX-KERNEL-X64-LABEL: test25a: 2960 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2961 ; LINUX-KERNEL-X64: .cfi_endproc 2962 2963 ; DARWIN-X64-LABEL: test25a: 2964 ; DARWIN-X64-NOT: callq ___stack_chk_fail 2965 ; DARWIN-X64: .cfi_endproc 2966 %a = alloca [4 x i32], align 16 2967 %arrayidx = getelementptr inbounds [4 x i32]* %a, i32 0, i64 0 2968 %0 = load i32* %arrayidx, align 4 2969 ret i32 %0 2970 } 2971 2972 ; test25b: array of [4 x i32] 2973 ; ssp attribute 2974 ; Requires no protector, except for Darwin which _does_ require a protector. 2975 define i32 @test25b() nounwind uwtable ssp { 2976 entry: 2977 ; LINUX-I386-LABEL: test25b: 2978 ; LINUX-I386-NOT: calll __stack_chk_fail 2979 ; LINUX-I386: .cfi_endproc 2980 2981 ; LINUX-X64-LABEL: test25b: 2982 ; LINUX-X64-NOT: callq __stack_chk_fail 2983 ; LINUX-X64: .cfi_endproc 2984 2985 ; LINUX-KERNEL-X64-LABEL: test25b: 2986 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 2987 ; LINUX-KERNEL-X64: .cfi_endproc 2988 2989 ; DARWIN-X64-LABEL: test25b: 2990 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 2991 ; DARWIN-X64: callq ___stack_chk_fail 2992 %a = alloca [4 x i32], align 16 2993 %arrayidx = getelementptr inbounds [4 x i32]* %a, i32 0, i64 0 2994 %0 = load i32* %arrayidx, align 4 2995 ret i32 %0 2996 } 2997 2998 ; test25c: array of [4 x i32] 2999 ; sspstrong attribute 3000 ; Requires protector. 3001 define i32 @test25c() nounwind uwtable sspstrong { 3002 entry: 3003 ; LINUX-I386-LABEL: test25c: 3004 ; LINUX-I386: mov{{l|q}} %gs: 3005 ; LINUX-I386: calll __stack_chk_fail 3006 3007 ; LINUX-X64-LABEL: test25c: 3008 ; LINUX-X64: mov{{l|q}} %fs: 3009 ; LINUX-X64: callq __stack_chk_fail 3010 3011 ; LINUX-KERNEL-X64-LABEL: test25c: 3012 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3013 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3014 3015 ; DARWIN-X64-LABEL: test25c: 3016 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3017 ; DARWIN-X64: callq ___stack_chk_fail 3018 %a = alloca [4 x i32], align 16 3019 %arrayidx = getelementptr inbounds [4 x i32]* %a, i32 0, i64 0 3020 %0 = load i32* %arrayidx, align 4 3021 ret i32 %0 3022 } 3023 3024 ; test25d: array of [4 x i32] 3025 ; sspreq attribute 3026 ; Requires protector. 3027 define i32 @test25d() nounwind uwtable sspreq { 3028 entry: 3029 ; LINUX-I386-LABEL: test25d: 3030 ; LINUX-I386: mov{{l|q}} %gs: 3031 ; LINUX-I386: calll __stack_chk_fail 3032 3033 ; LINUX-X64-LABEL: test25d: 3034 ; LINUX-X64: mov{{l|q}} %fs: 3035 ; LINUX-X64: callq __stack_chk_fail 3036 3037 ; LINUX-KERNEL-X64-LABEL: test25d: 3038 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3039 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3040 3041 ; DARWIN-X64-LABEL: test25d: 3042 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3043 ; DARWIN-X64: callq ___stack_chk_fail 3044 %a = alloca [4 x i32], align 16 3045 %arrayidx = getelementptr inbounds [4 x i32]* %a, i32 0, i64 0 3046 %0 = load i32* %arrayidx, align 4 3047 ret i32 %0 3048 } 3049 3050 ; test26: Nested structure, no arrays, no address-of expressions. 3051 ; Verify that the resulting gep-of-gep does not incorrectly trigger 3052 ; a stack protector. 3053 ; ssptrong attribute 3054 ; Requires no protector. 3055 define void @test26() nounwind uwtable sspstrong { 3056 entry: 3057 ; LINUX-I386-LABEL: test26: 3058 ; LINUX-I386-NOT: calll __stack_chk_fail 3059 ; LINUX-I386: .cfi_endproc 3060 3061 ; LINUX-X64-LABEL: test26: 3062 ; LINUX-X64-NOT: callq __stack_chk_fail 3063 ; LINUX-X64: .cfi_endproc 3064 3065 ; LINUX-KERNEL-X64-LABEL: test26: 3066 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail 3067 ; LINUX-KERNEL-X64: .cfi_endproc 3068 3069 ; DARWIN-X64-LABEL: test26: 3070 ; DARWIN-X64-NOT: callq ___stack_chk_fail 3071 ; DARWIN-X64: .cfi_endproc 3072 %c = alloca %struct.nest, align 4 3073 %b = getelementptr inbounds %struct.nest* %c, i32 0, i32 1 3074 %_a = getelementptr inbounds %struct.pair* %b, i32 0, i32 0 3075 %0 = load i32* %_a, align 4 3076 %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), i32 %0) 3077 ret void 3078 } 3079 3080 ; test27: Address-of a structure taken in a function with a loop where 3081 ; the alloca is an incoming value to a PHI node and a use of that PHI 3082 ; node is also an incoming value. 3083 ; Verify that the address-of analysis does not get stuck in infinite 3084 ; recursion when chasing the alloca through the PHI nodes. 3085 ; Requires protector. 3086 define i32 @test27(i32 %arg) nounwind uwtable sspstrong { 3087 bb: 3088 ; LINUX-I386-LABEL: test27: 3089 ; LINUX-I386: mov{{l|q}} %gs: 3090 ; LINUX-I386: calll __stack_chk_fail 3091 3092 ; LINUX-X64-LABEL: test27: 3093 ; LINUX-X64: mov{{l|q}} %fs: 3094 ; LINUX-X64: callq __stack_chk_fail 3095 3096 ; LINUX-KERNEL-X64-LABEL: test27: 3097 ; LINUX-KERNEL-X64: mov{{l|q}} %gs: 3098 ; LINUX-KERNEL-X64: callq __stack_chk_fail 3099 3100 ; DARWIN-X64-LABEL: test27: 3101 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard 3102 ; DARWIN-X64: callq ___stack_chk_fail 3103 %tmp = alloca %struct.small*, align 8 3104 %tmp1 = call i32 (...)* @dummy(%struct.small** %tmp) nounwind 3105 %tmp2 = load %struct.small** %tmp, align 8 3106 %tmp3 = ptrtoint %struct.small* %tmp2 to i64 3107 %tmp4 = trunc i64 %tmp3 to i32 3108 %tmp5 = icmp sgt i32 %tmp4, 0 3109 br i1 %tmp5, label %bb6, label %bb21 3110 3111 bb6: ; preds = %bb17, %bb 3112 %tmp7 = phi %struct.small* [ %tmp19, %bb17 ], [ %tmp2, %bb ] 3113 %tmp8 = phi i64 [ %tmp20, %bb17 ], [ 1, %bb ] 3114 %tmp9 = phi i32 [ %tmp14, %bb17 ], [ %tmp1, %bb ] 3115 %tmp10 = getelementptr inbounds %struct.small* %tmp7, i64 0, i32 0 3116 %tmp11 = load i8* %tmp10, align 1 3117 %tmp12 = icmp eq i8 %tmp11, 1 3118 %tmp13 = add nsw i32 %tmp9, 8 3119 %tmp14 = select i1 %tmp12, i32 %tmp13, i32 %tmp9 3120 %tmp15 = trunc i64 %tmp8 to i32 3121 %tmp16 = icmp eq i32 %tmp15, %tmp4 3122 br i1 %tmp16, label %bb21, label %bb17 3123 3124 bb17: ; preds = %bb6 3125 %tmp18 = getelementptr inbounds %struct.small** %tmp, i64 %tmp8 3126 %tmp19 = load %struct.small** %tmp18, align 8 3127 %tmp20 = add i64 %tmp8, 1 3128 br label %bb6 3129 3130 bb21: ; preds = %bb6, %bb 3131 %tmp22 = phi i32 [ %tmp1, %bb ], [ %tmp14, %bb6 ] 3132 %tmp23 = call i32 (...)* @dummy(i32 %tmp22) nounwind 3133 ret i32 undef 3134 } 3135 3136 declare double @testi_aux() 3137 declare i8* @strcpy(i8*, i8*) 3138 declare i32 @printf(i8*, ...) 3139 declare void @funcall(i32*) 3140 declare void @funcall2(i32**) 3141 declare void @funfloat(float*) 3142 declare void @funfloat2(float**) 3143 declare void @_Z3exceptPi(i32*) 3144 declare i32 @__gxx_personality_v0(...) 3145 declare i32* @getp() 3146 declare i32 @dummy(...) 3147
