Don't assume mingw is providing SSP functions

[vchuravy]

Summary

Mingw is indirectly targeting msvcrt*.dll and we can't guarantee that
these functions will be available during JIT'ing.

[vchuravy]

The Julia project is currently evaluating updating LLVM from 3.7 to 3.9 and we are working on making sure that it will continue to work on all supported platforms.
We currently support Windows through Mingw and encountered LLVM ERROR: Program used external function '__atomic_store' which could not be resolved! in JIT'ed code.
So far we did not need MSVCRT as a runtime library with Mingw, greatly simplifying deployment.

An alternative might be to change the meaning of isOSMSVCRT to not include MinGW, I at least find the following code and comment confusing:

else if (!Is64Bit && !canGuaranteeTCO(CallConv) &&
         !Subtarget.getTargetTriple().isOSMSVCRT() &&
         SR == StackStructReturn)
  // If this is a call to a struct-return function, the callee
  // pops the hidden struct pointer, so we have to push it back.
  // This is common for Darwin/X86, Linux & Mingw32 targets.
  // For MSVC Win32 targets, the caller pops the hidden struct pointer.

---
 include/llvm/ADT/Triple.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/llvm/ADT/Triple.h b/include/llvm/ADT/Triple.h
index b98f840..102b59b 100644
--- a/include/llvm/ADT/Triple.h
+++ b/include/llvm/ADT/Triple.h
@@ -517,8 +517,7 @@ public:
 
   /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
   bool isOSMSVCRT() const {
-    return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
-           isWindowsItaniumEnvironment();
+    return isWindowsMSVCEnvironment() || isWindowsItaniumEnvironment();
   }
 
   /// Tests whether the OS is Windows.
-- 
2.10.2

[vchuravy]

I should also note the mingw64 provides "libssp" so the MSVCRT functions are not needed on this target.

[vchuravy]

In the progress of updating the Julia frontend to LLVM 6.0.0 I encountered this issue again.
Julia is using mingw for our windows support and as far as I understand mingw doesn't provide __security_cookie and __security_check_cookie
as part of the runtime (https://sourceforge.net/p/mingw-w64/mailman/message/27235169/). I suspect partly due to the fact that the version of
msvcrt.dll that mingw only has the symbols in an external static library (bufferoverflowU.lib). On the other hand mingw does provide libssp.

Since Julia is currently carrying this patch I would welcome a discussion if this is the right approach or what we should be doing differently.

[vchuravy]

Rebase onto master

[mstorsjo]

Isn't this only an issue if you actually enable it (via -fstack-protector-strong to clang, or something similar in parameters to llvm codegen)?

This change in itself is right though, since we shouldn't be using those MSVC specific if targeting mingw.

But if I try building code with clang with this patch in place with -fstack-protector-strong, I get an assertion failure ("Assertion failed: (InChain.getValueType() == MVT::Other && "Not a chain"), function HandleMergeInputChains, file ../lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp, line 2557.") while I previously got a successful compile (but referencing the MSVC specific symbols). So I'm not sure exactly what and how this patch fixes.

So IMO the patch looks something in the right direction, but it doesn't seem to be complete to me. It at least needs a test case and showing what it fixes, and the assertion failure I quoted needs to be sorted out in one way or another.

[vchuravy]

@mstorsjo Thanks for your feedback. Might I ask how you tested this? Did you simply compiled clang as well and run the testsuite?

Yes this should only be an issue when StackProtectStrong is set on functions, which Julia does in certain build configurations (we could also not do that on Windows, but I would rather fix the issue upstream)

[mstorsjo]

In D27296#1041079, @vchuravy wrote:

@mstorsjo Thanks for your feedback. Might I ask how you tested this? Did you simply compiled clang as well and run the testsuite?

I tested compiling a minimal trivial C file with clang:

$ cat ssp.c
void other(void* ptr);
void func(void) {
	char c;
	other(&c);
}
$ clang -target x86_64-w64-mingw32 -S -o - ssp.c -O2 -fstack-protector-strong

It can also easily be reproduced with plain IR and llc:

$ cat ssp.ll
define dso_local void @func() sspstrong {
entry:
  %c = alloca i8, align 1
  call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %c) 
  call void @other(i8* nonnull %c) 
  call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %c) 
  ret void
}
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) 
declare dso_local void @other(i8*) 
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) 
$ llc -mtriple x86_64-w64-mingw32 ssp.ll

