Represent runtime preemption in the IR.

[sfertile]

Summary

Currently we do not represent runtime preemption in the IR, which has several drawbacks:

1. The semantics of GlobalValues differ depending on the object file format you are targeting (as well as the relocation-model and -fPIE value).
2. We have no way of disabling inlining of run time interposable functions, since in the IR we only know if a function is link-time interposable. Because of this llvm cannot support elf-interposition semantics.
3. In LTO builds of executables we will have extra knowledge that a symbol resolved to a local definition and can't be preemptable, but have no way to propagate that knowledge through the compiler.

This patch adds preemptability specifiers to the IR with the following meaning:
dso_local means the compiler may assume the symbol will resolve to a definition within the current linkage unit and the symbol may be accessed directly even if the definition is not within this compilation unit.
dso_preemptable means that the compiler must assume the GlobalValue may be replaced with a definition from outside the current linkage unit at runtime.

There is a question with the implementation though: should these be optional, or do we eventually want these to be required on every GlobalValue? My motivation for picking up this patch is to resolve the lto limitation, and that can be done equally well either way. I believe the original motivation though was issues 1 and 2. To support an option like '-fsemantic-interposition' then clang will need to properly mark the global values with dso_local/dso_preemptable, and we can support older bitcode files simply by treating global values as preemptable when not marked as explicitly dso_local. That will be pessimistic with old bitcode but at least have the correct semantics and not require breaking compatibility. I would appreciate some feedback in this area, how do people want to proceed?

[tmsriram]

Do you guys think this is a reasonable direction? If so I will add bitcode serialization support and upgrade and plug it to the other object formats.

Thanks for taking the time to do this. If you could also address the use cases of these new linkages. I can think of two ways:

• Using new attributes to specify these linkage types

Annotating the source with this is going to be difficult and error prone as the same source file could be potentially used to link a shared object and an executable.

• Using compile-time flags like -fvisibilty=extern-local or -fvisibility=strong-preemptable

Do you envision something like this? In that case, with -fvisiblity=extern-local, if we do find some extern symbols are not local, are you planning to emit an error?

For ELF atleast, preemptability can be inferred by looking at -fPIC/-fPIE/none. What is unknown is extern local. If I do not want to do source modifications, how would I get around this?

[mehdi_amini]

I agree with the general idea. I ranted about that in the past: I don't like the fact that a "default visibility" means different things depending on the object format or the platform. Whatever new attribute we come up with, it would be nice if it allows to simplifies the IR definition of "visibility" so that "default" would be "declaration is visible to other modules" and nothing more.

We should rethink the predicate we have based on the linkage in GlobalValue (things like mayBeOverridden(), isInterposable(), etc.) in light of a new attribute such as what you're proposing here.

lib/IR/Globals.cpp

55

I'm not fond of "This bit is set when we want to mark the runtime preemption as being different from the link time one", I rather have a real flag on the global value that say "isRuntimePremptable()" and avoid doing complicated inference in shouldAssumeDSOLocal() or in LLParser.cpp. I.e. it seems to me that it is easier to think about it as an "absolute" instead of a "relative" concept.

[rnk]

lib/AsmParser/LLLexer.cpp

501–502

What do you think about dso_local and dso_preemptable? The code is very clear that this is all about DSO storage, but the langref keywords are a little ambiguous.

lib/IR/Globals.cpp

44

Some comments would be useful here, the encoding of both local and preemtable in one bit is too clever.

Or we could do as Mehdi suggested and not worry about being so clever. :)

[mehdi_amini]

Can you confirm that this attribute would apply to declaration as well? So that we would generate direct accesses and not go through the GOT/PLT? Even for symbol defined in different module from their uses?

[• rafael]

This now implements all the codegen cases on x86.

I will implement the suggestions (absolute flag, rename .ll attributes) and upload again.

[mehdi_amini]

Should fix https://llvm.org/bugs/show_bug.cgi?id=23501

[sfertile]

@rafael Hi Rafael, I'm interested in picking this work up. I have rebased your patch to top of trunk and made the changes suggested in the review comments (absolute flag, prepend 'dso_' to the new keywords). I have a question though,

In D20217#430433, @mehdi_amini wrote:

Can you confirm that this attribute would apply to declaration as well? So that we would generate direct accesses and not go through the GOT/PLT? Even for symbol defined in different module from their uses?

Is this the intention? This is my motivation for picking this up.

[sfertile]

Updated the previous patch with a couple of the suggestions (make the dso_location flag absolute, add 'dso_' to the new keywords).
Refined the PowerPC FunctionCall lowering to be less conservative when deciding if a call may need a TOC restore, and updated relevant tests.
Added a PowerPC preemption test similar to the X86 test in the previous patch.

Since we now have TargetMachine::shouldAssumeDSOLocal which takes the compile options and object file format into account I didn't think we needed shouldAssumeDSOLocal in GlobalValue anymore, instead I simply respect the dso_location if it has been set explicitly.

The X86 test posted in the previous diff had a number of failures even when I stripped out everything except the 'default' cases (ie no dso_local/dso_preemptible keyword) . I left in the X86-Darwin tests since the default tests pass if I run on trunk and all the tests pass with the new changes.

Once we decide on the direction we want to take this patch then I will follow up with:

1. Refine the PowerPC Taill call eligibility checks to use 'shouldAssumeDifferentTOC' instead of 'resideInSameSection'
2. Add back the rest of the changes from the X86 target.
3. fix the removed X86 tests for linux/windows.
4. add bitcode serialization for dso_location.
5. update isInterposable() in GlobalValue.
6. Add a run step with -mcmodel=small to the 'ppc64-calls.ll' test.

[sfertile]

Updated the Tail-Call eligibility in the PowerPC back-end to use 'shouldAssumeDifferentTOC' and updated relevant tests.
Added '-code-model small' run steps to the PowerPC tests that check for tail-calls and TOC-restore nops.
Added (and updated) a Win32 preemption test.
Added 32-bit + pic run steps for the Darwin preemption test.

[rnk]

Nice, let's finally do this. :)

lib/Target/PowerPC/PPCISelLowering.cpp

4249 ↗

