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