Yes this should only be an issue when StackProtectStrong is set on functions, which Julia does in certain build configurations (we could also not do that on Windows, but I would rather fix the issue upstream)

Ok, well if you are setting this you will need to have GCC's libssp available for linking as well (I presume you have that and that's what you intend?), since the example above should produce references to __stack_chk_guard and __stack_chk_fail if it didn't error out during compilation.

[vchuravy]

Start adding test for ssp and sspstrong for mingw32

[vchuravy]

rebase

[vchuravy]

Hm I can't reproduce the failure you are seeing. I added your example as a test case and started extending the tests in Codegen/X86/stack-protector.ll to also cover mingw (there still lots of cases to go there).

[mstorsjo]

In D27296#1042387, @vchuravy wrote:

Hm I can't reproduce the failure you are seeing.

Sorry about that - I tested it with a build tree that was a couple weeks old. For some reason I got that failure there, but it does indeed seem to work with the latest trunk version. No idea what changed inbetween.

I added your example as a test case and started extending the tests in Codegen/X86/stack-protector.ll to also cover mingw (there still lots of cases to go there).

Thanks, this looks great!

Do you have commit access, or do you want me to commit it for you?

[mstorsjo]

One small detail actually; you might want to check for isWindowsItaniumEnvironment() as well, since afaik that environment is supposed to link to MSVC libraries. So either Subtarget.getTargetTriple().isWindowsMSVCEnvironment() || Subtarget.getTargetTriple().isWindowsItaniumEnvironment() or Subtarget.getTargetTriple().isOSMSVCRT() && !Subtarget.getTargetTriple().isWindowsGNUEnvironment().

[vchuravy]

In D27296#1042876, @mstorsjo wrote:

Sorry about that - I tested it with a build tree that was a couple weeks old. For some reason I got that failure there, but it does indeed seem to work with the latest trunk version. No idea what changed inbetween.

No worries!

Do you have commit access, or do you want me to commit it for you?

I don't have commit access so it would be great if you could land this.

You are right about Itanium. I will switch to not isWindowsGNUEnvironment() for the test and add a minimal test case for IA64.

[mstorsjo]

In D27296#1043227, @vchuravy wrote:

You are right about Itanium. I will switch to not isWindowsGNUEnvironment() for the test and add a minimal test case for IA64.

isWindowsItaniumEnvironment() isn't about IA64, but about the itanium C++ ABI (the one used on all other platforms), contrary to the MSVC C++ ABI. So the windows Itanium environment is like MSVC except that it uses a C++ ABI similar to what mingw and other platforms uses.

[vchuravy]

• update for windows-itanium and add tests

[vchuravy]

Is the x86_64-pc-windows-itanium the right platform triple?

I adapted the test to check that windows-itanium and windows-msvc both behave like msvc.

[mstorsjo]

LGTM. Do @compnerd or @smeenai have anything to add, or shall I commit it?

[smeenai]

Seems fine to me, since windows-itanium is unaffected.

llvm/trunk/lib/Target/X86/X86ISelLowering.cpp