(On Diff #102201)

Please split this change out so that it can be committed, tested, and reverted if necessary independently from the IR change.

[inouehrs]

Which word is more common, preemptable or preemptible?
This patch uses preemptable, and the discussion here uses both. man elf on Linux uses preemptible.

include/llvm/IR/GlobalValue.h

83–84

nit: It is better to break a line; this line seems too long.

291

nit: Unnecessary white line?

[amccarth]

In D20217#778664, @inouehrs wrote:

Which word is more common, preemptable or preemptible?
This patch uses preemptable, and the discussion here uses both. man elf on Linux uses preemptible.

Google n-grams suggests the "preemptible" is on the way out and was passed by "preemptable" in the 1990s.
https://books.google.com/ngrams/graph?content=pre-emptible%2C+preemptible%2C+preemptable&year_start=1800&year_end=2000&corpus=15&smoothing=3&share=&direct_url=t1%3B%2Cpre%20-%20emptible%3B%2Cc0%3B.t1%3B%2Cpreemptible%3B%2Cc0%3B.t1%3B%2Cpreemptable%3B%2Cc0

Mirriam-Webster and American Heritage online dictionaries have no entry for either spelling, suggesting it might be a more recent coinage. I'm told OED has "preemptible," but I don't have access to a copy to verify. M-W confirms that "-able" is more common in general than "-ible."

Grammarist explains that -ible is only for older words which have historically used -ible and that all recent coinages use -able. "All accepted -ible words are listed in the dictionary." http://grammarist.com/usage/able-ible/

So I would choose "-able" as it seems more future proof.

[sfertile]

Split out the PowerPC codegen changes into a separate patch, and made some minor formatting changes.

[mehdi_amini]

Missing LangRef update.

include/llvm/IR/GlobalValue.h

76

Documentation?

107

documentation?

[sfertile]

Updated patch to use only 2 values for dso_location: dso_preemptable/dso_local.
Added Bitcode Reading/Writing.
Added tests for diagnostics issued when parsing.
Add test for llvm-as/llvm-dis.

[rnk]

This should update LangRef with a description of how this is supposed to interact with our existing linkages. For example, today we can inline external function definitions because they are not interposable according to our model. LLVM basically implements the C++ model: multiple definitions of an external linkage function would be an ODR violation, widespread usage of malloc interposition notwithstanding. You seem to be proposing to change that, because dso_local defaults to false. dso_preemptible seems to be your default. Why did you remote the old tri-state dso storage in the latest patch? It seems like we could use the third state to preserve our existing behavior unless the frontend tells us otherwise.

lib/Bitcode/Reader/BitcodeReader.cpp

942

Unnecessary whitespace change

[sfertile]

! In D20217#863605, @rnk wrote:
This should update LangRef with a description of how this is supposed to interact with our existing linkages. For example, today we can inline external function definitions because they are not interposable according to our model. LLVM basically implements the C++ model: multiple definitions of an external linkage function would be an ODR violation, widespread usage of malloc interposition notwithstanding. You seem to be proposing to change that, because dso_local defaults to false. dso_preemptible seems to be your default.

I removed the tri-state enum after thinking about Rafaels question on what the long term goal is. If the long term goal is to have IR producers marking every GlobalValue as either local/preemptable then introducing a 'default' enum value is undesirable. I can get the same behavior by treating one of the other enum values as a default in the interim. I picked the preemptable value to treat as 'unkown' for 2 reasons:

1. So I could use local to represent the case where we can't infer from a single compilation unit if a symbol will resolve local but do know at link time with lto Use the linker resolutions to mark global values as dso_local.
2. If we want to support an option similar to gcc '-fsemantic-interposition' then we essentially can't mark a symbol as local by default. We must consider a function as preemptable unless we know for sure it can't be interposed.

! In D20217#863605, @rnk wrote:

It seems like we could use the third state to preserve our existing behavior unless the frontend tells us otherwise.

I don't intend to change the default behavior to start considering runtime interposition, basically if we do add '-fsemantic-interposition' then it would default to off and let users who wanted full elf interpostion semantics to opt in.

I had replied to the commits list trying to get some feedback before updating the lang-ref but never got any replies. I'll go ahead and update it with what I currently have planned and hopefully that gets the discussion moving again.

[sfertile]

Add a section to the langref for preemption specifiers, and updated global variables and function sections.

[sfertile]

add preemption specifier to the alias entry in the LangRef and update the comments in LLParser to add PreemptionSpecifier.

[pcc]

Two states makes sense to me as well. From a bitcode upgrade perspective I think it would be valid to upgrade the current meaning of dso_preemptable to mean "always use the GOT" once that is implemented.

lib/AsmParser/LLParser.cpp

1639

Should this also be a verifier check?

lib/Bitcode/Reader/BitcodeReader.cpp

3061

Nit: new code should probably go between lines 3055 and 3056.

lib/Bitcode/Writer/BitcodeWriter.cpp

1200

Please update docs/BitCodeFormat.rst.

[sfertile]

1. Updated the bitcode format document.
2. Added Verifier check for dso_local and dllimport storage class on same global value.
3. Updated the comments in BitcodeReader to match the current formats for GlobalVar/Function/GlobalIndirectSymbol.

[sfertile]

lib/AsmParser/LLParser.cpp

1639

Yes, added.

[sfertile]

ping.

[pcc]

Looks good, but since @rnk had comments about the two states he should also take a look.

[rnk]

In D20217#906852, @pcc wrote:

Looks good, but since @rnk had comments about the two states he should also take a look.

Peter's suggestion of how to handle backwards compatibility makes sense to me, so two states sounds good to me.

[nemanjai]

New keyword[s]? Seems it might be a nice addition to also add them to utils/vim/syntax/llvm.vim and friends if appropriate.

[sfertile]

In D20217#907788, @nemanjai wrote:

New keyword[s]? Seems it might be a nice addition to also add them to utils/vim/syntax/llvm.vim and friends if appropriate.

Good point. I'll have a look at those, and update in a subsequent patch.

docs/BitCodeFormat.rst

 The ``DEPLIB`` record (code 6) contains a variable number of values representing
 the bytes of a single dependent library name string, one of the libraries
 mentioned in a ``deplibs`` declaration.  There should be one ``DEPLIB`` record
 for each library name referenced.
 
 MODULE_CODE_GLOBALVAR Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[GLOBALVAR, strtab offset, strtab size, pointer type, isconst, initid, linkage, alignment, section, visibility, threadlocal, unnamed_addr, externally_initialized, dllstorageclass, comdat]``
+``[GLOBALVAR, strtab offset, strtab size, pointer type, isconst, initid, linkage, alignment, section, visibility, threadlocal, unnamed_addr, externally_initialized, dllstorageclass, comdat, attributes, preemptionspecifier]``
 
 The ``GLOBALVAR`` record (code 7) marks the declaration or definition of a
 global variable. The operand fields are:
 
 * *strtab offset*, *strtab size*: Specifies the name of the global variable.
   See `STRTAB_BLOCK Contents`_.
 
 * *pointer type*: The type index of the pointer type used to point to this

 * *dllstorageclass*: If present, an encoding of the DLL storage class of this variable:
 
   * ``default``: code 0
   * ``dllimport``: code 1
   * ``dllexport``: code 2
 
 * *comdat*: An encoding of the COMDAT of this function
 
+* *attributes*: If nonzero, the 1-based index into the table of AttributeLists.
+
+.. _bcpreemptionspecifier:
+
+* *preemptionspecifier*: If present, an encoding of the runtime preemption specifier of this variable:
+
+  * ``dso_preemptable``: code 0
+  * ``dso_local``: code 1
+
 .. _FUNCTION:
 
 MODULE_CODE_FUNCTION Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[FUNCTION, strtab offset, strtab size, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn]``
+``[FUNCTION, strtab offset, strtab size, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn, preemptionspecifier]``
 
 The ``FUNCTION`` record (code 8) marks the declaration or definition of a
 function. The operand fields are:
 
 * *strtab offset*, *strtab size*: Specifies the name of the function.
   See `STRTAB_BLOCK Contents`_.
 
 * *type*: The type index of the function type describing this function

 * *comdat*: An encoding of the COMDAT of this function
 
 * *prefixdata*: If non-zero, the value index of the prefix data for this function,
   plus 1.
 
 * *personalityfn*: If non-zero, the value index of the personality function for this function,
   plus 1.
 
+* *preemptionspecifier*: If present, an encoding of the :ref:`runtime preemption specifier<bcpreemptionspecifier>`  of this function.
+ 
 MODULE_CODE_ALIAS Record
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[ALIAS, strtab offset, strtab size, alias type, aliasee val#, linkage, visibility, dllstorageclass, threadlocal, unnamed_addr]``
+``[ALIAS, strtab offset, strtab size, alias type, aliasee val#, linkage, visibility, dllstorageclass, threadlocal, unnamed_addr, preemptionspecifier]``
 
 The ``ALIAS`` record (code 9) marks the definition of an alias. The operand
 fields are
 
 * *strtab offset*, *strtab size*: Specifies the name of the alias.
   See `STRTAB_BLOCK Contents`_.
 
 * *alias type*: The type index of the alias
 
 * *aliasee val#*: The value index of the aliased value
 
 * *linkage*: An encoding of the `linkage type`_ for this alias
 
 * *visibility*: If present, an encoding of the `visibility`_ of the alias
 
 * *dllstorageclass*: If present, an encoding of the
   :ref:`dllstorageclass<bcdllstorageclass>` of the alias
 
 * *threadlocal*: If present, an encoding of the
   :ref:`thread local property<bcthreadlocal>` of the alias
 
 * *unnamed_addr*: If present, an encoding of the
   :ref:`unnamed_addr<bcunnamedaddr>` attribute of this alias
 
+* *preemptionspecifier*: If present, an encoding of the :ref:`runtime preemption specifier<bcpreemptionspecifier>`  of this alias.
+
 .. _MODULE_CODE_GCNAME:
 
 MODULE_CODE_GCNAME Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``[GCNAME, ...string...]``
 
 The ``GCNAME`` record (code 11) contains a variable number of values

docs/LangRef.rst

 model is not supported, or if a better choice of model can be made.
 
 A model can also be specified in an alias, but then it only governs how
 the alias is accessed. It will not have any effect in the aliasee.
 
 For platforms without linker support of ELF TLS model, the -femulated-tls
 flag can be used to generate GCC compatible emulated TLS code.
 
+.. _runtime_preemption_model:
+
+Runtime Preemption Specifiers
+-----------------------------
+
+Global variables, functions and aliases may have an optional runtime preemption
+specifier. If a preemption specifier isn't given explicitly, then a
+symbol is assumed to be ``dso_preemptable``.
+
+``dso_preemptable``
+    Indicates that the function or variable may be replaced by a symbol from
+    outside the linkage unit at runtime.
+
+``dso_local``
+    The compiler may assume that a function or variable marked as ``dso_local``
+    will resolve to a symbol within the same linkage unit. Direct access will 
+    be generated even if the definition is not within this compilation unit.
+
 .. _namedtypes:
 
 Structure Types
 ---------------
 
 LLVM IR allows you to specify both "identified" and "literal" :ref:`structure
 types <t_struct>`. Literal types are uniqued structurally, but identified types
 are never uniqued. An :ref:`opaque structural type <t_opaque>` can also be used

 to have exactly that alignment. Targets and optimizers are not allowed
 to over-align the global if the global has an assigned section. In this
 case, the extra alignment could be observable: for example, code could
 assume that the globals are densely packed in their section and try to
 iterate over them as an array, alignment padding would break this
 iteration. The maximum alignment is ``1 << 29``.
 
 Globals can also have a :ref:`DLL storage class <dllstorageclass>`,
+an optional :ref:`runtime preemption specifier <runtime_preemption_model>`,
 an optional :ref:`global attributes <glattrs>` and
 an optional list of attached :ref:`metadata <metadata>`.
 
 Variables and aliases can have a
 :ref:`Thread Local Storage Model <tls_model>`.
 
 Syntax::
 
-      @<GlobalVarName> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
+      @<GlobalVarName> = [Linkage] [PreemptionSpecifier] [Visibility]
+                         [DLLStorageClass] [ThreadLocal]
                          [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
                          [ExternallyInitialized]
                          <global | constant> <Type> [<InitializerConstant>]
                          [, section "name"] [, comdat [($name)]]
                          [, align <Alignment>] (, !name !N)*
 
 For example, the following defines a global in a numbered address space
 with an initializer, section, and alignment:
.. code-block:: llvm
     @G = thread_local(initialexec) global i32 0, align 4
 
 .. _functionstructure:
 
 Functions
 ---------
 
 LLVM function definitions consist of the "``define``" keyword, an
-optional :ref:`linkage type <linkage>`, an optional :ref:`visibility
+optional :ref:`linkage type <linkage>`, an optional :ref:`runtime preemption
+specifier <runtime_preemption_model>`,  an optional :ref:`visibility
 style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function
 name, a (possibly empty) argument list (each with optional :ref:`parameter
 attributes <paramattrs>`), optional :ref:`function attributes <fnattrs>`,
 an optional section, an optional alignment,
 an optional :ref:`comdat <langref_comdats>`,

 If the ``unnamed_addr`` attribute is given, the address is known to not
 be significant and two identical functions can be merged.
 
 If the ``local_unnamed_addr`` attribute is given, the address is known to
 not be significant within the module.
 
 Syntax::
 
-    define [linkage] [visibility] [DLLStorageClass]
+    define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
            [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"]
            [comdat [($name)]] [align N] [gc] [prefix Constant]
            [prologue Constant] [personality Constant] (!name !N)* { ... }
 
 The argument list is a comma separated sequence of arguments where each
 argument is of the following form:

 
 Aliases, unlike function or variables, don't create any new data. They
 are just a new symbol and metadata for an existing position.
 
 Aliases have a name and an aliasee that is either a global value or a
 constant expression.
 
 Aliases may have an optional :ref:`linkage type <linkage>`, an optional
+:ref:`runtime preemption specifier <runtime_preemption_model>`, an optional
 :ref:`visibility style <visibility>`, an optional :ref:`DLL storage class
 <dllstorageclass>` and an optional :ref:`tls model <tls_model>`.
 
 Syntax::
 
-    @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
+    @<Name> = [Linkage] [PreemptionSpecifier] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
 
 The linkage must be one of ``private``, ``internal``, ``linkonce``, ``weak``,
 ``linkonce_odr``, ``weak_odr``, ``external``. Note that some system linkers
 might not correctly handle dropping a weak symbol that is aliased.
 
 Aliases that are not ``unnamed_addr`` are guaranteed to have the same address as
 the aliasee expression. ``unnamed_addr`` ones are only guaranteed to point
 to the same content.

include/llvm/IR/GlobalValue.h

public:
 
   /// @brief Storage classes of global values for PE targets.
   enum DLLStorageClassTypes {
     DefaultStorageClass   = 0,
     DLLImportStorageClass = 1, ///< Function to be imported from DLL
     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
   };
 
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
         ValueType(Ty), Linkage(Linkage), Visibility(DefaultVisibility),
         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IntID((Intrinsic::ID)0U), Parent(nullptr) {
+        HasLLVMReservedName(false), IsDSOLocal(false),
+        IntID((Intrinsic::ID)0U), Parent(nullptr) {
     setName(Name);
   }
 
   Type *ValueType;
 
-  static const unsigned GlobalValueSubClassDataBits = 18;
+  static const unsigned GlobalValueSubClassDataBits = 17;
 
   // All bitfields use unsigned as the underlying type so that MSVC will pack
   // them.
   unsigned Linkage : 4;       // The linkage of this global
   unsigned Visibility : 2;    // The visibility style of this global
   unsigned UnnamedAddrVal : 2; // This value's address is not significant
   unsigned DllStorageClass : 2; // DLL storage class
 
   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                             // the desired model?
 
   /// True if the function's name starts with "llvm.".  This corresponds to the
   /// value of Function::isIntrinsic(), which may be true even if
   /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
   unsigned HasLLVMReservedName : 1;
 
+  /// If true then there is a definition within the same linkage unit and that
+  /// definition cannot be runtime preempted.
+  unsigned IsDSOLocal : 1;
+
 private:
   friend class Constant;
 
   // Give subclasses access to what otherwise would be wasted padding.
-  // (18 + 4 + 2 + 2 + 2 + 3 + 1) == 32.
+  // (17 + 4 + 2 + 2 + 2 + 3 + 1 + 1) == 32.
   unsigned SubClassData : GlobalValueSubClassDataBits;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
   /// differently optimized variant of the same source level function at link
   /// time.
public:
   bool hasSection() const { return !getSection().empty(); }
   StringRef getSection() const;
 
   /// Global values are always pointers.
   PointerType *getType() const { return cast<PointerType>(User::getType()); }
 
   Type *getValueType() const { return ValueType; }
 
+  void setDSOLocal(bool Local) { IsDSOLocal = Local; }
+
+  bool isDSOLocal() const {
+    return IsDSOLocal;
+  }
+
   static LinkageTypes getLinkOnceLinkage(bool ODR) {
     return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
   }
   static LinkageTypes getWeakLinkage(bool ODR) {
     return ODR ? WeakODRLinkage : WeakAnyLinkage;
   }
 
   static bool isExternalLinkage(LinkageTypes Linkage) {
     return Linkage == ExternalLinkage;
   }
   static bool isAvailableExternallyLinkage(LinkageTypes Linkage) {
     return Linkage == AvailableExternallyLinkage;
   }
   static bool isLinkOnceODRLinkage(LinkageTypes Linkage) {
     return Linkage == LinkOnceODRLinkage;
   }
   static bool isLinkOnceLinkage(LinkageTypes Linkage) {
     return Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage;
   }
   static bool isWeakAnyLinkage(LinkageTypes Linkage) {
     return Linkage == WeakAnyLinkage;
   }
   static bool isWeakODRLinkage(LinkageTypes Linkage) {
     return Linkage == WeakODRLinkage;
   }

lib/AsmParser/LLLexer.cpp

do {                                                                         \
     if (Keyword == #STR)                                                       \
       return lltok::kw_##STR;                                                  \
   } while (false)
 
   KEYWORD(true);    KEYWORD(false);
   KEYWORD(declare); KEYWORD(define);
   KEYWORD(global);  KEYWORD(constant);
 
+  KEYWORD(dso_local);
+  KEYWORD(dso_preemptable);
+
   KEYWORD(private);
   KEYWORD(internal);
   KEYWORD(available_externally);
   KEYWORD(linkonce);
   KEYWORD(linkonce_odr);
   KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
   KEYWORD(weak_odr);
   KEYWORD(appending);
   KEYWORD(dllimport);
   KEYWORD(dllexport);
   KEYWORD(common);

lib/AsmParser/LLParser.h

private:
 
     bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
     bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
     bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     bool ParseOptionalAddrSpace(unsigned &AddrSpace);
     bool ParseOptionalParamAttrs(AttrBuilder &B);
     bool ParseOptionalReturnAttrs(AttrBuilder &B);
     bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage,
-                              unsigned &Visibility, unsigned &DLLStorageClass);
+                              unsigned &Visibility, unsigned &DLLStorageClass,
+                              bool &DSOLocal);
+    void ParseOptionalDSOLocal(bool &DSOLocal);
     void ParseOptionalVisibility(unsigned &Visibility);
     void ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
     bool ParseOptionalCallingConv(unsigned &CC);
     bool ParseOptionalAlignment(unsigned &Alignment);
     bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     bool ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
                                AtomicOrdering &Ordering);
     bool ParseScope(SyncScope::ID &SSID);
private:
     bool ParseDeclare();
     bool ParseDefine();
 
     bool ParseGlobalType(bool &IsConstant);
     bool ParseUnnamedGlobal();
     bool ParseNamedGlobal();
     bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
                      bool HasLinkage, unsigned Visibility,
-                     unsigned DLLStorageClass,
+                     unsigned DLLStorageClass, bool DSOLocal,
                      GlobalVariable::ThreadLocalMode TLM,
                      GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
                              unsigned Linkage, unsigned Visibility,
-                             unsigned DLLStorageClass,
+                             unsigned DLLStorageClass, bool DSOLocal,
                              GlobalVariable::ThreadLocalMode TLM,
                              GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseUnnamedAttrGrp();

lib/AsmParser/LLParser.cpp

else if (EatIfPresent(lltok::kw_local_unnamed_addr))
     UnnamedAddr = GlobalValue::UnnamedAddr::Local;
   else
     UnnamedAddr = GlobalValue::UnnamedAddr::None;
   return false;
 }
 
 /// ParseUnnamedGlobal:
 ///   OptionalVisibility (ALIAS | IFUNC) ...
-///   OptionalLinkage OptionalVisibility OptionalDLLStorageClass
+///   OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
+///   OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 ///   GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
-///   GlobalID '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
+///   GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
+///                OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseUnnamedGlobal() {
   unsigned VarID = NumberedVals.size();
   std::string Name;
   LocTy NameLoc = Lex.getLoc();
 
   // Handle the GlobalID form.
   if (Lex.getKind() == lltok::GlobalID) {
     if (Lex.getUIntVal() != VarID)
       return Error(Lex.getLoc(), "variable expected to be numbered '%" +
                    Twine(VarID) + "'");
     Lex.Lex(); // eat GlobalID;
 
     if (ParseToken(lltok::equal, "expected '=' after name"))
       return true;
   }
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
+  bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+                           DSOLocal) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
 /// ParseNamedGlobal:
 ///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
-///   GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
+///   GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
+///                 OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseNamedGlobal() {
   assert(Lex.getKind() == lltok::GlobalVar);
   LocTy NameLoc = Lex.getLoc();
   std::string Name = Lex.getStrVal();
   Lex.Lex();
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
+  bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
-      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+                           DSOLocal) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
 bool LLParser::parseComdat() {
   assert(Lex.getKind() == lltok::ComdatVar);
   std::string Name = Lex.getStrVal();
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();
 

 }
 
 static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
   return !GlobalValue::isLocalLinkage((GlobalValue::LinkageTypes)L) ||
          (GlobalValue::VisibilityTypes)V == GlobalValue::DefaultVisibility;
 }
 
 /// parseIndirectSymbol:
