Clang/driver: emulated TLS mode.

[chh]

Summary

This is the clang and driver changes for emulated TLS implemented in LLVM in http://reviews.llvm.org/D10522.

[chh]

ping.

[aaron.ballman]

I do not know enough about TLS modes to comment on much of this. The
attribute-specific stuff looks good to me, with one exception:

Index: docs/AttributeReference.rst

• docs/AttributeReference.rst

+++ docs/AttributeReference.rst
@@ -743,6 +743,7 @@

• local-dynamic
• initial-exec
• local-exec

+* emulated

Please do not modify AttributeReference.rst directly; just AttrDocs.td.

Thanks!

~Aaron

[chh]

This is for bug https://llvm.org/bugs/show_bug.cgi?id=23566

[chh]

Aaron, I uploaded a second patch which does not change AttributeReference.rst.
Thanks.

[joerg]

Why do we need this? Shouldn't the backend translate whatever TLS access it finds into the emulation? I really would like to see some context for this change.

[chh]

This patch should keep the default clang/llvm configuration for all targets, but add the necessary -ftls-model=emulated flag for Android users that need TLS.
Please see also the comments in the llvm bug:
https://llvm.org/bugs/show_bug.cgi?id=23566#c4

[chh]

I see your question now. At the beginning I was looking for a way to set up
some configuration flag too for *-*-android targets to tell LLVM how to
lower TLS code. Trying to recognize "android" environment in LLVM seems too
restricted, as the emulated model could be useful to any target.

