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