-///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility
-///                     OptionalDLLStorageClass OptionalThreadLocal
-///                     OptionalUnnamedAddr 'alias|ifunc' IndirectSymbol
+///   ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier 
+///                     OptionalVisibility OptionalDLLStorageClass
+///                     OptionalThreadLocal OptionalUnnamedAddr
+//                      'alias|ifunc' IndirectSymbol
 ///
 /// IndirectSymbol
 ///   ::= TypeAndValue
 ///
 /// Everything through OptionalUnnamedAddr has already been parsed.
 ///
-bool LLParser::parseIndirectSymbol(
-    const std::string &Name, LocTy NameLoc, unsigned L, unsigned Visibility,
-    unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM,
+bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
+                                   unsigned L, unsigned Visibility,
+                                   unsigned DLLStorageClass, bool DSOLocal,
+                                   GlobalVariable::ThreadLocalMode TLM,
                                    GlobalVariable::UnnamedAddr UnnamedAddr) {
   bool IsAlias;
   if (Lex.getKind() == lltok::kw_alias)
     IsAlias = true;
   else if (Lex.getKind() == lltok::kw_ifunc)
     IsAlias = false;
   else
     llvm_unreachable("Not an alias or ifunc!");
   Lex.Lex();
 
   GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
 
   if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
     return Error(NameLoc, "invalid linkage type for alias");
 
   if (!isValidVisibilityForLinkage(Visibility, L))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
+  if (DSOLocal && !IsAlias) {
+    return Error(NameLoc,
+                 "dso_local is invalid on ifunc");
+  }
+
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
   if (ParseType(Ty) ||
       ParseToken(lltok::comma, "expected comma after alias or ifunc's type"))
     return true;
 
   Constant *Aliasee;
   LocTy AliaseeLoc = Lex.getLoc();
bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   else
     GA.reset(GlobalIFunc::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GA->setUnnamedAddr(UnnamedAddr);
+  GA->setDSOLocal(DSOLocal);
 
   if (Name.empty())
     NumberedVals.push_back(GA.get());
 
   if (GVal) {
     // Verify that types agree.
     if (GVal->getType() != GA->getType())
       return Error(
bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
 
   // The module owns this now
   GA.release();
 
   return false;
 }
 
 /// ParseGlobal
-///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
-///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
-///       OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
-///   ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
+///   ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
+///       OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
 ///       OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
+///   ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
+///       OptionalDLLStorageClass OptionalThreadLocal OptionalUnnamedAddr
+///       OptionalAddrSpace OptionalExternallyInitialized GlobalType Type
+///       Const OptionalAttrs
 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
                            unsigned Linkage, bool HasLinkage,
                            unsigned Visibility, unsigned DLLStorageClass,
-                           GlobalVariable::ThreadLocalMode TLM,
+                           bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
                            GlobalVariable::UnnamedAddr UnnamedAddr) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
   bool IsConstant, IsExternallyInitialized;
   LocTy IsExternallyInitializedLoc;
bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
   if (Name.empty())
     NumberedVals.push_back(GV);
 
   // Set the parsed properties on the global.
   if (Init)
     GV->setInitializer(Init);
   GV->setConstant(IsConstant);
   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
+  GV->setDSOLocal(DSOLocal);
   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GV->setExternallyInitialized(IsExternallyInitialized);
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
 
   // Parse attributes on the global.
   while (Lex.getKind() == lltok::comma) {

 ///   ::= 'linkonce_odr'
 ///   ::= 'available_externally'
 ///   ::= 'appending'
 ///   ::= 'common'
 ///   ::= 'extern_weak'
 ///   ::= 'external'
 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                                     unsigned &Visibility,
-                                    unsigned &DLLStorageClass) {
+                                    unsigned &DLLStorageClass,
+                                    bool &DSOLocal) {
   Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
   if (HasLinkage)
     Lex.Lex();
+  ParseOptionalDSOLocal(DSOLocal);
   ParseOptionalVisibility(Visibility);
   ParseOptionalDLLStorageClass(DLLStorageClass);
+
+  if (DSOLocal && DLLStorageClass == GlobalValue::DLLImportStorageClass) {
+    return Error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch");
+  }
+
   return false;
 }
 
+void LLParser::ParseOptionalDSOLocal(bool &DSOLocal) {
+  switch (Lex.getKind()) {
+  default:
+    DSOLocal = false;
+    break;
+  case lltok::kw_dso_local:
+    DSOLocal = true;
+    Lex.Lex();
+    break;
+  case lltok::kw_dso_preemptable:
+    DSOLocal = false;
+    Lex.Lex();
+    break;
+  }
+}
+
 /// ParseOptionalVisibility
 ///   ::= /*empty*/
 ///   ::= 'default'
 ///   ::= 'hidden'
 ///   ::= 'protected'
 ///
 void LLParser::ParseOptionalVisibility(unsigned &Res) {
   switch (Lex.getKind()) {
bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
   if (ParseTypeAndValue(V, PFS)) return true;
   if (!isa<BasicBlock>(V))
     return Error(Loc, "expected a basic block");
   BB = cast<BasicBlock>(V);
   return false;
 }
 
 /// FunctionHeader
-///   ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
-///       OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
-///       OptionalAlign OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
+///   ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
+///       OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
+///       '(' ArgList ')' OptFuncAttrs OptSection OptionalAlign OptGC
+///       OptionalPrefix OptionalPrologue OptPersonalityFn
 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   // Parse the linkage.
   LocTy LinkageLoc = Lex.getLoc();
   unsigned Linkage;
-
   unsigned Visibility;
   unsigned DLLStorageClass;
+  bool DSOLocal;
   AttrBuilder RetAttrs;
   unsigned CC;
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+                           DSOLocal) ||
       ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/))
     return true;
 
   // Verify that the linkage is ok.
   switch ((GlobalValue::LinkageTypes)Linkage) {
   case GlobalValue::ExternalLinkage:
     break; // always ok.
if (!Fn)
     Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
   else // Move the forward-reference to the correct spot in the module.
     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
 
   if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
+  Fn->setDSOLocal(DSOLocal);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
   Fn->setComdat(C);

lib/AsmParser/LLToken.h

enum Kind {
   kw_x,
   kw_true,
   kw_false,
   kw_declare,
   kw_define,
   kw_global,
   kw_constant,
 
+  kw_dso_local,
+  kw_dso_preemptable,
+
   kw_private,
   kw_internal,
   kw_linkonce,
   kw_linkonce_odr,
   kw_weak, // Used as a linkage, and a modifier for "cmpxchg".
   kw_weak_odr,
   kw_appending,
   kw_dllimport,

lib/Bitcode/Reader/BitcodeReader.cpp

getDecodedDLLStorageClass(unsigned Val) {
   switch (Val) {
   default: // Map unknown values to default.
   case 0: return GlobalValue::DefaultStorageClass;
   case 1: return GlobalValue::DLLImportStorageClass;
   case 2: return GlobalValue::DLLExportStorageClass;
   }
 }
 
+static bool getDecodedDSOLocal(unsigned Val) {
+  switch(Val) {
+  default: // Map unknown values to preemptable.
+  case 0:  return false;
+  case 1:  return true;
+  }
+}
+
 static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {
   switch (Val) {
     case 0: return GlobalVariable::NotThreadLocal;
     default: // Map unknown non-zero value to general dynamic.
     case 1: return GlobalVariable::GeneralDynamicTLSModel;
     case 2: return GlobalVariable::LocalDynamicTLSModel;
     case 3: return GlobalVariable::InitialExecTLSModel;
     case 4: return GlobalVariable::LocalExecTLSModel;
   }
 }
 
 static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) {
   switch (Val) {
     default: // Map unknown to UnnamedAddr::None.
     case 0: return GlobalVariable::UnnamedAddr::None;
     case 1: return GlobalVariable::UnnamedAddr::Global;
     case 2: return GlobalVariable::UnnamedAddr::Local;
   }
 }
 
 static int getDecodedCastOpcode(unsigned Val) {
   switch (Val) {
   default: return -1;
   case bitc::CAST_TRUNC   : return Instruction::Trunc;
   case bitc::CAST_ZEXT    : return Instruction::ZExt;
   case bitc::CAST_SEXT    : return Instruction::SExt;
   case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
   case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
   case bitc::CAST_UITOFP  : return Instruction::UIToFP;
Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) {
   C->setSelectionKind(SK);
   ComdatList.push_back(C);
   return Error::success();
 }
 
 Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
   // v1: [pointer type, isconst, initid, linkage, alignment, section,
   // visibility, threadlocal, unnamed_addr, externally_initialized,
-  // dllstorageclass, comdat, attributes] (name in VST)
+  // dllstorageclass, comdat, attributes, preemption specifier] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   if (Record.size() < 6)
     return error("Invalid record");
   Type *Ty = getTypeByID(Record[0]);
   if (!Ty)
Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
   } else if (hasImplicitComdat(RawLinkage)) {
     NewGV->setComdat(reinterpret_cast<Comdat *>(1));
   }
 
   if (Record.size() > 12) {
     auto AS = getAttributes(Record[12]).getFnAttributes();
     NewGV->setAttributes(AS);
   }
+
+  if (Record.size() > 13) {
+    NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
+  }
+
   return Error::success();
 }
 
 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
   // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