The existing -ftls-model looks like a natural hook to me.
This allows any target to support multiple TLS models and let users choose
which model to compile. The attribute((tls_model(...)) syntax seems
also a nice feature to keep, so I added the "emulated" mode into both
-ftls-model and tls_model attributes. As you can see in this patch and the
other LLVM patch, I was testing multiple models at the same time.

[chh]

Here is Joerg's comment sent to llvm-commits@ but somehow did not reach here:

Date: Tue, 30 Jun 2015 13:03:13 +0200
From: Joerg Sonnenberger <[e-mail]>
To: [e-mail]
Subject: Re: [PATCH] Clang/driver: emulated TLS mode.
Message-ID: <[e-mail]>
Content-Type: text/plain; charset=us-ascii

On Mon, Jun 29, 2015 at 01:45:25PM -0700, Chih-hung Hsieh wrote:

I see your question now. At the beginning I was looking for a way to set up
some configuration flag too for *-*-android targets to tell LLVM how to
lower TLS code. Trying to recognize "android" environment in LLVM seems too
restricted, as the emulated model could be useful to any target.

Having a codegen flag to enable the translation of TLS access via the
emulation pass would be an option, but for that the pass should exist
first.

The existing -ftls-model looks like a natural hook to me.
This allows any target to support multiple TLS models and let users choose
which model to compile. The attribute((tls_model(...)) syntax seems
also a nice feature to keep, so I added the "emulated" mode into both
-ftls-model and tls_model attributes. As you can see in this patch and the
other LLVM patch, I was testing multiple models at the same time.

I don't think multiple TLS models in the sense of "native" vs "emultls"
is something that makes sense. TLS emulation is pretty much a crude hack
to workaround limitations either in the OS environment (Android) or the
toolchain (for NetBSD: VAX and Sun2). Given all the associated
complications, it would be insane to force the emulation path when
native TLS exists. Note that GCC supports different dialects for TLS
access on some platforms like ARM, but those are more like optimised
sequences.

[chh]

I agree that this is a less optimal, or you can say backward or "temporary", solution in llvm to support emutls. The important benefit now is to allow switching of a few core Android modules from gcc to clang/llvm sooner, as we cannot fix Android linker in time or upgrade all old Android devices for new TLS applications. Note that this is not only an Arm target issue but all major Android targets.

But Android's linker might have ELF TLS support in the future. I see no alternative for llvm to support emutls for current Android and there might be a time in the future Android users will need choices to continue using emutls (with gcc or llvm) or native TLS with llvm.

As emutls is target independent, in http://reviews.llvm.org/D10522, it is added as a new IL TLS mode. Of course it could also be completely implement in clang front-end and be translated to IL that contains no reference to special TLS get_address IL. That seems a more complicated implementation to me, or did I miss something?
Is there a similar front-end translation pass in clang that I can learn or reuse for emutls?

[rnk]

How does GCC do expose this model? Do they support __attribute__((tls_model("emulated"))), or is it a backend option like Joerg is suggesting?

If we go the backend option route, it doesn't have to be specific to Android, we can have some target predicate that can change in the future like useGCCEmulatedTLS().

test/CodeGenCXX/cxx11-thread-local.cpp

3

You can avoid duplicating the CHECK lines by giving FileCheck multiple prefixes:

| FileCheck --check-prefix=COMMON --check-prefix=EMU %s

[chh]

Thanks for the suggestion about FileCheck prefixes.
I will simplify the code soon.

Gcc has configuration flags to enable or disable TLS.
It's emutls model/pass can be selected through configuration:

https://github.com/gcc-mirror/gcc/blob/master/gcc/tree-emutls.c

I have not found a compile time flag to select emulated vs native TLS models,
although that should be doable.

When Android gcc is configured to use the emulated TLS model,
TLS attributes like attribute((tls_model("local-dynamic")))
are silently ignored. The emulated model is used.
Lacking warning is bad, and it might be accepted only
when a target really cannot support both native and native TLS.

Android supports only emulated TLS now, but should be able to support both
in the future. To replace Android gcc with llvm, I would really like to have
a compile time flag instead of two copies of Android llvm to support/test
both TLS models. The -ftls-model seems to be the flag to add such a feature.
Then it follows to allow 5 tls_model attributes.

I see that clang's -ftls-model flag sets default, but does not overwrite
attribute((tls_model("local-dynamic"))). So I think an easy
implementation is to do the same for the -ftls-model=emulated flag.

The alternative is a new compile-time flag to enable emulated TLS and overrides all other 4 native tls_model attributes, and give warnings. This new flag will be needed at both clang/driver level and llvm IL level, right? Is that what you want? Any suggestion for the name or mechanism?

[yaron.keren]

mingw on Windows uses emutls, so an option to do the same makes sense, maybe even the default to keep compatibility.

[rnk]

I don't think it's necessary to warn on the local_exec, etc models. Those flags still provide information about how visible the TLS is, we just don't use it.

It sounds like we should have a -f flag, like -femulated-tls, that controls what we do. The default for Android and MinGW would be to enable it, and that could change over time.

Chandler thinks that this emulation should be done in Clang IRGen, but Nick and I disagree that this should happen late in LLVM. I suggested it could be an IR codegen preparation pass, but David Majnemer disagreed because then it's harder to CSE the call to compute the address of the TLS. Then again, the IR lowering you already have doesn't support CSE, and I think that's fine.

[chh]

Reid, -femulated-tls and the defaults sound good to me.

I don't know much of clang's other passes yet. I made the emulated mode as similar to other 4 modes as possible and it seemed to be the easiest approach for me.

Could you tell me the best way to pass the -femulated-tls to llvm backend?

With -femulated-tls, we don't need attribute tls_model("emulated").
(1) If other tls_model attributes found by clang are passed to llvm, e.g., as thread_local(localexec) attribute, llvm will need a separate flag to process them like thread_local(emulated) attribute. Would this be a per compilation unit flag?
(2) If clang converts all other tls_model attributes and the default to thread_local(emulated) for llvm, we can use most of http://reviews.llvm.org/D10522 as is, and llvm can handle 5 TLS modes in one compilation unit.

[rnk]

In D10524#205066, @chh wrote:

Could you tell me the best way to pass the -femulated-tls to llvm backend?

Because of LTO, we generally don't have a place for codegen options to live on the module. Probably a string attribute "emulated-tls" or "tls-emulation" on the GlobalVariable would be the way to go.

[chh]

So in IR, a global variable can have string attributes like

thread_local emulated-tls
thread_local(localdynamic) emulated-tls
thread_local(initialexec) emulated-tls
thread_local(localexec) emulated-tls

I can give it a try.
Not sure yet if that will have shorter or longer patch.

[chh]

Diff 3 simplified the clang front-end and driver changes:

• Only -femulated-tls and -fno-emulated-tls flags are added. Default is -fno-emulated-tls mode.

• Unit tests are modified to check:
  • C uninitialized global variables are common, but uninitialized thread local variables are not.
  • The -femulated-tls and -fno-emulated-tls flags are passed from clang to cc1.

[rnk]

include/clang/Driver/Options.td

515 ↗

(On Diff #29973)

This doesn't need to be a cc1 option, we can have just -femulated-tls for cc1 and remove the negative one in the driver.

lib/Driver/Tools.cpp

3955–3956 ↗

(On Diff #29973)

Generally we try to canonicalize flags in the driver rather than in cc1. Rather than doing this, how about something like the following:

// Emulated TLS is enabled by default on Android, and can be enabled manually with -femulated-tls.
bool EmulatedTLSDefault = Triple.getEnvironment() == llvm::Triple::Android;
if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls, EmulatedTLSDefault))
  CmdArgs.push_back("-femulated-tls");

test/CodeGen/tls-model.c

7

We try to use %clang_cc1 outside of driver tests. We can check for the -femulated-tls flag easily in the driver, and then use the cc1 interface directly.

8–17

We only need the first test for CodeGen.

[chh]

I might guess wrong the suggested changes.
Please check if the new diff is what you suggested.
Thanks.

[rnk]

lgtm

test/CodeGenCXX/cxx11-thread-local.cpp

2

I also meant for this comment to apply here:
"We try to use %clang_cc1 outside of driver tests. We can check for the -femulated-tls flag easily in the driver, and then use the cc1 interface directly."

[chh]

test/CodeGenCXX/cxx11-thread-local.cpp

2

Sure. I will fix that before submit.

docs/UsersManual.rst

.. option:: -ftrap-function=[name]
    deeply embedded) where a trap cannot be properly handled, or when
    some custom behavior is desired.
 
 .. option:: -ftls-model=[model]
 
    Select which TLS model to use.
 
    Valid values are: ``global-dynamic``, ``local-dynamic``,
-   ``initial-exec`` and ``local-exec``. The default value is
-   ``global-dynamic``. The compiler may use a different model if the
+   ``initial-exec``, ``local-exec`` and ``emulated``. The default value is
+   ``global-dynamic``.  The compiler may use a different model if the
    selected model is not supported by the target, or if a more
    efficient model can be used. The TLS model can be overridden per
    variable using the ``tls_model`` attribute.
 
 .. option:: -mhwdiv=[values]
 
    Select the ARM modes (arm or thumb) that support hardware division
    instructions.

docs/tools/clang.pod

 =item B<-fcommon>
 
 This flag specifies that variables without initializers get common linkage.  It
 can be disabled with B<-fno-common>.
 
 =item B<-ftls-model>
 
 Set the default thread-local storage (TLS) model to use for thread-local
-variables. Valid values are: "global-dynamic", "local-dynamic", "initial-exec"
-and "local-exec". The default is "global-dynamic". The default model can be
+variables. Valid values are: "global-dynamic", "local-dynamic", "initial-exec",
+"local-exec", and "emulated". The default is "global-dynamic" or "emulated" if
+the target platform does not support "global-dynamic". The default model can be
 overridden with the tls_model attribute. The compiler will try to choose a more
 efficient model if possible.
 
 =item B<-flto> B<-emit-llvm>
 
 Generate output files in LLVM formats, suitable for link time optimization. When
 used with B<-S> this generates LLVM intermediate language assembly files,
 otherwise this generates LLVM bitcode format object files (which may be passed

include/clang/Basic/AttrDocs.td

def TLSModelDocs : Documentation {
   let Content = [{
 The ``tls_model`` attribute allows you to specify which thread-local storage
 model to use. It accepts the following strings:
 
 * global-dynamic
 * local-dynamic
 * initial-exec
 * local-exec
+* emulated
 
 TLS models are mutually exclusive.
   }];
 }
 
 def ThreadDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{

include/clang/Basic/DiagnosticSemaKinds.td

def err_property_function_in_objc_container : Error<
   "container not supported, move function outside its container">;
 
 let CategoryName = "Cocoa API Issue" in {
 def warn_objc_redundant_literal_use : Warning<
   "using %0 with a literal is redundant">, InGroup<ObjCRedundantLiteralUse>;
 }
 
 def err_attr_tlsmodel_arg : Error<"tls_model must be \"global-dynamic\", "
-  "\"local-dynamic\", \"initial-exec\" or \"local-exec\"">;
+  "\"local-dynamic\", \"initial-exec\", \"local-exec\" or \"emulated\"">;
 
 def err_only_annotate_after_access_spec : Error<
   "access specifier can only have annotation attributes">;
 
 def err_attribute_section_invalid_for_target : Error<
   "argument to 'section' attribute is not valid for this target: %0">;
 def warn_mismatched_section : Warning<
   "section does not match previous declaration">, InGroup<Section>;

include/clang/Frontend/CodeGenOptions.h

enum DebugInfoKind {
 
     FullDebugInfo         /// Generate complete debug info.
   };
 
   enum TLSModel {
     GeneralDynamicTLSModel,
     LocalDynamicTLSModel,
     InitialExecTLSModel,
-    LocalExecTLSModel
+    LocalExecTLSModel,
+    EmulatedTLSModel
   };
 
   enum FPContractModeKind {
     FPC_Off,        // Form fused FP ops only where result will not be affected.
     FPC_On,         // Form fused FP ops according to FP_CONTRACT rules.
     FPC_Fast        // Aggressively fuse FP ops (E.g. FMA).
   };
 

include/clang/Frontend/CodeGenOptions.def

 
 /// The kind of inlining to perform.
 ENUM_CODEGENOPT(Inlining, InliningMethod, 2, NoInlining)
 
 // Vector functions library to use.
 ENUM_CODEGENOPT(VecLib, VectorLibrary, 1, NoLibrary)
 
 /// The default TLS model to use.
-ENUM_CODEGENOPT(DefaultTLSModel, TLSModel, 2, GeneralDynamicTLSModel)
+ENUM_CODEGENOPT(DefaultTLSModel, TLSModel, 3, GeneralDynamicTLSModel)
 
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT
 #undef VALUE_CODEGENOPT
 

lib/CodeGen/CodeGenModule.cpp

if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
     GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
 }
 
 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
   return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
       .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
       .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
       .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
-      .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
+      .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel)
+      .Case("emulated", llvm::GlobalVariable::EmulatedTLSModel);
 }
 
 static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
     CodeGenOptions::TLSModel M) {
   switch (M) {
   case CodeGenOptions::GeneralDynamicTLSModel:
     return llvm::GlobalVariable::GeneralDynamicTLSModel;
   case CodeGenOptions::LocalDynamicTLSModel:
     return llvm::GlobalVariable::LocalDynamicTLSModel;
   case CodeGenOptions::InitialExecTLSModel:
     return llvm::GlobalVariable::InitialExecTLSModel;
   case CodeGenOptions::LocalExecTLSModel:
     return llvm::GlobalVariable::LocalExecTLSModel;
+  case CodeGenOptions::EmulatedTLSModel:
+    return llvm::GlobalVariable::EmulatedTLSModel;
   }
   llvm_unreachable("Invalid TLS model!");
 }
 
 void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
   assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
 
   llvm::GlobalValue::ThreadLocalMode TLM;

