[SafeStack] Use proper API to get stack guard

[pzheng]

Summary

Using the proper API automatically sets __stack_chk_guard to dso_local if
Reloc::Static. This wasn't strictly necessary until recently when dso_local was
no longer implied by TargetMachine::shouldAssumeDSOLocal for
__stack_chk_guard. By using the proper API, we can avoid generating unnecessary
GOT relocations.

[lebedev.ri]

This looks reasonable to me, but i'm not familiar with that pass.

[pzheng]

Any more comments? I'll probably wait a few more days before committing the change in case anyone hasn't got a chance to review.

llvm/lib/CodeGen/SafeStack.cpp

bool SafeStack::IsSafeStackAlloca(const Value *AllocaPtr, uint64_t AllocaSize) {
   }
 
   // All uses of the alloca are safe, we can place it on the safe stack.
   return true;
 }
 
 Value *SafeStack::getStackGuard(IRBuilder<> &IRB, Function &F) {
   Value *StackGuardVar = TL.getIRStackGuard(IRB);
-  if (!StackGuardVar)
-    StackGuardVar =
-        F.getParent()->getOrInsertGlobal("__stack_chk_guard", StackPtrTy);
+  Module *M = F.getParent();
+
+  if (!StackGuardVar) {
+    TL.insertSSPDeclarations(*M);
+    return IRB.CreateCall(Intrinsic::getDeclaration(M, Intrinsic::stackguard));
+  }
+
   return IRB.CreateLoad(StackPtrTy, StackGuardVar, "StackGuard");
 }
 
 void SafeStack::findInsts(Function &F,
                           SmallVectorImpl<AllocaInst *> &StaticAllocas,
                           SmallVectorImpl<AllocaInst *> &DynamicAllocas,
                           SmallVectorImpl<Argument *> &ByValArguments,
                           SmallVectorImpl<Instruction *> &Returns,

llvm/test/Transforms/SafeStack/X86/abi_ssp.ll

 ; RUN: opt -safe-stack -S -mtriple=i686-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s
 ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s
 
 ; RUN: opt -safe-stack -S -mtriple=i686-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,GLOBAL32 %s
 ; RUN: opt -safe-stack -S -mtriple=i686-linux-android24 < %s -o - | FileCheck --check-prefixes=COMMON,TLS32 %s
 
 ; RUN: opt -safe-stack -S -mtriple=x86_64-linux-android < %s -o - | FileCheck --check-prefixes=COMMON,TLS64 %s
 
 ; RUN: opt -safe-stack -S -mtriple=x86_64-unknown-fuchsia < %s -o - | FileCheck --check-prefixes=COMMON,FUCHSIA64 %s
 
 define void @foo() safestack sspreq {
 entry:
 ; TLS32: %[[StackGuard:.*]] = load i8*, i8* addrspace(256)* inttoptr (i32 20 to i8* addrspace(256)*)
 ; TLS64: %[[StackGuard:.*]] = load i8*, i8* addrspace(257)* inttoptr (i32 40 to i8* addrspace(257)*)
 ; FUCHSIA64: %[[StackGuard:.*]] = load i8*, i8* addrspace(257)* inttoptr (i32 16 to i8* addrspace(257)*)
-; GLOBAL32: %[[StackGuard:.*]] = load i8*, i8** @__stack_chk_guard
+; GLOBAL32: %[[StackGuard:.*]] = call i8* @llvm.stackguard()
 ; COMMON:   store i8* %[[StackGuard]], i8** %[[StackGuardSlot:.*]]
   %a = alloca i8, align 1
   call void @Capture(i8* %a)
 
 ; COMMON: %[[A:.*]] = load i8*, i8** %[[StackGuardSlot]]
 ; COMMON: icmp ne i8* %[[StackGuard]], %[[A]]
   ret void
 }
 
 declare void @Capture(i8*)

llvm/test/Transforms/SafeStack/X86/ssp.ll

 ; RUN: opt -safe-stack -S -mtriple=x86_64-unknown < %s -o - | FileCheck %s
 
 define void @foo() safestack sspreq {
 entry:
 ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
 ; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
 ; CHECK: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
 
 ; CHECK: %[[A:.*]] = getelementptr i8, i8* %[[USP]], i32 -8
 ; CHECK: %[[StackGuardSlot:.*]] = bitcast i8* %[[A]] to i8**
-; CHECK: %[[StackGuard:.*]] = load i8*, i8** @__stack_chk_guard
+; CHECK: %[[StackGuard:.*]] = call i8* @llvm.stackguard()
 ; CHECK: store i8* %[[StackGuard]], i8** %[[StackGuardSlot]]
   %a = alloca i8, align 1
 
 ; CHECK: call void @Capture
   call void @Capture(i8* %a)
 
 ; CHECK: %[[B:.*]] = load i8*, i8** %[[StackGuardSlot]]
 ; CHECK: %[[COND:.*]] = icmp ne i8* %[[StackGuard]], %[[B]]