if (hasStackGuardSlotTLS(Subtarget.getTargetTriple())) {
     }
   }
 
   return TargetLowering::getIRStackGuard(IRB);
 }
 
 void X86TargetLowering::insertSSPDeclarations(Module &M) const {
   // MSVC CRT provides functionalities for stack protection.
-  if (Subtarget.getTargetTriple().isOSMSVCRT()) {
+  if (Subtarget.getTargetTriple().isWindowsMSVCEnvironment() ||
+      Subtarget.getTargetTriple().isWindowsItaniumEnvironment()) {
     // MSVC CRT has a global variable holding security cookie.
     M.getOrInsertGlobal("__security_cookie",
                         Type::getInt8PtrTy(M.getContext()));
 
     // MSVC CRT has a function to validate security cookie.
     auto *SecurityCheckCookie = cast<Function>(
         M.getOrInsertFunction("__security_check_cookie",
                               Type::getVoidTy(M.getContext()),
                               Type::getInt8PtrTy(M.getContext())));
     SecurityCheckCookie->setCallingConv(CallingConv::X86_FastCall);
     SecurityCheckCookie->addAttribute(1, Attribute::AttrKind::InReg);
     return;
   }
   // glibc, bionic, and Fuchsia have a special slot for the stack guard.
   if (hasStackGuardSlotTLS(Subtarget.getTargetTriple()))
     return;
   TargetLowering::insertSSPDeclarations(M);
 }
 
 Value *X86TargetLowering::getSDagStackGuard(const Module &M) const {
   // MSVC CRT has a global variable holding security cookie.
-  if (Subtarget.getTargetTriple().isOSMSVCRT())
+  if (Subtarget.getTargetTriple().isWindowsMSVCEnvironment() ||
+      Subtarget.getTargetTriple().isWindowsItaniumEnvironment()) {
     return M.getGlobalVariable("__security_cookie");
+  }
   return TargetLowering::getSDagStackGuard(M);
 }
 
 Value *X86TargetLowering::getSSPStackGuardCheck(const Module &M) const {
   // MSVC CRT has a function to validate security cookie.
-  if (Subtarget.getTargetTriple().isOSMSVCRT())
+  if (Subtarget.getTargetTriple().isWindowsMSVCEnvironment() ||
+      Subtarget.getTargetTriple().isWindowsItaniumEnvironment()) {
     return M.getFunction("__security_check_cookie");
+  }
   return TargetLowering::getSSPStackGuardCheck(M);
 }
 
 Value *X86TargetLowering::getSafeStackPointerLocation(IRBuilder<> &IRB) const {
   if (Subtarget.getTargetTriple().isOSContiki())
     return getDefaultSafeStackPointerLocation(IRB, false);
 
   // Android provides a fixed TLS slot for the SafeStack pointer. See the

llvm/trunk/test/CodeGen/X86/stack-protector.ll

 ; RUN: llc -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-I386 %s
 ; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-X64 %s
 ; RUN: llc -code-model=kernel -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefix=LINUX-KERNEL-X64 %s
 ; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | FileCheck --check-prefix=DARWIN-X64 %s
 ; RUN: llc -mtriple=amd64-pc-openbsd < %s -o - | FileCheck --check-prefix=OPENBSD-AMD64 %s
 ; RUN: llc -mtriple=i386-pc-windows-msvc < %s -o - | FileCheck -check-prefix=MSVC-I386 %s
+; RUN: llc -mtriple=x86_64-w64-mingw32 < %s -o - | FileCheck --check-prefix=MINGW-X64 %s
 
 %struct.foo = type { [16 x i8] }
 %struct.foo.0 = type { [4 x i8] }
 %struct.pair = type { i32, i32 }
 %struct.nest = type { %struct.pair, %struct.pair }
 %struct.vec = type { <4 x i32> }
 %class.A = type { [2 x i8] }
 %struct.deep = type { %union.anon }

 
 ; DARWIN-X64-LABEL: test1a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test1a:
 ; MSVC-I386-NOT: calll  @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test1a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; OPENBSD-AMD64-LABEL: test1b:
 ; OPENBSD-AMD64: movq __guard_local(%rip)
 ; OPENBSD-AMD64: callq __stack_smash_handler
 
 ; MSVC-I386-LABEL: test1b:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test1b:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test1c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test1c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test1c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test1d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test1d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test1d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test2a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test2a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test2a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0

 
 ; LINUX-KERNEL-X64-LABEL: test2b:
 ; LINUX-KERNEL-X64: mov{{l|q}} %gs:
 ; LINUX-KERNEL-X64: callq __stack_chk_fail
 
 ; DARWIN-X64-LABEL: test2b:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
+
+; MINGW-X64-LABEL: test2b:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test2c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test2c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test2c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test2d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test2d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test2d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test3a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test3a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test3a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test3b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test3b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test3b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test3c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test3c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test3c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test3d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test3d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test3d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %arraydecay1 = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)

 
 ; DARWIN-X64-LABEL: test4a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test4a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test4a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test4b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test4b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test4b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test4c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test4c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test4c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test4d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test4d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test4d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
   %buf1 = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0

 
 ; DARWIN-X64-LABEL: test5a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test5a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test5a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }
 
 ; test5b:  no arrays / no nested arrays

 
 ; DARWIN-X64-LABEL: test5b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test5b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test5b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }
 
 ; test5c:  no arrays / no nested arrays

 
 ; DARWIN-X64-LABEL: test5c:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test5c:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test5c:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }
 
 ; test5d:  no arrays / no nested arrays

 
 ; DARWIN-X64-LABEL: test5d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test5d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test5d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }
 
 ; test6a:  Address-of local taken (j = &a)

 
 ; DARWIN-X64-LABEL: test6a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test6a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test6a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1
   store i32 %add, i32* %a, align 4
   store i32* %a, i32** %j, align 8

 ; LINUX-KERNEL-X64-LABEL: test6b:
 ; LINUX-KERNEL-X64-NOT: callq __stack_chk_fail
 ; LINUX-KERNEL-X64: .cfi_endproc
 
 ; DARWIN-X64-LABEL: test6b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