lib/CodeGen/ItaniumCXXABI.cpp

llvm::FunctionType *FTy =
         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
     InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init",
                                                       SourceLocation(),
                                                       /*TLS=*/true);
     llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
         CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
         llvm::GlobalVariable::InternalLinkage,
         llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
+    // Use EmulatedTLSModel when -ftls-model=emulated
+    if (CGM.getCodeGenOpts().getDefaultTLSModel() ==
+        clang::CodeGenOptions::TLSModel::EmulatedTLSModel)
+      Guard->setThreadLocalMode(
+          llvm::GlobalValue::ThreadLocalMode::EmulatedTLSModel);
+    else
       Guard->setThreadLocal(true);
     CodeGenFunction(CGM)
         .GenerateCXXGlobalInitFunc(InitFunc, CXXThreadLocalInits, Guard);
   }
   for (unsigned I = 0, N = CXXThreadLocals.size(); I != N; ++I) {
     const VarDecl *VD = CXXThreadLocals[I].first;
     llvm::GlobalVariable *Var = CXXThreadLocals[I].second;
 
     // Some targets require that all access to thread local variables go through

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
 
   if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
     StringRef Name = A->getValue();
     unsigned Model = llvm::StringSwitch<unsigned>(Name)
         .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
         .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
         .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
         .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
+        .Case("emulated", CodeGenOptions::EmulatedTLSModel)
         .Default(~0U);
     if (Model == ~0U) {
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
       Success = false;
     } else {
       Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
     }
   }

