[clang] Fix checking for emulated TLS in shouldAssumeDSOLocal in CodeGen

[mstorsjo]

Summary

We shouldn't just check the clang options, we also should check
Triple::hasDefaultEmulatedTLS().

This doesn't make any testable difference in this commit, because
the check for emulated TLS is within a block for
TT.isWindowsGNUEnvironment(), and hasDefaultEmulatedTLS() returns
false for any such environment - but it makes the code from
0e4cf807aeaf54a10e02176498a7df13ac722b37 / D102970 more correct and
generic.

Some mingw distributions carry a downstream patch, that enables
emulated TLS by default for mingw targets in hasDefaultEmulatedTLS()

• and for such cases, this patch does make a difference and fixes the

detection of emulated TLS, if it is implicitly enabled.

I'm open for better suggestions on where to place the useEmulatedTLS()
helper function; it's a parallel to the preexisting
TargetMachine::useEmulatedTLS() which does the same, within llvm.

[aaron.ballman]

Adding a few more reviewers for better opinions, but the changes look reasonable to me.

[efriedma]

I'm not really happy with the way this implicitly ties the implementation of this function to the implementation of TargetMachine::useEmulatedTLS(). I'd prefer to just make clang always explicitly compute whether EmullatedTLS is enabled, then always set ExplicitEmulatedTLS, so the backend can't choose something different from what the frontend thinks it should be using. (So we always call hasDefaultEmulatedTLS() if we can't find an femulated-tls flag in CompilerInvocation. And the ExplicitEmulatedTLS flag in clang goes away.)

Alternatively, if you think clang really shouldn't care whether emulated TLS is enabled, we could just conservatively return false from shouldAssumeDSOLocal, and let some later optimization clean it up. Not sure what implications that has for code generation.

[mstorsjo]

Abandoned in favour of D132916.

clang/lib/CodeGen/CodeGenModule.h

public:
 
   CGCXXABI &getCXXABI() const { return *ABI; }
   llvm::LLVMContext &getLLVMContext() { return VMContext; }
 
   bool shouldUseTBAA() const { return TBAA != nullptr; }
 
   const TargetCodeGenInfo &getTargetCodeGenInfo();
 
+  bool useEmulatedTLS() const {
+    if (CodeGenOpts.ExplicitEmulatedTLS)
+      return CodeGenOpts.EmulatedTLS;
+    return getTriple().hasDefaultEmulatedTLS();
+  }
+
   CodeGenTypes &getTypes() { return Types; }
 
   CodeGenVTables &getVTables() { return VTables; }
 
   ItaniumVTableContext &getItaniumVTableContext() {
     return VTables.getItaniumVTableContext();
   }
 

clang/lib/CodeGen/CodeGenModule.cpp

if (TT.isWindowsGNUEnvironment()) {
     // imported from a DLL by the linker; don't mark variables that
     // potentially could come from another DLL as DSO local.
 
     // With EmulatedTLS, TLS variables can be autoimported from other DLLs
     // (and this actually happens in the public interface of libstdc++), so
     // such variables can't be marked as DSO local. (Native TLS variables
     // can't be dllimported at all, though.)
     if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
-        (!GV->isThreadLocal() || CGM.getCodeGenOpts().EmulatedTLS))
+        (!GV->isThreadLocal() || CGM.useEmulatedTLS()))
       return false;
   }
 
   // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
   // remain unresolved in the link, they can be resolved to zero, which is
   // outside the current DSO.
   if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
     return false;