switch to emulated TLV on macOS before 10.7

[catap]

Summary

The first version of macOS which had TLV inside DYLD was macOS 10.7 and llvm/clang can't compile code:

__thread int x;

void use_x() {
    x = 7;
}

This patch allows to compile code above on macOS before 10.7 as:

	.section	__TEXT,__text,regular,pure_instructions
	.macosx_version_min 10, 6
	.globl	_use_x                          ## -- Begin function use_x
	.p2align	4, 0x90
_use_x:                                 ## @use_x
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	leaq	___emutls_v.x(%rip), %rdi
	callq	___emutls_get_address
	movl	$7, (%rax)
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.section	__DATA,__data
	.globl	___emutls_v.x                   ## @__emutls_v.x
	.p2align	3
___emutls_v.x:
	.quad	4                               ## 0x4
	.quad	4                               ## 0x4
	.quad	0
	.quad	0

.subsections_via_symbols

Which allows me to build rust for macOS 10.6 for example.

As far as I know it was impossible to run x86_64/i386 on apple hardware before 10.4, and LLVM have some issue with ABI on PowerPC for macOS => I've limited support for 10.4+.

This changes effectively reverts an assumption that was introduced at least at 25 Jun 2010 in commit https://github.com/llvm/llvm-project/commit/17c7b89054639ad3cd86f917ad11a50377c8de17

I guess it isn't the only place, but it shown how deep ago it was.

This patch was tested on all MacPorts users for quite a while since it was firstly introduced on 13 Dec 2018 at commit https://github.com/macports/macports-ports/commit/5949e6264728ac7f74625c9eaf5b41d2852d07e6

Co-authored-by: Ken Cunningham <[e-mail]>

[catap]

I have a green light from build and this changes are ready for review.

clang/lib/Basic/Targets/OSTargets.h

 public:
   DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     // By default, no TLS, and we list permitted architecture/OS
     // combinations.
     this->TLSSupported = false;
 
     if (Triple.isMacOSX())
-      this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
+      this->TLSSupported = !Triple.isMacOSXVersionLT(10, 4);
     else if (Triple.isiOS()) {
       // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards,
       // 32-bit simulator from 10 onwards.
       if (Triple.isArch64Bit())
         this->TLSSupported = !Triple.isOSVersionLT(8);
       else if (Triple.isArch32Bit()) {
         if (!Triple.isSimulatorEnvironment())
           this->TLSSupported = !Triple.isOSVersionLT(9);

clang/lib/CodeGen/ItaniumCXXABI.cpp

static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
                                         llvm::Constant *addr, bool TLS) {
   assert(!CGF.getTarget().getTriple().isOSAIX() &&
          "unexpected call to emitGlobalDtorWithCXAAtExit");
   assert((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
          "__cxa_atexit is disabled");
   const char *Name = "__cxa_atexit";
   if (TLS) {
     const llvm::Triple &T = CGF.getTarget().getTriple();
-    Name = T.isOSDarwin() ?  "_tlv_atexit" : "__cxa_thread_atexit";
+    Name = (T.isOSDarwin() && !(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
+               ? "_tlv_atexit"
+               : "__cxa_thread_atexit";
   }
 
   // We're assuming that the destructor function is something we can
   // reasonably call with the default CC.  Go ahead and cast it to the
   // right prototype.
   llvm::Type *dtorTy =
     llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
 

clang/test/Sema/darwin-tls.c

-// RUN: not %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.6 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
+// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.6 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.7 %s 2>&1 | FileCheck %s --check-prefix TLS
 
 // RUN: not %clang_cc1 -fsyntax-only -triple arm64-apple-ios7.1 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
 // RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-ios8.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: not %clang_cc1 -fsyntax-only -triple thumbv7s-apple-ios8.3 %s 2>&1 | FileCheck %s --check-prefix NO-TLS
 // RUN: %clang_cc1 -fsyntax-only -triple thumbv7s-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: %clang_cc1 -fsyntax-only -triple armv7-apple-ios9.0 %s 2>&1 | FileCheck %s --check-prefix TLS
 // RUN: not %clang_cc1 -fsyntax-only -triple i386-apple-ios9.0-simulator %s 2>&1 | FileCheck %s --check-prefix NO-TLS

clang/test/Sema/tls.c

 // Test that TLS is correctly considered supported or unsupported for the
 // different targets.
 
 // Linux supports TLS.
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only %s
 
-// Darwin supports TLS since 10.7.
-// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s
+// Darwin supports TLS.
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s
 // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only %s
 
 // RUN: %clang_cc1 -triple x86_64-pc-win32 -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only %s
 
 // OpenBSD supports TLS.
 // RUN: %clang_cc1 -triple x86_64-pc-openbsd -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-openbsd -fsyntax-only %s
 
 // Haiku does not support TLS.
 // RUN: not %clang_cc1 -triple i586-pc-haiku -fsyntax-only %s
 
 __thread int x;

clang/test/SemaCXX/cxx11-thread-unsupported.cpp

-// RUN: %clang_cc1 -std=c++11 -triple=x86_64-apple-macosx10.6 -verify %s
-
-void f() {
-  thread_local int x; // expected-error {{thread-local storage is not supported for the current target}}
-}

llvm/include/llvm/ADT/Triple.h

public:
 
   /// Tests whether the target supports comdat
   bool supportsCOMDAT() const {
     return !(isOSBinFormatMachO() || isOSBinFormatXCOFF());
   }
 
   /// Tests whether the target uses emulated TLS as default.
   bool hasDefaultEmulatedTLS() const {
-    return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
+    return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment() ||
+           (isMacOSX() && isMacOSXVersionLT(10, 7));
   }
 
   /// Tests whether the target uses -data-sections as default.
   bool hasDefaultDataSections() const {
     return isOSBinFormatXCOFF() || isWasm();
   }
 
   /// Tests if the environment supports dllimport/export annotations.