lib/Sema/SemaDeclAttr.cpp

static void handleTLSModelAttr(Sema &S, Decl *D,
   StringRef Model;
   SourceLocation LiteralLoc;
   // Check that it is a string.
   if (!S.checkStringLiteralArgumentAttr(Attr, 0, Model, &LiteralLoc))
     return;
 
   // Check that the value.
   if (Model != "global-dynamic" && Model != "local-dynamic"
-      && Model != "initial-exec" && Model != "local-exec") {
+      && Model != "initial-exec" && Model != "local-exec"
+      && Model != "emulated") {
     S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
     return;
   }
 
   D->addAttr(::new (S.Context)
              TLSModelAttr(Attr.getRange(), S.Context, Model,
                           Attr.getAttributeSpellingListIndex()));
 }

test/CodeGen/thread-specifier.c

 // RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
 
+// CHECK: @a1 = global i32 0, align 4
 // CHECK: @b = external thread_local global
 // CHECK: @d.e = internal thread_local global
 // CHECK: @d.f = internal thread_local global
-// CHECK: @f.a = internal thread_local(initialexec) global
-// CHECK: @a = thread_local global
-// CHECK: @g = thread_local global
-// CHECK: @h = thread_local(localdynamic) global
-// CHECK: @i = thread_local(initialexec) global
-// CHECK: @j = thread_local(localexec) global
+// CHECK: @f.a = internal thread_local(initialexec) global i32 0, align 4
+// CHECK: @f.b = internal thread_local(emulated) global i32 0, align 4
+// CHECK: @a0 = common global i32 0, align 4
+// CHECK: @a = thread_local global i32 0, align 4
+// CHECK: @g = thread_local global i32 0, align 4
+// CHECK: @h = thread_local(localdynamic) global i32 0, align 4
+// CHECK: @i = thread_local(initialexec) global i32 0, align 4
+// CHECK: @j = thread_local(localexec) global i32 0, align 4
+// CHECK: @k = thread_local(emulated) global i32 0, align 4
 
 // CHECK-NOT: @_ZTW
 // CHECK-NOT: @_ZTH
 
