test/CodeGen/X86/stack-protector.ll

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