-
 ; MSVC-I386-LABEL: test6b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test6b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1
   store i32 %add, i32* %a, align 4
   store i32* %a, i32** %j, align 8

 
 ; DARWIN-X64-LABEL: test6c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test6c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test6c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1
   store i32 %add, i32* %a, align 4
   store i32* %a, i32** %j, align 8

 
 ; DARWIN-X64-LABEL: test6d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test6d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test6d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1
   store i32 %add, i32* %a, align 4
   store i32* %a, i32** %j, align 8

 
 ; DARWIN-X64-LABEL: test7a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test7a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test7a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 
 ; test7b:  PtrToInt Cast
 ;          ssp attribute

 
 ; DARWIN-X64-LABEL: test7b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test7b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test7b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 
 ; test7c:  PtrToInt Cast
 ;          sspstrong attribute

 
 ; DARWIN-X64-LABEL: test7c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test7c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test7c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: .seh_endproc
+
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 
 ; test7d:  PtrToInt Cast
 ;          sspreq attribute

 
 ; DARWIN-X64-LABEL: test7d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test7d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test7d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 
 ; test8a:  Passing addr-of to function call
 ;          no ssp attribute

 
 ; DARWIN-X64-LABEL: test8a:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test8a:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test8a:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test8b:  Passing addr-of to function call
 ;          ssp attribute
 ; Requires no protector.

 
 ; DARWIN-X64-LABEL: test8b:
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 ; DARWIN-X64: .cfi_endproc
 
 ; MSVC-I386-LABEL: test8b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test8b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test8c:  Passing addr-of to function call
 ;          sspstrong attribute
 ; Requires protector.

 
 ; DARWIN-X64-LABEL: test8c:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test8c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test8c:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test8d:  Passing addr-of to function call
 ;          sspreq attribute
 ; Requires protector.

 
 ; DARWIN-X64-LABEL: test8d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test8d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test8d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test9a:  Addr-of in select instruction
 ;          no ssp attribute
 ; Requires no protector.

 ; DARWIN-X64-LABEL: test19d:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test19d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
+
+; MINGW-X64-LABEL: test19d:
+; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: callq __stack_chk_fail
+
   %c = alloca %struct.pair, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   store i32 0, i32* %a, align 4
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad

 
 ; DARWIN-X64-LABEL: test25b:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test25b:
 ; MSVC-I386-NOT: calll @__security_check_cookie@4
 ; MSVC-I386: retl
+
+; MINGW-X64-LABEL: test25b:
+; MINGW-X64-NOT: callq __stack_chk_fail
+; MINGW-X64: .seh_endproc
+
   %a = alloca [4 x i32], align 16
   %arrayidx = getelementptr inbounds [4 x i32], [4 x i32]* %a, i32 0, i64 0
   %0 = load i32, i32* %arrayidx, align 4
   ret i32 %0
 }
 
 ; test25c: array of [4 x i32]
 ;          sspstrong attribute

llvm/trunk/test/CodeGen/X86/win32-ssp.ll

+; RUN: llc -mtriple=x86_64-w64-mingw32        < %s -o - | FileCheck --check-prefix=MINGW %s
+; RUN: llc -mtriple=x86_64-pc-windows-itanium < %s -o - | FileCheck --check-prefix=MSVC  %s
+; RUN: llc -mtriple=x86_64-pc-windows-msvc    < %s -o - | FileCheck --check-prefix=MSVC  %s
+
+declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
+declare dso_local void @other(i8*)
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+
+define dso_local void @func() sspstrong {
+entry:
+; MINGW-LABEL: func:
+; MINGW: mov{{l|q}}  __stack_chk_guard
+; MINGW: callq other
+; MINGW: mov{{l|q}}  __stack_chk_guard
+; MINGW: callq __stack_chk_fail
+; MINGW: .seh_endproc
+
+; MSVC-LABEL: func:
+; MSVC: mov{{l|q}} __security_cookie
+; MSVC: callq other
+; MSVC: callq __security_check_cookie
+; MSVC: .seh_endproc
+
+  %c = alloca i8, align 1
+  call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %c)
+  call void @other(i8* nonnull %c)
+  call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %c)
+  ret void
+}