+int a0;
+int a1 = 0;
+
 __thread int a;
 extern __thread int b;
 int c() { return *&b; }
 int d() {
   __thread static int e;
   __thread static union {float a; int b;} f = {.b = 1};
   return 0;
 }
 
 __thread int g __attribute__((tls_model("global-dynamic")));
 __thread int h __attribute__((tls_model("local-dynamic")));
 __thread int i __attribute__((tls_model("initial-exec")));
 __thread int j __attribute__((tls_model("local-exec")));
+__thread int k __attribute__((tls_model("emulated")));
 
 int f() {
   __thread static int a __attribute__((tls_model("initial-exec")));
-  return a++;
+  __thread static int b __attribute__((tls_model("emulated")));
+  return a++ + b++;
 }

test/CodeGen/tls-model.c

 // RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-GD
 // RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -ftls-model=global-dynamic -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-GD
 // RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -ftls-model=local-dynamic -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-LD
 // RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -ftls-model=initial-exec -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-IE
 // RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -ftls-model=local-exec -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-LE
+// RUN: %clang_cc1 %s -triple x86_64-pc-linux-gnu -ftls-model=emulated -emit-llvm -o - | FileCheck %s -check-prefix=CHECK-EMU
 
+int z1 = 0;
 int __thread x;
 int f() {
   static int __thread y;
   return y++;
 }
 int __thread __attribute__((tls_model("initial-exec"))) z;