-  // prefixdata] (name in VST)
+  // prefixdata,  personalityfn, preemption specifier] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   if (Record.size() < 8)
     return error("Invalid record");
   Type *Ty = getTypeByID(Record[0]);
   if (!Ty)
Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   }
 
   if (Record.size() > 13 && Record[13] != 0)
     FunctionPrefixes.push_back(std::make_pair(Func, Record[13] - 1));
 
   if (Record.size() > 14 && Record[14] != 0)
     FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
 
+  if (Record.size() > 15) {
+    Func->setDSOLocal(getDecodedDSOLocal(Record[15]));
+  }
+
   ValueList.push_back(Func);
 
   // If this is a function with a body, remember the prototype we are
   // creating now, so that we can match up the body with them later.
   if (!isProto) {
     Func->setIsMaterializable(true);
     FunctionsWithBodies.push_back(Func);
     DeferredFunctionInfo[Func] = 0;
   }
   return Error::success();
 }
 
 Error BitcodeReader::parseGlobalIndirectSymbolRecord(
     unsigned BitCode, ArrayRef<uint64_t> Record) {
   // v1 ALIAS_OLD: [alias type, aliasee val#, linkage] (name in VST)
   // v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility,
-  // dllstorageclass] (name in VST)
+  // dllstorageclass, threadlocal, unnamed_addr,
+  // preemption specifier] (name in VST)
   // v1 IFUNC: [alias type, addrspace, aliasee val#, linkage,
-  // visibility, dllstorageclass] (name in VST)
+  // visibility, dllstorageclass, threadlocal, unnamed_addr,
+  // preemption specifier] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   bool NewRecord = BitCode != bitc::MODULE_CODE_ALIAS_OLD;
   if (Record.size() < (3 + (unsigned)NewRecord))
     return error("Invalid record");
   unsigned OpNum = 0;
Error BitcodeReader::parseGlobalIndirectSymbolRecord(
   if (OpNum != Record.size())
     NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
   else
     upgradeDLLImportExportLinkage(NewGA, Linkage);
   if (OpNum != Record.size())
     NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
   if (OpNum != Record.size())
     NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
+  if (OpNum != Record.size())
+    NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));
   ValueList.push_back(NewGA);
   IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
   return Error::success();
 }
 
 Error BitcodeReader::parseModule(uint64_t ResumeBit,
                                  bool ShouldLazyLoadMetadata) {
   if (ResumeBit)
     Stream.JumpToBit(ResumeBit);
   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeModuleInfo() {
 
   // Emit the global variable information.
   for (const GlobalVariable &GV : M.globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat, attributes]
+    //             comdat, attributes, DSO_Local]
     Vals.push_back(addToStrtab(GV.getName()));
     Vals.push_back(GV.getName().size());
     Vals.push_back(VE.getTypeID(GV.getValueType()));
     Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
         GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
         GV.hasComdat() ||
-        GV.hasAttributes()) {
+        GV.hasAttributes() ||
+        GV.isDSOLocal()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(getEncodedUnnamedAddr(GV));
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
 
       auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);
       Vals.push_back(VE.getAttributeListID(AL));
+
+      Vals.push_back(GV.isDSOLocal());
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the function proto information.
   for (const Function &F : M) {
     // FUNCTION:  [strtab offset, strtab size, type, callingconv, isproto,
     //             linkage, paramattrs, alignment, section, visibility, gc,
     //             unnamed_addr, prologuedata, dllstorageclass, comdat,
-    //             prefixdata, personalityfn]
+    //             prefixdata, personalityfn, DSO_Local]
     Vals.push_back(addToStrtab(F.getName()));
     Vals.push_back(F.getName().size());
     Vals.push_back(VE.getTypeID(F.getFunctionType()));
     Vals.push_back(F.getCallingConv());
     Vals.push_back(F.isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
     Vals.push_back(VE.getAttributeListID(F.getAttributes()));
     Vals.push_back(Log2_32(F.getAlignment())+1);
     Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
     Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
     Vals.push_back(getEncodedUnnamedAddr(F));
     Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
                                        : 0);
     Vals.push_back(getEncodedDLLStorageClass(F));
     Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
     Vals.push_back(
         F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
 
+    Vals.push_back(F.isDSOLocal());
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M.aliases()) {
     // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,
-    //         visibility, dllstorageclass, threadlocal, unnamed_addr]
+    //         visibility, dllstorageclass, threadlocal, unnamed_addr,
+    //         DSO_Local]
     Vals.push_back(addToStrtab(A.getName()));
     Vals.push_back(A.getName().size());
     Vals.push_back(VE.getTypeID(A.getValueType()));
     Vals.push_back(A.getType()->getAddressSpace());
     Vals.push_back(VE.getValueID(A.getAliasee()));
     Vals.push_back(getEncodedLinkage(A));
     Vals.push_back(getEncodedVisibility(A));
     Vals.push_back(getEncodedDLLStorageClass(A));
     Vals.push_back(getEncodedThreadLocalMode(A));
     Vals.push_back(getEncodedUnnamedAddr(A));
+    Vals.push_back(A.isDSOLocal());
+
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the ifunc information.
   for (const GlobalIFunc &I : M.ifuncs()) {
     // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver

lib/IR/AsmWriter.cpp

static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
                             formatted_raw_ostream &Out) {
   switch (Vis) {
   case GlobalValue::DefaultVisibility: break;
   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
   }
 }
 
+static void PrintDSOLocation(bool IsDSOLocal, formatted_raw_ostream &Out){
+  if (IsDSOLocal)
+    Out << "dso_local ";
+}
+
 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
                                  formatted_raw_ostream &Out) {
   switch (SCT) {
   case GlobalValue::DefaultStorageClass: break;
   case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
   case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
   }
 }
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
 
   WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
   Out << " = ";
 
   if (!GV->hasInitializer() && GV->hasExternalLinkage())
     Out << "external ";
 
   Out << getLinkagePrintName(GV->getLinkage());
+  PrintDSOLocation(GV->isDSOLocal(), Out);
   PrintVisibility(GV->getVisibility(), Out);
   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
   StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
   if (!UA.empty())
       Out << UA << ' ';
 
   if (unsigned AddressSpace = GV->getType()->getAddressSpace())

 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
   if (GIS->isMaterializable())
     Out << "; Materializable\n";
 
   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
   Out << " = ";
 
   Out << getLinkagePrintName(GIS->getLinkage());
+  PrintDSOLocation(GIS->isDSOLocal(), Out);
   PrintVisibility(GIS->getVisibility(), Out);
   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
   StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
   if (!UA.empty())
       Out << UA << ' ';
 
   if (isa<GlobalAlias>(GIS))
if (F->isDeclaration()) {
     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
     F->getAllMetadata(MDs);
     printMetadataAttachments(MDs, " ");
     Out << ' ';
   } else
     Out << "define ";
 
   Out << getLinkagePrintName(F->getLinkage());
+  PrintDSOLocation(F->isDSOLocal(), Out);
   PrintVisibility(F->getVisibility(), Out);
   PrintDLLStorageClass(F->getDLLStorageClass(), Out);
 
   // Print the calling convention.
   if (F->getCallingConv() != CallingConv::C) {
     PrintCallingConv(F->getCallingConv(), Out);
     Out << " ";
   }

lib/IR/Globals.cpp

 // GlobalValue while adding flags.
 static_assert(sizeof(GlobalValue) ==
                   sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
               "unexpected GlobalValue size growth");
 
 // GlobalObject adds a comdat.
 static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
               "unexpected GlobalObject size growth");
 
 bool GlobalValue::isMaterializable() const {
   if (const Function *F = dyn_cast<Function>(this))
     return F->isMaterializable();
   return false;
 }
 Error GlobalValue::materialize() {
   return getParent()->materialize(this);
 }
 
 /// Override destroyConstantImpl to make sure it doesn't get called on
 /// GlobalValue's because they shouldn't be treated like other constants.
 void GlobalValue::destroyConstantImpl() {
   llvm_unreachable("You can't GV->destroyConstantImpl()!");
 }
 
 Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
   llvm_unreachable("Unsupported class for handleOperandChange()!");
 }
 
 /// copyAttributesFrom - copy all additional attributes (those not needed to
 /// create a GlobalValue) from the GlobalValue Src to this one.
 void GlobalValue::copyAttributesFrom(const GlobalValue *Src) {
   setVisibility(Src->getVisibility());
   setUnnamedAddr(Src->getUnnamedAddr());
   setDLLStorageClass(Src->getDLLStorageClass());
+  setDSOLocal(Src->isDSOLocal());
 }
 
 void GlobalValue::removeFromParent() {
   switch (getValueID()) {
 #define HANDLE_GLOBAL_VALUE(NAME)                                              \
   case Value::NAME##Val:                                                       \
     return static_cast<NAME *>(this)->removeFromParent();
 #include "llvm/IR/Value.def"

lib/IR/Verifier.cpp

if (GV.hasAppendingLinkage()) {
     const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
     Assert(GVar && GVar->getValueType()->isArrayTy(),
            "Only global arrays can have appending linkage!", GVar);
   }
 
   if (GV.isDeclarationForLinker())
     Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
 
+  if (GV.hasDLLImportStorageClass())
+    Assert(!GV.isDSOLocal(),
+           "GlobalValue with DLLImport Storage is dso_local!", &GV);
+
   forEachUser(&GV, GlobalValueVisited, [&](const Value *V) -> bool {
     if (const Instruction *I = dyn_cast<Instruction>(V)) {
       if (!I->getParent() || !I->getParent()->getParent())
         CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
                     I);
       else if (I->getParent()->getParent()->getParent() != &M)
         CheckFailed("Global is referenced in a different module!", &GV, &M, I,
                     I->getParent()->getParent(),

lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
 
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmwares builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 
-  if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
+  if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility() ||
+              GV->isDSOLocal()))
     return true;
 
   if (TT.isOSBinFormatMachO()) {
     if (RM == Reloc::Static)
       return true;
     return GV && GV->isStrongDefinitionForLinker();
   }
 

test/Assembler/dllimport-dsolocal-diag.ll

+; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+
+declare dso_local dllimport void @fun()
+; CHECK: error: dso_location and DLL-StorageClass mismatch

test/Assembler/ifunc-dsolocal-daig.ll

+; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+
+@foo = dso_local ifunc i32 (i32), i64 ()* @foo_ifunc
+; CHECK: error: dso_local is invalid on ifunc
+
+define internal i64 @foo_ifunc() {
+entry:
+  ret i64 0
+}

test/Bitcode/dso_location.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; Tests parsing for the dso_local keyword as well as the serialization/
+; deserialization of the dso_local value on GlobalValues.
+
+@local_global = dso_local global i32 0
+; CHECK: @local_global = dso_local global i32 0
+
+@weak_local_global = weak dso_local global i32 0
+; CHECK: @weak_local_global = weak dso_local global i32 0
+
+@external_local_global = external dso_local global i32
+; CHECK: @external_local_global = external dso_local global i32
+
+@default_local_global = dso_local default global i32 0
+; CHECK: @default_local_global = dso_local global i32 0
+
+@hidden_local_global = dso_local hidden global i32 0
+; CHECK: @hidden_local_global = dso_local hidden global i32 0
+
+@protected_local_global = dso_local protected global i32 0
+; CHECK: @protected_local_global = dso_local protected global i32 0
+
+@local_alias = dso_local alias i32, i32* @local_global
+; CHECK-DAG: @local_alias = dso_local alias i32, i32* @local_global
+
+@preemptable_alias = dso_preemptable alias i32, i32* @hidden_local_global
+; CHECK-DAG: @preemptable_alias = alias i32, i32* @hidden_local_global
+
+@preemptable_ifunc = dso_preemptable ifunc void (), i8* ()* @ifunc_resolver
+; CHECK-DAG: @preemptable_ifunc = ifunc void (), i8* ()* @ifunc_resolver
+declare dso_local default void @default_local()
+; CHECK: declare dso_local void @default_local()
+
+declare dso_local hidden void @hidden_local()
+; CHECK: declare dso_local hidden void @hidden_local()
+
+define dso_local protected void @protected_local() {
+; CHECK: define dso_local protected void @protected_local()
+entry:
+  ret void
+}
+
+define i8* @ifunc_resolver() {
+entry:
+  ret i8* null
+}

test/CodeGen/PowerPC/preemption.ll

+; RUN: llc -mtriple powerpc64le-unkown-gnu-linux  < %s |  FileCheck %s
+; RUN: llc -mtriple powerpc64le-unkown-gnu-linux -relocation-model=static \
+; RUN: < %s |  FileCheck --check-prefix=STATIC %s
+; RUN: llc -mtriple powerpc64le-unkown-gnu-linux -relocation-model=pic \
+; RUN: < %s |  FileCheck %s
+
+; globals
+
+@strong_default = global i32 55
+define i32* @get_strong_default() #0 {
+  ret i32* @strong_default
+
+; STATIC-LABEL: @get_strong_default
+; STATIC: addis 3, 2, strong_default@toc@ha
+; STATIC: addi 3, 3, strong_default@toc@l
+; STATIC: blr
+
+; CHECK-LABEL: @get_strong_default
+; CHECK: addis 3, 2, .LC0@toc@ha
+; CHECK: ld 3, .LC0@toc@l(3)
+; CHECK: blr
+}
+
+@weak_default = weak global i32 55
+define i32* @get_weak_default() #0 {
+  ret i32* @weak_default
+
+; STATIC-LABEL: @get_weak_default
+; STATIC: addis 3, 2, weak_default@toc@ha
+; STATIC: addi 3, 3, weak_default@toc@l
+; STATIC: blr
+
+; CHECK-LABEL: @get_weak_default
+; CHECK: addis 3, 2, .LC1@toc@ha
+; CHECK: ld 3, .LC1@toc@l(3)
+; CHECK: blr
+}
+
+@external_default_global = external global i32
+define i32* @get_external_default_global() {
+  ret i32* @external_default_global
+
+; STATIC-LABEL: @get_external_default_global
+; STATIC: addis 3, 2, .LC0@toc@ha
+; STATIC: ld 3, .LC0@toc@l(3)
+; STATIC: blr
+
+; CHECK-LABEL: @get_external_default_global
+; CHECK: addis 3, 2, .LC2@toc@ha
+; CHECK: ld 3, .LC2@toc@l(3)
+; CHECK: blr
+}
+
+
+@strong_local_global = dso_local global i32 55
+define i32* @get_strong_local_global() {
+  ret i32* @strong_local_global
+
+; STATIC-LABEL: @get_strong_local_global
+; STATIC:       addis 3, 2, strong_local_global@toc@ha
+; STATIC:       addi 3, 3, strong_local_global@toc@l
+; STATIC:       blr
+
+; CHECK-LABEL: @get_strong_local_global
+; CHECK:       addis 3, 2, strong_local_global@toc@ha
+; CHECK:       addi 3, 3, strong_local_global@toc@l
+; CHECK:       blr
+}
+
+@weak_local_global = weak dso_local global i32 42
+define i32* @get_weak_local_global() {
+  ret i32* @weak_local_global
+
+; STATIC-LABEL: @get_weak_local_global
+; STATIC:       addis 3, 2, weak_local_global@toc@ha
+; STATIC:       addi 3, 3, weak_local_global@toc@l
+; STATIC:       blr
+
+; CHECK-LABEL: @get_weak_local_global
+; CHECK:       addis 3, 2, weak_local_global@toc@ha
+; CHECK:       addi 3, 3, weak_local_global@toc@l
+; CHECK:       blr
+}
+
+@external_local_global = external dso_local global i32
+define i32* @get_external_local_global() {
+  ret i32* @external_local_global
+; STATIC-LABEL: @get_external_local_global
+; STATIC:       addis 3, 2, external_local_global@toc@ha
+; STATIC:       addi 3, 3, external_local_global@toc@l
+; STATIC:       blr
+
+; CHECK-LABEL: @get_external_local_global
+; CHECK:       addis 3, 2, external_local_global@toc@ha
+; CHECK:       addi 3, 3, external_local_global@toc@l
+; CHECK:       blr
+}
+
+@strong_preemptable_global = dso_preemptable global i32 42
+define i32* @get_strong_preemptable_global() {
+  ret i32* @strong_preemptable_global
+
+; STATIC-LABEL: @get_strong_preemptable_global
+; STATIC: addis 3, 2, strong_preemptable_global@toc@ha
+; STATIC: addi 3, 3, strong_preemptable_global@toc@l
+; STATIC: blr
+
+; CHECK-LABEL: @get_strong_preemptable_global
+; CHECK: addis 3, 2, .LC3@toc@ha
+; CHECK: ld 3, .LC3@toc@l(3)
+; CHECK: blr
+}
+
+@weak_preemptable_global = weak dso_preemptable global i32 42
+define i32* @get_weak_preemptable_global() {
+  ret i32* @weak_preemptable_global
+
+; STATIC-LABEL: @get_weak_preemptable_global
+; STATIC: addis 3, 2, weak_preemptable_global@toc@ha
+; STATIC: addi 3, 3, weak_preemptable_global@toc@l
+; STATIC: blr
+
+; CHECK-LABEL: @get_weak_preemptable_global
+; CHECK: addis 3, 2, .LC4@toc@ha
+; CHECK: ld 3, .LC4@toc@l(3)
+; CHECK: blr
+}
+
+@external_preemptable_global = external dso_preemptable global i32
+define i32* @get_external_preemptable_global() {
+  ret i32* @external_preemptable_global
+
+; STATIC-LABEL: @get_external_preemptable_global
+; STATIC: addis 3, 2, .LC1@toc@ha
+; STATIC: ld 3, .LC1@toc@l(3)
+; STATIC: blr
+
+; CHECK-LABEL: @get_external_preemptable_global
+; CHECK: addis 3, 2, .LC5@toc@ha
+; CHECK: ld 3, .LC5@toc@l(3)
+; CHECK: blr
+}
+
+; functions
+define signext i32 @strong_default_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @strong_default_function_caller(i32 %i) {
+  %call = notail call signext i32 @strong_default_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @strong_default_function_caller
+; STATIC:       bl strong_default_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @strong_default_function_caller
+; CHECK:        bl strong_default_function
+; CHECK-NEXT:   nop
+; CHECK:        blr
+}
+
+define weak signext i32 @weak_default_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @weak_default_function_caller(i32 %i) {
+  %call = notail call signext i32 @weak_default_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @weak_default_function_caller
+; STATIC:       bl weak_default_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @weak_default_function_caller
+; CHECK:        bl weak_default_function
+; CHECK-NEXT:   nop
+; CHECK:        blr
+}
+
+
+declare i32 @external_default_function(i32 %i)
+define i32 @external_default_function_caller(i32 %i) {
+  %call = notail call signext i32  @external_default_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @external_default_function_caller
+; STATIC:       bl external_default_function
+; STATIC-NEXT:  nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @external_default_function_caller
+; CHECK:        bl external_default_function
+; CHECK-NEXT:   nop
+; CHECK:        blr
+}
+
+define dso_local signext i32 @strong_local_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @strong_local_function_caller(i32 %i) {
+  %call = notail call signext i32 @strong_local_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @strong_local_function_caller
+; STATIC:       bl strong_local_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @strong_local_function_caller
+; CHECK:        bl strong_local_function
+; CHECK-NOT:    nop
+; CHECK:        blr
+}
+
+define weak dso_local signext i32 @weak_local_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @weak_local_function_caller(i32 %i) {
+  %call = notail call signext i32 @weak_local_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @weak_local_function_caller
+; STATIC:       bl weak_local_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @weak_local_function_caller
+; CHECK:        bl weak_local_function
+; CHECK-NOT:    nop
+; CHECK:        blr
+}
+
+declare dso_local i32 @external_local_function(i32 %i)
+define i32 @external_local_function_caller(i32 %i) {
+  %call = notail call signext i32  @external_local_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @external_local_function_caller
+; STATIC:       bl external_local_function
+; STATIC-NOT:  nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @external_local_function_caller
+; CHECK:        bl external_local_function
+; CHECK-NOT:    nop
+; CHECK:        blr
+}
+
+define dso_preemptable signext i32 @strong_preemptable_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @strong_preemptable_function_caller(i32 %i) {
+  %call = notail call signext i32 @strong_preemptable_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @strong_preemptable_function_caller
+; STATIC:       bl strong_preemptable_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @strong_preemptable_function_caller
+; CHECK:        bl strong_preemptable_function
+; CHECK-NEXT:   nop
+; CHECK:        blr
+}
+
+define weak dso_preemptable signext i32 @weak_preemptable_function(i32 %i) {
+  ret i32 %i
+}
+define signext i32 @weak_preemptable_function_caller(i32 %i) {
+  %call = notail call signext i32 @weak_preemptable_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @weak_preemptable_function_caller
+; STATIC:       bl weak_preemptable_function
+; STATIC-NOT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @weak_preemptable_function_caller
+; CHECK:        bl weak_preemptable_function
+; CHECK-NEXT:   nop
+; CHECK:        blr
+}
+
+declare dso_preemptable i32 @external_preemptable_function(i32 %i)
+define i32 @external_preemptable_function_caller(i32 %i) {
+  %call = notail call signext i32  @external_preemptable_function(i32 signext %i)
+  ret i32 %call
+
+; STATIC-LABEL: @external_preemptable_function_caller
+; STATIC:       bl external_preemptable_function
+; STATIC-NEXT:   nop
+; STATIC:       blr
+
+; CHECK-LABEL:  @external_preemptable_function_caller
+; CHECK:        bl external_preemptable_function
+; CHECK-NEXT:    nop
+; CHECK:        blr
+}
+

test/CodeGen/X86/darwin-preemption.ll

+; RUN: llc -mtriple x86_64-apple-darwin \
+; RUN:     -relocation-model=static          < %s | FileCheck %s
+; RUN: llc -mtriple x86_64-apple-darwin \
+; RUN:     -relocation-model=pic             < %s | FileCheck %s
+; RUN: llc -mtriple x86_64-apple-darwin \
+; RUN:     -relocation-model=dynamic-no-pic  < %s | FileCheck %s
+
+; 32 bits
+
+; RUN: llc -mtriple i386-apple-darwin \
+; RUN:    -relocation-model=static < %s | FileCheck --check-prefix=DARWIN32_S %s
+; RUN: llc -mtriple i386-apple-darwin \
+; RUN:     -relocation-model=pic     < %s | FileCheck --check-prefix=DARWIN32 %s
+; RUN: llc -mtriple i386-apple-darwin \
+; RUN:   -relocation-model=dynamic-no-pic < %s | \
+; RUN:   FileCheck --check-prefix=DARWIN32_DNP %s
+
+; globals
+
+@strong_default_global = global i32 42
+define i32* @get_strong_default_global() {
+  ret i32* @strong_default_global
+}
+; CHECK: leaq _strong_default_global(%rip), %rax
+; DARWIN32: leal _strong_default_global-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_default_global, %eax
+; DARWIN32_DNP: movl $_strong_default_global, %eax
+
+@weak_default_global = weak global i32 42
+define i32* @get_weak_default_global() {
+  ret i32* @weak_default_global
+}
+; CHECK: movq _weak_default_global@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_default_global$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_default_global, %eax
+; DARWIN32_DNP: movl L_weak_default_global$non_lazy_ptr, %eax
+
+@external_default_global = external global i32
+define i32* @get_external_default_global() {
+  ret i32* @external_default_global
+}
+; CHECK: movq _external_default_global@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_external_default_global$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_default_global, %eax
+; DARWIN32_DNP: movl L_external_default_global$non_lazy_ptr, %eax
+
+@strong_local_global = dso_local global i32 42
+define i32* @get_strong_local_global() {
+  ret i32* @strong_local_global
+}
+; CHECK: leaq _strong_local_global(%rip), %rax
+; DARWIN32: leal _strong_local_global-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_local_global, %eax
+; DARWIN32_DNP: movl $_strong_local_global, %eax
+
+@weak_local_global = weak dso_local global i32 42
+define i32* @get_weak_local_global() {
+  ret i32* @weak_local_global
+}
+; CHECK: leaq _weak_local_global(%rip), %rax
+; DARWIN32: leal _weak_local_global-L{{.}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_local_global, %eax
+; DARWIN32_DNP: movl $_weak_local_global, %eax
+
+@external_local_global = external dso_local global i32
+define i32* @get_external_local_global() {
+  ret i32* @external_local_global
+}
+; CHECK: leaq _external_local_global(%rip), %rax
+; DARWIN32: movl L_external_local_global$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_local_global, %eax
+; DARWIN32_DNP: movl $_external_local_global, %eax
+
+@strong_preemptable_global = dso_preemptable global i32 42
+define i32* @get_strong_preemptable_global() {
+  ret i32* @strong_preemptable_global
+}
+; CHECK: leaq _strong_preemptable_global(%rip), %rax
+; DARWIN32: leal _strong_preemptable_global-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_preemptable_global, %eax
+; DARWIN32_DNP: movl $_strong_preemptable_global, %eax
+
+@weak_preemptable_global = weak dso_preemptable global i32 42
+define i32* @get_weak_preemptable_global() {
+  ret i32* @weak_preemptable_global
+}
+; CHECK: movq _weak_preemptable_global@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_preemptable_global$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_preemptable_global, %eax
+; DARWIN32_DNP: movl L_weak_preemptable_global$non_lazy_ptr, %eax
+
+@external_preemptable_global = external dso_preemptable global i32
+define i32* @get_external_preemptable_global() {
+  ret i32* @external_preemptable_global
+}
+; CHECK: movq _external_preemptable_global@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_external_preemptable_global$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_preemptable_global, %eax
+; DARWIN32_DNP: movl L_external_preemptable_global$non_lazy_ptr, %eax
+
+; aliases
+@aliasee = global i32 42
+
+@strong_default_alias = alias i32, i32* @aliasee
+define i32* @get_strong_default_alias() {
+  ret i32* @strong_default_alias
+}
+; CHECK: leaq _strong_default_alias(%rip), %rax
+; DARWIN32: leal _strong_default_alias-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_default_alias, %eax
+; DARWIN32_DNP: movl $_strong_default_alias, %eax
+
+@weak_default_alias = weak alias i32, i32* @aliasee
+define i32* @get_weak_default_alias() {
+  ret i32* @weak_default_alias
+}
+; CHECK: movq _weak_default_alias@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_default_alias$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_default_alias, %eax
+; DARWIN32_DNP: movl L_weak_default_alias$non_lazy_ptr, %eax
+
+@strong_local_alias = dso_local alias i32, i32* @aliasee
+define i32* @get_strong_local_alias() {
+  ret i32* @strong_local_alias
+}
+; CHECK: leaq _strong_local_alias(%rip), %rax
+; DARWIN32: leal _strong_local_alias-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_local_alias, %eax
+; DARWIN32_DNP: movl $_strong_local_alias, %eax
+
+@weak_local_alias = weak dso_local alias i32, i32* @aliasee
+define i32* @get_weak_local_alias() {
+  ret i32* @weak_local_alias
+}
+; CHECK: leaq _weak_local_alias(%rip), %rax
+; DARWIN32: leal _weak_local_alias-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_local_alias, %eax
+; DARWIN32_DNP: movl $_weak_local_alias, %eax
+
+@strong_preemptable_alias = dso_preemptable alias i32, i32* @aliasee
+define i32* @get_strong_preemptable_alias() {
+  ret i32* @strong_preemptable_alias
+}
+; CHECK: leaq _strong_preemptable_alias(%rip), %rax
+; DARWIN32: leal _strong_preemptable_alias-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_preemptable_alias, %eax
+; DARWIN32_DNP: movl $_strong_preemptable_alias, %eax
+
+@weak_preemptable_alias = weak dso_preemptable alias i32, i32* @aliasee
+define i32* @get_weak_preemptable_alias() {
+  ret i32* @weak_preemptable_alias
+}
+; CHECK: movq _weak_preemptable_alias@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_preemptable_alias$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_preemptable_alias, %eax
+; DARWIN32_DNP: movl L_weak_preemptable_alias$non_lazy_ptr, %eax
+
+; functions
+
+define void @strong_default_function() {
+  ret void
+}
+define void()* @get_strong_default_function() {
+  ret void()* @strong_default_function
+}
+; CHECK: leaq _strong_default_function(%rip), %rax
+; DARWIN32: leal _strong_default_function-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_default_function, %eax
+; DARWIN32_DNP: movl $_strong_default_function, %eax
+
+define weak void @weak_default_function() {
+  ret void
+}
+define void()* @get_weak_default_function() {
+  ret void()* @weak_default_function
+}
+; CHECK: movq _weak_default_function@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_default_function$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_default_function, %eax
+; DARWIN32_DNP: movl L_weak_default_function$non_lazy_ptr, %eax
+
+declare void @external_default_function()
+define void()* @get_external_default_function() {
+  ret void()* @external_default_function
+}
+; CHECK: movq _external_default_function@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_external_default_function$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_default_function, %eax
+; DARWIN32_DNP: movl L_external_default_function$non_lazy_ptr, %eax
+
+define dso_local void @strong_local_function() {
+  ret void
+}
+define void()* @get_strong_local_function() {
+  ret void()* @strong_local_function
+}
+; CHECK: leaq _strong_local_function(%rip), %rax
+; DARWIN32: leal _strong_local_function-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_local_function, %eax
+; DARWIN32_DNP: movl $_strong_local_function, %eax
+
+define weak dso_local void @weak_local_function() {
+  ret void
+}
+define void()* @get_weak_local_function() {
+  ret void()* @weak_local_function
+}
+; CHECK: leaq _weak_local_function(%rip), %rax
+; DARWIN32: leal _weak_local_function-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_local_function, %eax
+; DARWIN32_DNP: movl $_weak_local_function, %eax
+
+declare dso_local void @external_local_function()
+define void()* @get_external_local_function() {
+  ret void()* @external_local_function
+}
+; CHECK: leaq _external_local_function(%rip), %rax
+; DARWIN32: movl L_external_local_function$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_local_function, %eax
+; DARWIN32_DNP: movl $_external_local_function, %eax
+
+define dso_preemptable void @strong_preemptable_function() {
+  ret void
+}
+define void()* @get_strong_preemptable_function() {
+  ret void()* @strong_preemptable_function
+}
+; CHECK: leaq _strong_preemptable_function(%rip), %rax
+; DARWIN32: leal _strong_preemptable_function-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_strong_preemptable_function, %eax
+; DARWIN32_DNP: movl $_strong_preemptable_function, %eax
+
+define weak dso_preemptable void @weak_preemptable_function() {
+  ret void
+}
+define void()* @get_weak_preemptable_function() {
+  ret void()* @weak_preemptable_function
+}
+; CHECK: movq _weak_preemptable_function@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_weak_preemptable_function$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_weak_preemptable_function, %eax
+; DARWIN32_DNP: movl L_weak_preemptable_function$non_lazy_ptr, %eax
+
+declare dso_preemptable void @external_preemptable_function()
+define void()* @get_external_preemptable_function() {
+  ret void()* @external_preemptable_function
+}
+; CHECK: movq _external_preemptable_function@GOTPCREL(%rip), %rax
+; DARWIN32: movl L_external_preemptable_function$non_lazy_ptr-L{{.*}}$pb(%eax), %eax
+; DARWIN32_S: movl $_external_preemptable_function, %eax
+; DARWIN32_DNP: movl L_external_preemptable_function$non_lazy_ptr, %eax

test/CodeGen/X86/linux-preemption.ll

+; RUN: llc -mtriple x86_64-pc-linux \
+; RUN:     -relocation-model=static  < %s | FileCheck --check-prefix=STATIC %s
+; RUN: llc -mtriple x86_64-pc-linux \
+; RUN:     -relocation-model=pic             < %s | FileCheck %s
+; RUN: llc -mtriple x86_64-pc-linux \
+; RUN:     -relocation-model=dynamic-no-pic  < %s | FileCheck %s
+
+; 32 bits
+
+; RUN: llc -mtriple i386-pc-linux \
+; RUN:     -relocation-model=pic     < %s | FileCheck --check-prefix=CHECK32 %s
+
+; globals
+
+@strong_default_global = global i32 42
+define i32* @get_strong_default_global() {
+  ret i32* @strong_default_global
+}
+; CHECK: movq strong_default_global@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_default_global, %eax
+; CHECK32: movl strong_default_global@GOT(%eax), %eax
+
+@weak_default_global = weak global i32 42
+define i32* @get_weak_default_global() {
+  ret i32* @weak_default_global
+}
+; CHECK: movq weak_default_global@GOTPCREL(%rip), %rax
+; STATIC: movl $weak_default_global, %eax
+; CHECK32: movl weak_default_global@GOT(%eax), %eax
+
+@external_default_global = external global i32
+define i32* @get_external_default_global() {
+  ret i32* @external_default_global
+}
+; CHECK: movq external_default_global@GOTPCREL(%rip), %rax
+; STATIC: movl $external_default_global, %eax
+; CHECK32: movl external_default_global@GOT(%eax), %eax
+
+@strong_local_global = dso_local global i32 42
+define i32* @get_strong_local_global() {
+  ret i32* @strong_local_global
+}
+; CHECK: leaq strong_local_global(%rip), %rax
+; STATIC: movl $strong_local_global, %eax
+; CHECK32: leal strong_local_global@GOTOFF(%eax), %eax
+
+@weak_local_global = weak dso_local global i32 42
+define i32* @get_weak_local_global() {
+  ret i32* @weak_local_global
+}
+; CHECK: leaq weak_local_global(%rip), %rax
+; STATIC: movl $weak_local_global, %eax
+; CHECK32: leal weak_local_global@GOTOFF(%eax), %eax
+
+@external_local_global = external dso_local global i32
+define i32* @get_external_local_global() {
+  ret i32* @external_local_global
+}
+; CHECK: leaq external_local_global(%rip), %rax
+; STATIC: movl $external_local_global, %eax
+; CHECK32: leal external_local_global@GOTOFF(%eax), %eax
+
+
+@strong_preemptable_global = dso_preemptable global i32 42
+define i32* @get_strong_preemptable_global() {
+  ret i32* @strong_preemptable_global
+}
+; CHECK: movq strong_preemptable_global@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_preemptable_global, %eax
+; CHECK32: movl strong_preemptable_global@GOT(%eax), %eax
+
+@weak_preemptable_global = weak dso_preemptable global i32 42
+define i32* @get_weak_preemptable_global() {
+  ret i32* @weak_preemptable_global
+}
+; CHECK ;ADD_LABEL_BACK;  movq weak_preemptable_global@GOTPCREL(%rip), %rax
+; STATIC ;ADD_LABEL_BACK; movq weak_preemptable_global@GOTPCREL, %rax
+; CHECK32 ;ADD_LABEL_BACK; movl weak_preemptable_global@GOT(%eax), %eax
+
+@external_preemptable_global = external dso_preemptable global i32
+define i32* @get_external_preemptable_global() {
+  ret i32* @external_preemptable_global
+}
+; CHECK: movq external_preemptable_global@GOTPCREL(%rip), %rax
+; STATIC: movl $external_preemptable_global, %eax
+; CHECK32: movl external_preemptable_global@GOT(%eax), %eax
+
+; aliases
+@aliasee = global i32 42
+
+@strong_default_alias = alias i32, i32* @aliasee
+define i32* @get_strong_default_alias() {
+  ret i32* @strong_default_alias
+}
+; CHECK: movq strong_default_alias@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_default_alias, %eax
+; CHECK32: movl strong_default_alias@GOT(%eax), %eax
+
+@weak_default_alias = weak alias i32, i32* @aliasee
+define i32* @get_weak_default_alias() {
+  ret i32* @weak_default_alias
+}
+; CHECK: movq weak_default_alias@GOTPCREL(%rip), %rax
+; STATIC: movl $weak_default_alias, %eax
+; CHECK32: movl weak_default_alias@GOT(%eax), %eax
+
+@strong_local_alias = dso_local alias i32, i32* @aliasee
+define i32* @get_strong_local_alias() {
+  ret i32* @strong_local_alias
+}
+; CHECK: leaq strong_local_alias(%rip), %rax
+; STATIC: movl $strong_local_alias, %eax
+; CHECK32: leal strong_local_alias@GOTOFF(%eax), %eax
+
+@weak_local_alias = weak dso_local alias i32, i32* @aliasee
+define i32* @get_weak_local_alias() {
+  ret i32* @weak_local_alias
+}
+; CHECK: leaq weak_local_alias(%rip), %rax
+; STATIC: movl $weak_local_alias, %eax
+; CHECK32: leal weak_local_alias@GOTOFF(%eax), %eax
+
+
+@strong_preemptable_alias = dso_preemptable alias i32, i32* @aliasee
+define i32* @get_strong_preemptable_alias() {
+  ret i32* @strong_preemptable_alias
+}
+; CHECK: movq strong_preemptable_alias@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_preemptable_alias, %eax
+; CHECK32: movl strong_preemptable_alias@GOT(%eax), %eax
+
+@weak_preemptable_alias = weak dso_preemptable alias i32, i32* @aliasee
+define i32* @get_weak_preemptable_alias() {
+  ret i32* @weak_preemptable_alias
+}
+; CHECK: movq weak_preemptable_alias@GOTPCREL(%rip), %rax
+; STATIC: movl $weak_preemptable_alias, %eax
+; CHECK32: movl weak_preemptable_alias@GOT(%eax), %eax
+
+; functions
+
+define void @strong_default_function() {
+  ret void
+}
+define void()* @get_strong_default_function() {
+  ret void()* @strong_default_function
+}
+; CHECK: movq strong_default_function@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_default_function, %eax
+; CHECK32: movl strong_default_function@GOT(%eax), %eax
+
+define weak void @weak_default_function() {
+  ret void
+}
+define void()* @get_weak_default_function() {
+  ret void()* @weak_default_function
+}
+; CHECK: movq weak_default_function@GOTPCREL(%rip), %rax
+; STATIC: movl $weak_default_function, %eax
+; CHECK32: movl weak_default_function@GOT(%eax), %eax
+
+declare void @external_default_function()
+define void()* @get_external_default_function() {
+  ret void()* @external_default_function
+}
+; CHECK: movq external_default_function@GOTPCREL(%rip), %rax
+; STATIC: movl $external_default_function, %eax
+; CHECK32: movl external_default_function@GOT(%eax), %eax
+
+define dso_local void @strong_local_function() {
+  ret void
+}
+define void()* @get_strong_local_function() {
+  ret void()* @strong_local_function
+}
+; CHECK: leaq strong_local_function(%rip), %rax
+; STATIC: movl $strong_local_function, %eax
+; CHECK32: leal strong_local_function@GOTOFF(%eax), %eax
+
+define weak dso_local void @weak_local_function() {
+  ret void
+}
+define void()* @get_weak_local_function() {
+  ret void()* @weak_local_function
+}
+; CHECK: leaq weak_local_function(%rip), %rax
+; STATIC: movl $weak_local_function, %eax
+; CHECK32: leal weak_local_function@GOTOFF(%eax), %eax
+
+declare dso_local void @external_local_function()
+define void()* @get_external_local_function() {
+  ret void()* @external_local_function
+}
+; CHECK: leaq external_local_function(%rip), %rax
+; STATIC: movl $external_local_function, %eax
+; CHECK32: leal external_local_function@GOTOFF(%eax), %eax
+
+
+define dso_preemptable void @strong_preemptable_function() {
+  ret void
+}
+define void()* @get_strong_preemptable_function() {
+  ret void()* @strong_preemptable_function
+}
+; CHECK: movq strong_preemptable_function@GOTPCREL(%rip), %rax
+; STATIC: movl $strong_preemptable_function, %eax
+; CHECK32: movl strong_preemptable_function@GOT(%eax), %eax
+
+define weak dso_preemptable void @weak_preemptable_function() {
+  ret void
+}
+define void()* @get_weak_preemptable_function() {
+  ret void()* @weak_preemptable_function
+}
+; CHECK: movq weak_preemptable_function@GOTPCREL(%rip), %rax
+; STATIC: movl $weak_preemptable_function, %eax
+; CHECK32: movl weak_preemptable_function@GOT(%eax), %eax
+
+declare dso_preemptable void @external_preemptable_function()
+define void()* @get_external_preemptable_function() {
+  ret void()* @external_preemptable_function
+}
+; CHECK: movq external_preemptable_function@GOTPCREL(%rip), %rax
+; STATIC: movl $external_preemptable_function, %eax
+; CHECK32: movl external_preemptable_function@GOT(%eax), %eax

test/CodeGen/X86/win32-preemption.ll

+; RUN: llc -mtriple x86_64-pc-win32 \
+; RUN:     -relocation-model=static  < %s | FileCheck --check-prefix=COFF_S %s
+; RUN: llc -mtriple x86_64-pc-win32 \
+; RUN:     -relocation-model=pic     < %s | FileCheck --check-prefix=COFF %s
+; RUN: llc -mtriple x86_64-pc-win32 \
+; RUN:  -relocation-model=dynamic-no-pic < %s | FileCheck --check-prefix=COFF %s
+
+
+; 32 bits
+
+; RUN: llc -mtriple i386-pc-win32 \
+; RUN:    -relocation-model=static  < %s | FileCheck --check-prefix=COFF32 %s
+; RUN: llc -mtriple i386-pc-win32 \
+; RUN:     -relocation-model=pic     < %s | FileCheck --check-prefix=COFF32 %s
+; RUN: llc -mtriple i386-pc-win32 \
+; RUN:   -relocation-model=dynamic-no-pic < %s | \
+; RUN:   FileCheck --check-prefix=COFF32 %s
+
+; globals
+
+@strong_default_global = global i32 42
+define i32* @get_strong_default_global() {
+  ret i32* @strong_default_global
+}
+; COFF: leaq strong_default_global(%rip), %rax
+; COFF_S: movl $strong_default_global, %eax
+; COFF32: movl $_strong_default_global, %eax
+
+@weak_default_global = weak global i32 42
+define i32* @get_weak_default_global() {
+  ret i32* @weak_default_global
+}
+; COFF: leaq weak_default_global(%rip), %rax
+; COFF_S: movl $weak_default_global, %eax
+; COFF32: movl $_weak_default_global, %eax
+
+@external_default_global = external global i32
+define i32* @get_external_default_global() {
+  ret i32* @external_default_global
+}
+; COFF: leaq external_default_global(%rip), %rax
+; COFF_S: movl $external_default_global, %eax
+; COFF32: movl $_external_default_global, %eax
+
+
+@strong_local_global = dso_local global i32 42
+define i32* @get_strong_local_global() {
+  ret i32* @strong_local_global
+}
+; COFF: leaq strong_local_global(%rip), %rax
+; COFF_S: movl $strong_local_global, %eax
+; COFF32: movl $_strong_local_global, %eax
+
+@weak_local_global = weak dso_local global i32 42
+define i32* @get_weak_local_global() {
+  ret i32* @weak_local_global
+}
+; COFF: leaq weak_local_global(%rip), %rax
+; COFF_S: movl $weak_local_global, %eax
+; COFF32: movl $_weak_local_global, %eax
+
+@external_local_global = external dso_local global i32
+define i32* @get_external_local_global() {
+  ret i32* @external_local_global
+}
+; COFF: leaq external_local_global(%rip), %rax
+; COFF_S: movl $external_local_global, %eax
+; COFF32: movl $_external_local_global, %eax
+
+
+@strong_preemptable_global = dso_preemptable global i32 42
+define i32* @get_strong_preemptable_global() {
+  ret i32* @strong_preemptable_global
+}
+; COFF: leaq strong_preemptable_global(%rip), %rax
+; COFF_S: movl $strong_preemptable_global, %eax
+; COFF32: movl $_strong_preemptable_global, %eax
+
+@weak_preemptable_global = weak dso_preemptable global i32 42
+define i32* @get_weak_preemptable_global() {
+  ret i32* @weak_preemptable_global
+}
+; COFF: leaq weak_preemptable_global(%rip), %rax
+; COFF_S: movl $weak_preemptable_global, %eax
+; COFF32: movl $_weak_preemptable_global, %eax
+
+@external_preemptable_global = external dso_preemptable global i32
+define i32* @get_external_preemptable_global() {
+  ret i32* @external_preemptable_global
+}
+; COFF: leaq external_preemptable_global(%rip), %rax
+; COFF_S: movl $external_preemptable_global, %eax
+; COFF32: movl $_external_preemptable_global, %eax
+
+
+; aliases
+@aliasee = global i32 42
+
+@strong_default_alias = alias i32, i32* @aliasee
+define i32* @get_strong_default_alias() {
+  ret i32* @strong_default_alias
+}
+; COFF: leaq strong_default_alias(%rip), %rax
+; COFF_S: movl $strong_default_alias, %eax
+; COFF32: movl $_strong_default_alias, %eax
+
+@weak_default_alias = weak alias i32, i32* @aliasee
+define i32* @get_weak_default_alias() {
+  ret i32* @weak_default_alias
+}
+; COFF: leaq weak_default_alias(%rip), %rax
+; COFF_S: movl $weak_default_alias, %eax
+; COFF32: movl $_weak_default_alias, %eax
+
+
+@strong_local_alias = dso_local alias i32, i32* @aliasee
+define i32* @get_strong_local_alias() {
+  ret i32* @strong_local_alias
+}
+; COFF: leaq strong_local_alias(%rip), %rax
+; COFF_S: movl $strong_local_alias, %eax
+; COFF32: movl $_strong_local_alias, %eax
+
+@weak_local_alias = weak dso_local alias i32, i32* @aliasee
+define i32* @get_weak_local_alias() {
+  ret i32* @weak_local_alias
+}
+; COFF: leaq weak_local_alias(%rip), %rax
+; COFF_S: movl $weak_local_alias, %eax
+; COFF32: movl $_weak_local_alias, %eax
+
+
+@strong_preemptable_alias = dso_preemptable alias i32, i32* @aliasee
+define i32* @get_strong_preemptable_alias() {
+  ret i32* @strong_preemptable_alias
+}
+; COFF: leaq strong_preemptable_alias(%rip), %rax
+; COFF_S: movl $strong_preemptable_alias, %eax
+; COFF32: movl $_strong_preemptable_alias, %eax
+
+@weak_preemptable_alias = weak dso_preemptable alias i32, i32* @aliasee
+define i32* @get_weak_preemptable_alias() {
+  ret i32* @weak_preemptable_alias
+}
+; COFF: leaq weak_preemptable_alias(%rip), %rax
+; COFF_S: movl $weak_preemptable_alias, %eax
+; COFF32: movl $_weak_preemptable_alias, %eax
+
+
+; functions
+
+define void @strong_default_function() {
+  ret void
+}
+define void()* @get_strong_default_function() {
+  ret void()* @strong_default_function
+}
+; COFF: leaq strong_default_function(%rip), %rax
+; COFF_S: movl $strong_default_function, %eax
+; COFF32: movl $_strong_default_function, %eax
+
+define weak void @weak_default_function() {
+  ret void
+}
+define void()* @get_weak_default_function() {
+  ret void()* @weak_default_function
+}
+; COFF: leaq weak_default_function(%rip), %rax
+; COFF_S: movl $weak_default_function, %eax
+; COFF32: movl $_weak_default_function, %eax
+
+declare void @external_default_function()
+define void()* @get_external_default_function() {
+  ret void()* @external_default_function
+}
+; COFF: leaq external_default_function(%rip), %rax
+; COFF_S: movl $external_default_function, %eax
+; COFF32: movl $_external_default_function, %eax
+
+
+define dso_local void @strong_local_function() {
+  ret void
+}
+define void()* @get_strong_local_function() {
+  ret void()* @strong_local_function
+}
+; COFF: leaq strong_local_function(%rip), %rax
+; COFF_S: movl $strong_local_function, %eax
+; COFF32: movl $_strong_local_function, %eax
+
+define weak dso_local void @weak_local_function() {
+  ret void
+}
+define void()* @get_weak_local_function() {
+  ret void()* @weak_local_function
+}
+; COFF: leaq weak_local_function(%rip), %rax
+; COFF_S: movl $weak_local_function, %eax
+; COFF32: movl $_weak_local_function, %eax
+
+declare dso_local void @external_local_function()
+define void()* @get_external_local_function() {
+  ret void()* @external_local_function
+}
+; COFF: leaq external_local_function(%rip), %rax
+; COFF_S: movl $external_local_function, %eax
+; COFF32: movl $_external_local_function, %eax
+
+
+define dso_preemptable void @strong_preemptable_function() {
+  ret void
+}
+define void()* @get_strong_preemptable_function() {
+  ret void()* @strong_preemptable_function
+}
+; COFF: leaq strong_preemptable_function(%rip), %rax
+; COFF_S: movl $strong_preemptable_function, %eax
+; COFF32: movl $_strong_preemptable_function, %eax
+
+define weak dso_preemptable void @weak_preemptable_function() {
+  ret void
+}
+define void()* @get_weak_preemptable_function() {
+  ret void()* @weak_preemptable_function
+}
+; COFF: leaq weak_preemptable_function(%rip), %rax
+; COFF_S: movl $weak_preemptable_function, %eax
+; COFF32: movl $_weak_preemptable_function, %eax
+
+declare dso_preemptable void @external_preemptable_function()
+define void()* @get_external_preemptable_function() {
+  ret void()* @external_preemptable_function
+}
+; COFF: leaq external_preemptable_function(%rip), %rax
+; COFF_S: movl $external_preemptable_function, %eax
+; COFF32: movl $_external_preemptable_function, %eax