+int __thread __attribute__((tls_model("emulated"))) z2;
+int z3;
 
+// Note that unlike normal C uninitialized global variables,
+// uninitialized TLS variables do NOT have COMMON linkage.
+
+// CHECK-GD: @z1 = global i32 0, align 4
 // CHECK-GD: @f.y = internal thread_local global i32 0
-// CHECK-GD: @x = thread_local global i32 0
-// CHECK-GD: @z = thread_local(initialexec) global i32 0
+// CHECK-GD: @x = thread_local global i32 0, align 4
+// CHECK-GD: @z = thread_local(initialexec) global i32 0, align 4
+// CHECK-GD: @z2 = thread_local(emulated) global i32 0, align 4
+// CHECK-GD: @z3 = common global i32 0, align 4
 
+// CHECK-LD: @z1 = global i32 0, align 4
 // CHECK-LD: @f.y = internal thread_local(localdynamic) global i32 0
-// CHECK-LD: @x = thread_local(localdynamic) global i32 0
-// CHECK-LD: @z = thread_local(initialexec) global i32 0
+// CHECK-LD: @x = thread_local(localdynamic) global i32 0, align 4
+// CHECK-LD: @z = thread_local(initialexec) global i32 0, align 4
+// CHECK-LD: @z2 = thread_local(emulated) global i32 0, align 4
+// CHECK-LD: @z3 = common global i32 0, align 4
 
+// CHECK-IE: @z1 = global i32 0, align 4
 // CHECK-IE: @f.y = internal thread_local(initialexec) global i32 0
-// CHECK-IE: @x = thread_local(initialexec) global i32 0
-// CHECK-IE: @z = thread_local(initialexec) global i32 0
+// CHECK-IE: @x = thread_local(initialexec) global i32 0, align 4
+// CHECK-IE: @z = thread_local(initialexec) global i32 0, align 4
+// CHECK-IE: @z2 = thread_local(emulated) global i32 0, align 4
+// CHECK-IE: @z3 = common global i32 0, align 4
 
+// CHECK-LE: @z1 = global i32 0, align 4
 // CHECK-LE: @f.y = internal thread_local(localexec) global i32 0
-// CHECK-LE: @x = thread_local(localexec) global i32 0
-// CHECK-LE: @z = thread_local(initialexec) global i32 0
+// CHECK-LE: @x = thread_local(localexec) global i32 0, align 4
+// CHECK-LE: @z = thread_local(initialexec) global i32 0, align 4
+// CHECK-LE: @z2 = thread_local(emulated) global i32 0, align 4
+// CHECK-LE: @z3 = common global i32 0, align 4
+
+// CHECK-EMU: @z1 = global i32 0, align 4
+// CHECK-EMU: @f.y = internal thread_local(emulated) global i32 0
+// CHECK-EMU: @x = thread_local(emulated) global i32 0, align 4
+// CHECK-EMU: @z = thread_local(initialexec) global i32 0, align 4
+// CHECK-EMU: @z2 = thread_local(emulated) global i32 0, align 4
+// CHECK-EMU: @z3 = common global i32 0, align 4

test/CodeGenCXX/cxx11-thread-local.cpp

 // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -ftls-model=emulated -emit-llvm %s -o - \
+// RUN:   -triple x86_64-linux-gnu | FileCheck --check-prefix=EMU %s
+
+// Make sure that -tfls-model=emulated sets all thread_local variables to
+// the default thread_local(emulated) mode.
 
 int f();
 int g();
 
 // CHECK: @a = thread_local global i32 0
+// EMU: @a = thread_local(emulated) global i32 0
 thread_local int a = f();
+
 extern thread_local int b;
+
 // CHECK: @c = global i32 0
+// EMU: @c = global i32 0
 int c = b;
+
 // CHECK: @_ZL1d = internal thread_local global i32 0
+// EMU: @_ZL1d = internal thread_local(emulated) global i32 0
 static thread_local int d = g();
 
 struct U { static thread_local int m; };
+
 // CHECK: @_ZN1U1mE = thread_local global i32 0
+// EMU: @_ZN1U1mE = thread_local(emulated) global i32 0
 thread_local int U::m = f();
 
 template<typename T> struct V { static thread_local int m; };
 template<typename T> thread_local int V<T>::m = g();
 
 // CHECK: @e = global i32 0
+// EMU: @e = global i32 0
 int e = V<int>::m;
 
 // CHECK: @_ZN1VIiE1mE = linkonce_odr thread_local global i32 0
+// EMU: @_ZN1VIiE1mE = linkonce_odr thread_local(emulated) global i32 0
 
 // CHECK: @_ZZ1fvE1n = internal thread_local global i32 0
+// EMU: @_ZZ1fvE1n = internal thread_local(emulated) global i32 0
 
 // CHECK: @_ZGVZ1fvE1n = internal thread_local global i8 0
+// EMU: @_ZGVZ1fvE1n = internal thread_local(emulated) global i8 0
 
 // CHECK: @_ZZ8tls_dtorvE1s = internal thread_local global
+// EMU: @_ZZ8tls_dtorvE1s = internal thread_local(emulated) global
 // CHECK: @_ZGVZ8tls_dtorvE1s = internal thread_local global i8 0
+// EMU: @_ZGVZ8tls_dtorvE1s = internal thread_local(emulated) global i8 0
 
 // CHECK: @_ZZ8tls_dtorvE1t = internal thread_local global
+// EMU: @_ZZ8tls_dtorvE1t = internal thread_local(emulated) global
 // CHECK: @_ZGVZ8tls_dtorvE1t = internal thread_local global i8 0
+// EMU: @_ZGVZ8tls_dtorvE1t = internal thread_local(emulated) global i8 0
 
 // CHECK: @_ZZ8tls_dtorvE1u = internal thread_local global
+// EMU: @_ZZ8tls_dtorvE1u = internal thread_local(emulated) global
 // CHECK: @_ZGVZ8tls_dtorvE1u = internal thread_local global i8 0
+// EMU: @_ZGVZ8tls_dtorvE1u = internal thread_local(emulated) global i8 0
 // CHECK: @_ZGRZ8tls_dtorvE1u_ = internal thread_local global
+// EMU: @_ZGRZ8tls_dtorvE1u_ = internal thread_local(emulated) global
 
 // CHECK: @_ZGVN1VIiE1mE = linkonce_odr thread_local global i64 0
+// EMU: @_ZGVN1VIiE1mE = linkonce_odr thread_local(emulated) global i64 0
 
 // CHECK: @__tls_guard = internal thread_local global i8 0
+// EMU: @__tls_guard = internal thread_local(emulated) global i8 0
 
 // CHECK: @llvm.global_ctors = appending global {{.*}} @[[GLOBAL_INIT:[^ ]*]]
+// EMU: @llvm.global_ctors = appending global {{.*}} @[[GLOBAL_INIT:[^ ]*]]
 
 // CHECK: @_ZTH1a = alias void ()* @__tls_init
+// EMU: @_ZTH1a = alias void ()* @__tls_init
 // CHECK: @_ZTHL1d = internal alias void ()* @__tls_init
+// EMU: @_ZTHL1d = internal alias void ()* @__tls_init
 // CHECK: @_ZTHN1U1mE = alias void ()* @__tls_init
+// EMU: @_ZTHN1U1mE = alias void ()* @__tls_init
 // CHECK: @_ZTHN1VIiE1mE = linkonce_odr alias void ()* @__tls_init
+// EMU: @_ZTHN1VIiE1mE = linkonce_odr alias void ()* @__tls_init
 
 
 // Individual variable initialization functions:
 
 // CHECK: define {{.*}} @[[A_INIT:.*]]()
+// EMU: define {{.*}} @[[A_INIT:.*]]()
 // CHECK: call i32 @_Z1fv()
+// EMU: call i32 @_Z1fv()
 // CHECK-NEXT: store i32 {{.*}}, i32* @a, align 4
+// EMU-NEXT: store i32 {{.*}}, i32* @a, align 4
 
 // CHECK-LABEL: define i32 @_Z1fv()
 int f() {
   // CHECK: %[[GUARD:.*]] = load i8, i8* @_ZGVZ1fvE1n, align 1
+  // EMU: %[[GUARD:.*]] = load i8, i8* @_ZGVZ1fvE1n, align 1
   // CHECK: %[[NEED_INIT:.*]] = icmp eq i8 %[[GUARD]], 0
+  // EMU: %[[NEED_INIT:.*]] = icmp eq i8 %[[GUARD]], 0
   // CHECK: br i1 %[[NEED_INIT]]
+  // EMU: br i1 %[[NEED_INIT]]
 
   // CHECK: %[[CALL:.*]] = call i32 @_Z1gv()
+  // EMU: %[[CALL:.*]] = call i32 @_Z1gv()
   // CHECK: store i32 %[[CALL]], i32* @_ZZ1fvE1n, align 4
+  // EMU: store i32 %[[CALL]], i32* @_ZZ1fvE1n, align 4
   // CHECK: store i8 1, i8* @_ZGVZ1fvE1n
+  // EMU: store i8 1, i8* @_ZGVZ1fvE1n
   // CHECK: br label
+  // EMU: br label
   static thread_local int n = g();
 
   // CHECK: load i32, i32* @_ZZ1fvE1n, align 4
+  // EMU: load i32, i32* @_ZZ1fvE1n, align 4
   return n;
 }
 
 // CHECK: define {{.*}} @[[C_INIT:.*]]()
 // CHECK: call i32* @_ZTW1b()
 // CHECK-NEXT: load i32, i32* %{{.*}}, align 4
 // CHECK-NEXT: store i32 %{{.*}}, i32* @c, align 4
 

test/Sema/attr-tls_model.c

 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -verify -fsyntax-only %s
 
 #if !__has_attribute(tls_model)
 #error "Should support tls_model attribute"
 #endif
 
 int f() __attribute((tls_model("global-dynamic"))); // expected-error {{'tls_model' attribute only applies to thread-local variables}}
 
 int x __attribute((tls_model("global-dynamic"))); // expected-error {{'tls_model' attribute only applies to thread-local variables}}
 static __thread int y __attribute((tls_model("global-dynamic"))); // no-warning
 
 static __thread int y __attribute((tls_model("local", "dynamic"))); // expected-error {{'tls_model' attribute takes one argument}}
 static __thread int y __attribute((tls_model(123))); // expected-error {{'tls_model' attribute requires a string}}
-static __thread int y __attribute((tls_model("foobar"))); // expected-error {{tls_model must be "global-dynamic", "local-dynamic", "initial-exec" or "local-exec"}}
+static __thread int y __attribute((tls_model("foobar"))); // expected-error {{tls_model must be "global-dynamic", "local-dynamic", "initial-exec", "local-exec" or "emulated"}}