This is an archive of the discontinued LLVM Phabricator instance.

Change representation of dllexport/dllimport
ClosedPublic

Authored by nrieck on Jul 5 2013, 6:38 PM.

Download Raw Diff

Details

Reviewers

rnk
asl

Summary

Representing dllexport/dllimport as distinct linkage types prevents using these attributes on templates and inline functions.

Instead of introducing further mixed linkage types to include linkonce and weak ODR, the old import/export linkage types are replaced with new function attributes (DLLExport, DLLImport) and an extension to global variables:

    
@Exp = global i32 1, align 4, dllexport
@Imp = external global i32, dllimport

Linkage for dllexported globals and functions is now equal to their linkage without dllexport. Imported globals and functions must be either declarations, or definitions with AvailableExternallyLinkage. An alias is exported if the aliasee is exported.

Diff Detail

Event Timeline

Replaced the mixed representation (function attribute + global var extension) with a new visibility-like specifier, usable for functions, globals and aliases. Note: Aliases could have dllexport linkage before.
Kept the old linkage types in the C API, and marked them as obsolete.
Extended bitcode for the new specifier, upgrading older bitcode files.

I still feel strongly that dllexport and dllimport should be new visibility values.

Is there any compelling reason to support a combination of dllimport/dllexport + visibility(hidden/internal/protected)? If not, I don't see any reason to make that representable in IR.

test/CodeGen/X86/dllimport-x86_64.ll
28	Should this be FAST-NEXT: or have some other way to avoid matching one of the calls from below?
test/CodeGen/X86/dllimport.ll
32	ditto

Oh, you meant adding them to GlobalValue::VisibilityTypes? I don't really like referring to dllexport/dllimport as visibilities, especially not dllimport. Though in the end I care more about getting this in. I agree that there's a certain duplication in the IR reader/writer. Regarding combining them, I wonder what the ARM compiler does. Browsing through their reference, they seem to support dllexport/dllimport using ELF (and also visibility). I can't find anything in the docs about issues combining them though. While dllexport must always have default visibility, dllimport could be any.

test/CodeGen/X86/dllimport-x86_64.ll
28	Yeah, would be better.

How's this patch doing? It's come up on the mailing lists a few times, so I thought I'd ping. :)

Why do you say that dllimport could be any visibility? Is it useful to have a visibility(non-hidden) + dllimport symbol?

Why do you say that dllimport could be any visibility?  Is it useful to have a visibility(non-hidden) + dllimport symbol?

Because dllimport has nothing wrt the visibility. Visibility is
essnetially ELF'ish thing. dllexport can be thought as "default"
visibility and everything else is hidden visibility by default, but
dllimport does not fit into this semantics. Trying to fit them into
visibility is essentialy a workaround

compnerd added inline comments.Sep 10 2013, 10:37 AM

lib/Bitcode/Reader/BitcodeReader.cpp
193	missing return or break
194	ditto

Rebased to recent ToT.
Fixed UpgradeDLLImportExportLinkage.
Added mingw triple to tests.

asl added a reviewer: asl.Nov 27 2013, 2:08 AM

Rebased to ToT

Thanks, LGTM!

Sorry for taking a while to get back to this, it's large.

Committed in r199203, r199218 and r199219. Clang changes in r199220.

bd1976llvm mentioned this in D95949: Remove unused CHECK of dllexport declaration.Feb 3 2021, 5:59 AM

Revision Contents

Path

Size

docs/

LangRef.rst

36 lines

include/

llvm-c/

Core.h

2 lines

llvm/

IR/

Attributes.h

2 lines

GlobalValue.h

12 lines

GlobalVariable.h

19 lines

lib/

AsmParser/

LLParser.cpp

19 lines

Bitcode/

Reader/

BitcodeReader.cpp

2 lines

Writer/

BitcodeWriter.cpp

2 lines

CodeGen/

AsmPrinter/

AsmPrinter.cpp

1 line

ExecutionEngine/

ExecutionEngine.cpp

4 lines

IR/

8 lines

6 lines

10 lines

6 lines

31 lines

Linker/

LinkModules.cpp

24 lines

Target/

CppBackend/

CPPBackend.cpp

6 lines

Mangler.cpp

9 lines

X86/

19 lines

18 lines

12 lines

13 lines

XCore/

XCoreAsmPrinter.cpp

4 lines

test/

CodeGen/

X86/

85 lines

103 lines

54 lines

65 lines

MC/

COFF/

linker-options.ll

2 lines

Diff 2710

docs/LangRef.rst

This file is larger than 256 KB, so syntax highlighting is disabled by default.

Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Lines	``linkonce_odr_auto_hide``
``linkonce_odr_auto_hide`` may have only ``default`` visibility. The		``linkonce_odr_auto_hide`` may have only ``default`` visibility. The
symbols are removed by the linker from the final linked image		symbols are removed by the linker from the final linked image
(executable or dynamic library).		(executable or dynamic library).
``external``		``external``
If none of the above identifiers are used, the global is externally		If none of the above identifiers are used, the global is externally
visible, meaning that it participates in linkage and can be used to		visible, meaning that it participates in linkage and can be used to
resolve external symbol references.		resolve external symbol references.

The next two types of linkage are targeted for Microsoft Windows
platform only. They are designed to support importing (exporting)
symbols from (to) DLLs (Dynamic Link Libraries).

``dllimport``
"``dllimport``" linkage causes the compiler to reference a function
or variable via a global pointer to a pointer that is set up by the
DLL exporting the symbol. On Microsoft Windows targets, the pointer
name is formed by combining ``__imp_`` and the function or variable
name.
``dllexport``
"``dllexport``" linkage causes the compiler to provide a global
pointer to a pointer in a DLL, so that it can be referenced with the
``dllimport`` attribute. On Microsoft Windows targets, the pointer
name is formed by combining ``__imp_`` and the function or variable
name.

For example, since the "``.LC0``" variable is defined to be internal, if		For example, since the "``.LC0``" variable is defined to be internal, if
another module defined a "``.LC0``" variable and was linked with this		another module defined a "``.LC0``" variable and was linked with this
one, one of the two would be renamed, preventing a collision. Since		one, one of the two would be renamed, preventing a collision. Since
"``main``" and "``puts``" are external (i.e., lacking any linkage		"``main``" and "``puts``" are external (i.e., lacking any linkage
declarations), they are accessible outside of the current module.		declarations), they are accessible outside of the current module.

It is illegal for a function declaration to have any linkage type		It is illegal for a function declaration to have any linkage type
other than ``external``, ``dllimport`` or ``extern_weak``.		other than ``external``, ``dllimport`` or ``extern_weak``.
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
convenient. If an explicit alignment is specified, the global is forced		convenient. If an explicit alignment is specified, the global is forced
to have exactly that alignment. Targets and optimizers are not allowed		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		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		case, the extra alignment could be observable: for example, code could
assume that the globals are densely packed in their section and try to		assume that the globals are densely packed in their section and try to
iterate over them as an array, alignment padding would break this		iterate over them as an array, alignment padding would break this
iteration.		iteration.

		Globals can be marked as ``dllimport`` or ``dllexport``. Please refer to
		the function attributes with the same name for more information.

For example, the following defines a global in a numbered address space		For example, the following defines a global in a numbered address space
with an initializer, section, and alignment:		with an initializer, section, and alignment:

.. code-block:: llvm		.. code-block:: llvm

@G = addrspace(5) constant float 1.0, section "foo", align 4		@G = addrspace(5) constant float 1.0, section "foo", align 4

The following example defines a thread-local global with the		The following example defines a thread-local global with the
``initialexec`` TLS model:		``initialexec`` TLS model:

.. code-block:: llvm		.. code-block:: llvm

@G = thread_local(initialexec) global i32 0, align 4		@G = thread_local(initialexec) global i32 0, align 4

		The following example defines a global that is imported from a DLL:

		.. code-block:: llvm

		@G = external global i32, dllimport

.. _functionstructure:		.. _functionstructure:

Functions		Functions
---------		---------

LLVM function definitions consist of the "``define``" keyword, an		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:`visibility
style <visibility>`, an optional :ref:`calling convention <callingconv>`,		style <visibility>`, an optional :ref:`calling convention <callingconv>`,
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines	``builtin``
uses the ``nobuiltin`` attribute. This is only valid at call sites for		uses the ``nobuiltin`` attribute. This is only valid at call sites for
direct calls to functions which are declared with the ``nobuiltin``		direct calls to functions which are declared with the ``nobuiltin``
attribute.		attribute.
``cold``		``cold``
This attribute indicates that this function is rarely called. When		This attribute indicates that this function is rarely called. When
computing edge weights, basic blocks post-dominated by a cold		computing edge weights, basic blocks post-dominated by a cold
function call are also considered to be cold; and, thus, given low		function call are also considered to be cold; and, thus, given low
weight.		weight.
		``dllimport``
		"``dllimport``" causes the compiler to reference the function via a
		global pointer to a pointer that is set up by the DLL exporting the
		symbol. On Microsoft Windows targets, the pointer name is formed by
		combining ``__imp_`` and the function or variable name.
		``dllexport``
		"``dllexport``" causes the compiler to provide a global pointer to a
		pointer in a DLL, so that it can be referenced with the ``dllimport``
		attribute. On Microsoft Windows targets, the pointer name is formed
		by combining ``__imp_`` and the function or variable name.
``nonlazybind``		``nonlazybind``
This attribute suppresses lazy symbol binding for the function. This		This attribute suppresses lazy symbol binding for the function. This
may make calls to the function faster, at the cost of extra program		may make calls to the function faster, at the cost of extra program
startup time if the function is not called during program startup.		startup time if the function is not called during program startup.
``inlinehint``		``inlinehint``
This attribute indicates that the source code contained a hint that		This attribute indicates that the source code contained a hint that
inlining this function is desirable (such as the "inline" keyword in		inlining this function is desirable (such as the "inline" keyword in
C/C++). It is just a hint; it imposes no requirements on the		C/C++). It is just a hint; it imposes no requirements on the
▲ Show 20 Lines • Show All 7,854 Lines • Show Last 20 Lines

include/llvm-c/Core.h

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines	typedef enum {
LLVMLinkOnceODRAutoHideLinkage, /*< Like LinkOnceODR, but possibly hidden. /		LLVMLinkOnceODRAutoHideLinkage, /*< Like LinkOnceODR, but possibly hidden. /
LLVMWeakAnyLinkage, /*< Keep one copy of function when linking (weak) /		LLVMWeakAnyLinkage, /*< Keep one copy of function when linking (weak) /
LLVMWeakODRLinkage, /**< Same, but only replaced by something		LLVMWeakODRLinkage, /**< Same, but only replaced by something
equivalent. */		equivalent. */
LLVMAppendingLinkage, /*< Special purpose, only applies to global arrays /		LLVMAppendingLinkage, /*< Special purpose, only applies to global arrays /
LLVMInternalLinkage, /**< Rename collisions when linking (static		LLVMInternalLinkage, /**< Rename collisions when linking (static
functions) */		functions) */
LLVMPrivateLinkage, /*< Like Internal, but omit from symbol table /		LLVMPrivateLinkage, /*< Like Internal, but omit from symbol table /
LLVMDLLImportLinkage, /*< Function to be imported from DLL /
LLVMDLLExportLinkage, /*< Function to be accessible from DLL /
LLVMExternalWeakLinkage,/*< ExternalWeak linkage description /		LLVMExternalWeakLinkage,/*< ExternalWeak linkage description /
LLVMGhostLinkage, /*< Obsolete /		LLVMGhostLinkage, /*< Obsolete /
LLVMCommonLinkage, /*< Tentative definitions /		LLVMCommonLinkage, /*< Tentative definitions /
LLVMLinkerPrivateLinkage, /*< Like Private, but linker removes. /		LLVMLinkerPrivateLinkage, /*< Like Private, but linker removes. /
LLVMLinkerPrivateWeakLinkage /*< Like LinkerPrivate, but is weak. /		LLVMLinkerPrivateWeakLinkage /*< Like LinkerPrivate, but is weak. /
} LLVMLinkage;		} LLVMLinkage;

typedef enum {		typedef enum {
▲ Show 20 Lines • Show All 2,445 Lines • Show Last 20 Lines

include/llvm/IR/Attributes.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines	enum AttrKind {
Alignment, ///< Alignment of parameter (5 bits)		Alignment, ///< Alignment of parameter (5 bits)
///< stored as log2 of alignment with +1 bias		///< stored as log2 of alignment with +1 bias
///< 0 means unaligned (different from align(1))		///< 0 means unaligned (different from align(1))
AlwaysInline, ///< inline=always		AlwaysInline, ///< inline=always
Builtin, ///< Callee is recognized as a builtin, despite		Builtin, ///< Callee is recognized as a builtin, despite
///< nobuiltin attribute on its declaration.		///< nobuiltin attribute on its declaration.
ByVal, ///< Pass structure by value		ByVal, ///< Pass structure by value
Cold, ///< Marks function as being in a cold path.		Cold, ///< Marks function as being in a cold path.
		DLLExport, ///< Export this function from DLL
		DLLImport, ///< Import this function from DLL
InlineHint, ///< Source said inlining was desirable		InlineHint, ///< Source said inlining was desirable
InReg, ///< Force argument to be passed in register		InReg, ///< Force argument to be passed in register
MinSize, ///< Function must be optimized for size first		MinSize, ///< Function must be optimized for size first
Naked, ///< Naked function		Naked, ///< Naked function
Nest, ///< Nested function static chain		Nest, ///< Nested function static chain
NoAlias, ///< Considered to not alias after call		NoAlias, ///< Considered to not alias after call
NoBuiltin, ///< Callee isn't recognized as a builtin		NoBuiltin, ///< Callee isn't recognized as a builtin
NoCapture, ///< Function creates no aliases of pointer		NoCapture, ///< Function creates no aliases of pointer
▲ Show 20 Lines • Show All 419 Lines • Show Last 20 Lines

include/llvm/IR/GlobalValue.h

Show All 37 Lines	enum LinkageTypes {
LinkOnceODRAutoHideLinkage, ///< Like LinkOnceODRLinkage but addr not taken.		LinkOnceODRAutoHideLinkage, ///< Like LinkOnceODRLinkage but addr not taken.
WeakAnyLinkage, ///< Keep one copy of named function when linking (weak)		WeakAnyLinkage, ///< Keep one copy of named function when linking (weak)
WeakODRLinkage, ///< Same, but only replaced by something equivalent.		WeakODRLinkage, ///< Same, but only replaced by something equivalent.
AppendingLinkage, ///< Special purpose, only applies to global arrays		AppendingLinkage, ///< Special purpose, only applies to global arrays
InternalLinkage, ///< Rename collisions when linking (static functions).		InternalLinkage, ///< Rename collisions when linking (static functions).
PrivateLinkage, ///< Like Internal, but omit from symbol table.		PrivateLinkage, ///< Like Internal, but omit from symbol table.
LinkerPrivateLinkage, ///< Like Private, but linker removes.		LinkerPrivateLinkage, ///< Like Private, but linker removes.
LinkerPrivateWeakLinkage, ///< Like LinkerPrivate, but weak.		LinkerPrivateWeakLinkage, ///< Like LinkerPrivate, but weak.
DLLImportLinkage, ///< Function to be imported from DLL
DLLExportLinkage, ///< Function to be accessible from DLL.
ExternalWeakLinkage,///< ExternalWeak linkage description.		ExternalWeakLinkage,///< ExternalWeak linkage description.
CommonLinkage ///< Tentative definitions.		CommonLinkage ///< Tentative definitions.
};		};

/// @brief An enumeration for the kinds of visibility of global values.		/// @brief An enumeration for the kinds of visibility of global values.
enum VisibilityTypes {		enum VisibilityTypes {
DefaultVisibility = 0, ///< The GV is visible		DefaultVisibility = 0, ///< The GV is visible
HiddenVisibility, ///< The GV is hidden		HiddenVisibility, ///< The GV is hidden
Show All 31 Lines	public:

VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }		VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }		bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }		bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
bool hasProtectedVisibility() const {		bool hasProtectedVisibility() const {
return Visibility == ProtectedVisibility;		return Visibility == ProtectedVisibility;
}		}
void setVisibility(VisibilityTypes V) { Visibility = V; }		void setVisibility(VisibilityTypes V) { Visibility = V; }

bool hasSection() const { return !Section.empty(); }		bool hasSection() const { return !Section.empty(); }
const std::string &getSection() const { return Section; }		const std::string &getSection() const { return Section; }
void setSection(StringRef S) { Section = S; }		void setSection(StringRef S) { Section = S; }

/// If the usage is empty (except transitively dead constants), then this		/// If the usage is empty (except transitively dead constants), then this
/// global value can be safely deleted since the destructor will		/// global value can be safely deleted since the destructor will
/// delete the dead constants as well.		/// delete the dead constants as well.
/// @brief Determine if the usage of this global value is empty except		/// @brief Determine if the usage of this global value is empty except
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	public:
}		}
static bool isLinkerPrivateWeakLinkage(LinkageTypes Linkage) {		static bool isLinkerPrivateWeakLinkage(LinkageTypes Linkage) {
return Linkage == LinkerPrivateWeakLinkage;		return Linkage == LinkerPrivateWeakLinkage;
}		}
static bool isLocalLinkage(LinkageTypes Linkage) {		static bool isLocalLinkage(LinkageTypes Linkage) {
return isInternalLinkage(Linkage) \|\| isPrivateLinkage(Linkage) \|\|		return isInternalLinkage(Linkage) \|\| isPrivateLinkage(Linkage) \|\|
isLinkerPrivateLinkage(Linkage) \|\| isLinkerPrivateWeakLinkage(Linkage);		isLinkerPrivateLinkage(Linkage) \|\| isLinkerPrivateWeakLinkage(Linkage);
}		}
static bool isDLLImportLinkage(LinkageTypes Linkage) {
return Linkage == DLLImportLinkage;
}
static bool isDLLExportLinkage(LinkageTypes Linkage) {
return Linkage == DLLExportLinkage;
}
static bool isExternalWeakLinkage(LinkageTypes Linkage) {		static bool isExternalWeakLinkage(LinkageTypes Linkage) {
return Linkage == ExternalWeakLinkage;		return Linkage == ExternalWeakLinkage;
}		}
static bool isCommonLinkage(LinkageTypes Linkage) {		static bool isCommonLinkage(LinkageTypes Linkage) {
return Linkage == CommonLinkage;		return Linkage == CommonLinkage;
}		}

/// isDiscardableIfUnused - Whether the definition of this global may be		/// isDiscardableIfUnused - Whether the definition of this global may be
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines	public:
bool hasAppendingLinkage() const { return isAppendingLinkage(Linkage); }		bool hasAppendingLinkage() const { return isAppendingLinkage(Linkage); }
bool hasInternalLinkage() const { return isInternalLinkage(Linkage); }		bool hasInternalLinkage() const { return isInternalLinkage(Linkage); }
bool hasPrivateLinkage() const { return isPrivateLinkage(Linkage); }		bool hasPrivateLinkage() const { return isPrivateLinkage(Linkage); }
bool hasLinkerPrivateLinkage() const { return isLinkerPrivateLinkage(Linkage); }		bool hasLinkerPrivateLinkage() const { return isLinkerPrivateLinkage(Linkage); }
bool hasLinkerPrivateWeakLinkage() const {		bool hasLinkerPrivateWeakLinkage() const {
return isLinkerPrivateWeakLinkage(Linkage);		return isLinkerPrivateWeakLinkage(Linkage);
}		}
bool hasLocalLinkage() const { return isLocalLinkage(Linkage); }		bool hasLocalLinkage() const { return isLocalLinkage(Linkage); }
bool hasDLLImportLinkage() const { return isDLLImportLinkage(Linkage); }
bool hasDLLExportLinkage() const { return isDLLExportLinkage(Linkage); }
bool hasExternalWeakLinkage() const { return isExternalWeakLinkage(Linkage); }		bool hasExternalWeakLinkage() const { return isExternalWeakLinkage(Linkage); }
bool hasCommonLinkage() const { return isCommonLinkage(Linkage); }		bool hasCommonLinkage() const { return isCommonLinkage(Linkage); }

void setLinkage(LinkageTypes LT) { Linkage = LT; }		void setLinkage(LinkageTypes LT) { Linkage = LT; }
LinkageTypes getLinkage() const { return Linkage; }		LinkageTypes getLinkage() const { return Linkage; }

bool isDiscardableIfUnused() const {		bool isDiscardableIfUnused() const {
return isDiscardableIfUnused(Linkage);		return isDiscardableIfUnused(Linkage);
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

include/llvm/IR/GlobalVariable.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	class GlobalVariable : public GlobalValue, public ilist_node<GlobalVariable> {
bool isConstantGlobal : 1; // Is this a global constant?		bool isConstantGlobal : 1; // Is this a global constant?
unsigned threadLocalMode : 3; // Is this symbol "Thread Local",		unsigned threadLocalMode : 3; // Is this symbol "Thread Local",
// if so, what is the desired		// if so, what is the desired
// model?		// model?
bool isExternallyInitializedConstant : 1; // Is this a global whose value		bool isExternallyInitializedConstant : 1; // Is this a global whose value
// can change from its initial		// can change from its initial
// value before global		// value before global
// initializers are run?		// initializers are run?
		unsigned dllStorageClass : 2; // DLL storage class

public:		public:
// allocate space for exactly one operand		// allocate space for exactly one operand
void *operator new(size_t s) {		void *operator new(size_t s) {
return User::operator new(s, 1);		return User::operator new(s, 1);
}		}

enum ThreadLocalMode {		enum ThreadLocalMode {
NotThreadLocal = 0,		NotThreadLocal = 0,
GeneralDynamicTLSModel,		GeneralDynamicTLSModel,
LocalDynamicTLSModel,		LocalDynamicTLSModel,
InitialExecTLSModel,		InitialExecTLSModel,
LocalExecTLSModel		LocalExecTLSModel
};		};

		/// @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.
		};

/// GlobalVariable ctor - If a parent module is specified, the global is		/// GlobalVariable ctor - If a parent module is specified, the global is
/// automatically inserted into the end of the specified modules global list.		/// automatically inserted into the end of the specified modules global list.
GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,		GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
Constant *Initializer = 0, const Twine &Name = "",		Constant *Initializer = 0, const Twine &Name = "",
ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,		ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
bool isExternallyInitialized = false);		bool isExternallyInitialized = false);
/// GlobalVariable ctor - This creates a global and inserts it before the		/// GlobalVariable ctor - This creates a global and inserts it before the
/// specified other global.		/// specified other global.
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines	public:
void setThreadLocal(bool Val) {		void setThreadLocal(bool Val) {
threadLocalMode = Val ? GeneralDynamicTLSModel : NotThreadLocal;		threadLocalMode = Val ? GeneralDynamicTLSModel : NotThreadLocal;
}		}
void setThreadLocalMode(ThreadLocalMode Val) { threadLocalMode = Val; }		void setThreadLocalMode(ThreadLocalMode Val) { threadLocalMode = Val; }
ThreadLocalMode getThreadLocalMode() const {		ThreadLocalMode getThreadLocalMode() const {
return static_cast<ThreadLocalMode>(threadLocalMode);		return static_cast<ThreadLocalMode>(threadLocalMode);
}		}

		DLLStorageClassTypes getDLLStorageClass() const {
		return DLLStorageClassTypes(dllStorageClass);
		}
		bool hasDLLImportStorageClass() const {
		return dllStorageClass == DLLImportStorageClass;
		}
		bool hasDLLExportStorageClass() const {
		return dllStorageClass == DLLExportStorageClass;
		}
		void setDLLStorageClass(DLLStorageClassTypes C) { dllStorageClass = C; }

bool isExternallyInitialized() const {		bool isExternallyInitialized() const {
return isExternallyInitializedConstant;		return isExternallyInitializedConstant;
}		}
void setExternallyInitialized(bool Val) {		void setExternallyInitialized(bool Val) {
isExternallyInitializedConstant = Val;		isExternallyInitializedConstant = Val;
}		}

/// copyAttributesFrom - copy all additional attributes (those not needed to		/// copyAttributesFrom - copy all additional attributes (those not needed to
Show All 33 Lines

lib/AsmParser/LLParser.cpp

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines	while (1) {
case lltok::kw_linker_private_weak_def_auto: // FIXME: backwards compat.		case lltok::kw_linker_private_weak_def_auto: // FIXME: backwards compat.
case lltok::kw_internal: // OptionalLinkage		case lltok::kw_internal: // OptionalLinkage
case lltok::kw_weak: // OptionalLinkage		case lltok::kw_weak: // OptionalLinkage
case lltok::kw_weak_odr: // OptionalLinkage		case lltok::kw_weak_odr: // OptionalLinkage
case lltok::kw_linkonce: // OptionalLinkage		case lltok::kw_linkonce: // OptionalLinkage
case lltok::kw_linkonce_odr: // OptionalLinkage		case lltok::kw_linkonce_odr: // OptionalLinkage
case lltok::kw_linkonce_odr_auto_hide: // OptionalLinkage		case lltok::kw_linkonce_odr_auto_hide: // OptionalLinkage
case lltok::kw_appending: // OptionalLinkage		case lltok::kw_appending: // OptionalLinkage
case lltok::kw_dllexport: // OptionalLinkage
case lltok::kw_common: // OptionalLinkage		case lltok::kw_common: // OptionalLinkage
case lltok::kw_dllimport: // OptionalLinkage
case lltok::kw_extern_weak: // OptionalLinkage		case lltok::kw_extern_weak: // OptionalLinkage
case lltok::kw_external: { // OptionalLinkage		case lltok::kw_external: { // OptionalLinkage
unsigned Linkage, Visibility;		unsigned Linkage, Visibility;
if (ParseOptionalLinkage(Linkage) \|\|		if (ParseOptionalLinkage(Linkage) \|\|
ParseOptionalVisibility(Visibility) \|\|		ParseOptionalVisibility(Visibility) \|\|
ParseGlobal("", SMLoc(), Linkage, true, Visibility))		ParseGlobal("", SMLoc(), Linkage, true, Visibility))
return true;		return true;
break;		break;
▲ Show 20 Lines • Show All 456 Lines • ▼ Show 20 Lines	if (ParseOptionalThreadLocal(TLM) \|\|
&IsExternallyInitializedLoc) \|\|		&IsExternallyInitializedLoc) \|\|
ParseGlobalType(IsConstant) \|\|		ParseGlobalType(IsConstant) \|\|
ParseType(Ty, TyLoc))		ParseType(Ty, TyLoc))
return true;		return true;

// If the linkage is specified and is external, then no initializer is		// If the linkage is specified and is external, then no initializer is
// present.		// present.
Constant *Init = 0;		Constant *Init = 0;
if (!HasLinkage \|\| (Linkage != GlobalValue::DLLImportLinkage &&		if (!HasLinkage \|\| (Linkage != GlobalValue::ExternalWeakLinkage &&
Linkage != GlobalValue::ExternalWeakLinkage &&
Linkage != GlobalValue::ExternalLinkage)) {		Linkage != GlobalValue::ExternalLinkage)) {
if (ParseGlobalValue(Ty, Init))		if (ParseGlobalValue(Ty, Init))
return true;		return true;
}		}

if (Ty->isFunctionTy() \|\| Ty->isLabelTy())		if (Ty->isFunctionTy() \|\| Ty->isLabelTy())
return Error(TyLoc, "invalid type for global variable");		return Error(TyLoc, "invalid type for global variable");

▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines	if (Lex.getKind() == lltok::kw_section) {
Lex.Lex();		Lex.Lex();
GV->setSection(Lex.getStrVal());		GV->setSection(Lex.getStrVal());
if (ParseToken(lltok::StringConstant, "expected global section string"))		if (ParseToken(lltok::StringConstant, "expected global section string"))
return true;		return true;
} else if (Lex.getKind() == lltok::kw_align) {		} else if (Lex.getKind() == lltok::kw_align) {
unsigned Alignment;		unsigned Alignment;
if (ParseOptionalAlignment(Alignment)) return true;		if (ParseOptionalAlignment(Alignment)) return true;
GV->setAlignment(Alignment);		GV->setAlignment(Alignment);
		} else if (Lex.getKind() == lltok::kw_dllimport) {
		Lex.Lex();
		GV->setDLLStorageClass(GlobalVariable::DLLImportStorageClass);
		} else if (Lex.getKind() == lltok::kw_dllexport) {
		Lex.Lex();
		GV->setDLLStorageClass(GlobalVariable::DLLExportStorageClass);
} else {		} else {
TokError("unknown global variable property!");		TokError("unknown global variable property!");
}		}
}		}

return false;		return false;
}		}

▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines	case lltok::kw_alignstack: {
return true;		return true;
}		}
B.addStackAlignmentAttr(Alignment);		B.addStackAlignmentAttr(Alignment);
continue;		continue;
}		}
case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;		case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;		case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;		case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;
		case lltok::kw_dllexport: B.addAttribute(Attribute::DLLExport); break;
		case lltok::kw_dllimport: B.addAttribute(Attribute::DLLImport); break;
case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;		case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;		case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;		case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;		case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;		case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
case lltok::kw_noimplicitfloat: B.addAttribute(Attribute::NoImplicitFloat); break;		case lltok::kw_noimplicitfloat: B.addAttribute(Attribute::NoImplicitFloat); break;
case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;		case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;		case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
▲ Show 20 Lines • Show All 343 Lines • ▼ Show 20 Lines
/// ::= 'internal'		/// ::= 'internal'
/// ::= 'weak'		/// ::= 'weak'
/// ::= 'weak_odr'		/// ::= 'weak_odr'
/// ::= 'linkonce'		/// ::= 'linkonce'
/// ::= 'linkonce_odr'		/// ::= 'linkonce_odr'
/// ::= 'linkonce_odr_auto_hide'		/// ::= 'linkonce_odr_auto_hide'
/// ::= 'available_externally'		/// ::= 'available_externally'
/// ::= 'appending'		/// ::= 'appending'
/// ::= 'dllexport'
/// ::= 'common'		/// ::= 'common'
/// ::= 'dllimport'
/// ::= 'extern_weak'		/// ::= 'extern_weak'
/// ::= 'external'		/// ::= 'external'
bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {		bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
HasLinkage = false;		HasLinkage = false;
switch (Lex.getKind()) {		switch (Lex.getKind()) {
default: Res=GlobalValue::ExternalLinkage; return false;		default: Res=GlobalValue::ExternalLinkage; return false;
case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;		case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;		case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;
case lltok::kw_linker_private_weak:		case lltok::kw_linker_private_weak:
Res = GlobalValue::LinkerPrivateWeakLinkage;		Res = GlobalValue::LinkerPrivateWeakLinkage;
break;		break;
case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;		case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;		case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break;
case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;		case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break;
case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;		case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break;
case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;		case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break;
case lltok::kw_linkonce_odr_auto_hide:		case lltok::kw_linkonce_odr_auto_hide:
case lltok::kw_linker_private_weak_def_auto: // FIXME: For backwards compat.		case lltok::kw_linker_private_weak_def_auto: // FIXME: For backwards compat.
Res = GlobalValue::LinkOnceODRAutoHideLinkage;		Res = GlobalValue::LinkOnceODRAutoHideLinkage;
break;		break;
case lltok::kw_available_externally:		case lltok::kw_available_externally:
Res = GlobalValue::AvailableExternallyLinkage;		Res = GlobalValue::AvailableExternallyLinkage;
break;		break;
case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;		case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break;
case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break;
case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;		case lltok::kw_common: Res = GlobalValue::CommonLinkage; break;
case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break;
case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;		case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break;
case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;		case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break;
}		}
Lex.Lex();		Lex.Lex();
HasLinkage = true;		HasLinkage = true;
return false;		return false;
}		}

▲ Show 20 Lines • Show All 1,619 Lines • ▼ Show 20 Lines	if (ParseOptionalLinkage(Linkage) \|\|
ParseOptionalReturnAttrs(RetAttrs) \|\|		ParseOptionalReturnAttrs(RetAttrs) \|\|
ParseType(RetType, RetTypeLoc, true /void allowed/))		ParseType(RetType, RetTypeLoc, true /void allowed/))
return true;		return true;

// Verify that the linkage is ok.		// Verify that the linkage is ok.
switch ((GlobalValue::LinkageTypes)Linkage) {		switch ((GlobalValue::LinkageTypes)Linkage) {
case GlobalValue::ExternalLinkage:		case GlobalValue::ExternalLinkage:
break; // always ok.		break; // always ok.
case GlobalValue::DLLImportLinkage:
case GlobalValue::ExternalWeakLinkage:		case GlobalValue::ExternalWeakLinkage:
if (isDefine)		if (isDefine)
return Error(LinkageLoc, "invalid linkage for function definition");		return Error(LinkageLoc, "invalid linkage for function definition");
break;		break;
case GlobalValue::PrivateLinkage:		case GlobalValue::PrivateLinkage:
case GlobalValue::LinkerPrivateLinkage:		case GlobalValue::LinkerPrivateLinkage:
case GlobalValue::LinkerPrivateWeakLinkage:		case GlobalValue::LinkerPrivateWeakLinkage:
case GlobalValue::InternalLinkage:		case GlobalValue::InternalLinkage:
case GlobalValue::AvailableExternallyLinkage:		case GlobalValue::AvailableExternallyLinkage:
case GlobalValue::LinkOnceAnyLinkage:		case GlobalValue::LinkOnceAnyLinkage:
case GlobalValue::LinkOnceODRLinkage:		case GlobalValue::LinkOnceODRLinkage:
case GlobalValue::LinkOnceODRAutoHideLinkage:		case GlobalValue::LinkOnceODRAutoHideLinkage:
case GlobalValue::WeakAnyLinkage:		case GlobalValue::WeakAnyLinkage:
case GlobalValue::WeakODRLinkage:		case GlobalValue::WeakODRLinkage:
case GlobalValue::DLLExportLinkage:
if (!isDefine)		if (!isDefine)
return Error(LinkageLoc, "invalid linkage for function declaration");		return Error(LinkageLoc, "invalid linkage for function declaration");
break;		break;
case GlobalValue::AppendingLinkage:		case GlobalValue::AppendingLinkage:
case GlobalValue::CommonLinkage:		case GlobalValue::CommonLinkage:
return Error(LinkageLoc, "invalid function linkage type");		return Error(LinkageLoc, "invalid function linkage type");
}		}

▲ Show 20 Lines • Show All 1,415 Lines • Show Last 20 Lines

lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {		static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
switch (Val) {		switch (Val) {
default: // Map unknown/new linkages to external		default: // Map unknown/new linkages to external
case 0: return GlobalValue::ExternalLinkage;		case 0: return GlobalValue::ExternalLinkage;
case 1: return GlobalValue::WeakAnyLinkage;		case 1: return GlobalValue::WeakAnyLinkage;
case 2: return GlobalValue::AppendingLinkage;		case 2: return GlobalValue::AppendingLinkage;
case 3: return GlobalValue::InternalLinkage;		case 3: return GlobalValue::InternalLinkage;
case 4: return GlobalValue::LinkOnceAnyLinkage;		case 4: return GlobalValue::LinkOnceAnyLinkage;
case 5: return GlobalValue::DLLImportLinkage;
case 6: return GlobalValue::DLLExportLinkage;
case 7: return GlobalValue::ExternalWeakLinkage;		case 7: return GlobalValue::ExternalWeakLinkage;
case 8: return GlobalValue::CommonLinkage;		case 8: return GlobalValue::CommonLinkage;
case 9: return GlobalValue::PrivateLinkage;		case 9: return GlobalValue::PrivateLinkage;
case 10: return GlobalValue::WeakODRLinkage;		case 10: return GlobalValue::WeakODRLinkage;
case 11: return GlobalValue::LinkOnceODRLinkage;		case 11: return GlobalValue::LinkOnceODRLinkage;
case 12: return GlobalValue::AvailableExternallyLinkage;		case 12: return GlobalValue::AvailableExternallyLinkage;
case 13: return GlobalValue::LinkerPrivateLinkage;		case 13: return GlobalValue::LinkerPrivateLinkage;
case 14: return GlobalValue::LinkerPrivateWeakLinkage;		case 14: return GlobalValue::LinkerPrivateWeakLinkage;
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines	static SynchronizationScope GetDecodedSynchScope(unsigned Val) {
case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread;		case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread;
default: // Map unknown scopes to cross-thread.		default: // Map unknown scopes to cross-thread.
case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread;		case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread;
}		}
}		}

namespace llvm {		namespace llvm {
namespace {		namespace {
/// @brief A class for maintaining the slot number definition		/// @brief A class for maintaining the slot number definition
		compnerdUnsubmitted Not Done Reply Inline Actions missing return or break compnerd: missing return or break
/// as a placeholder for the actual definition for forward constants defs.		/// as a placeholder for the actual definition for forward constants defs.
		compnerdUnsubmitted Not Done Reply Inline Actions ditto compnerd: ditto
class ConstantPlaceHolder : public ConstantExpr {		class ConstantPlaceHolder : public ConstantExpr {
void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION;		void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION;
public:		public:
// allocate space for exactly one operand		// allocate space for exactly one operand
void *operator new(size_t s) {		void *operator new(size_t s) {
return User::operator new(s, 1);		return User::operator new(s, 1);
}		}
explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context)		explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context)
▲ Show 20 Lines • Show All 2,907 Lines • Show Last 20 Lines

lib/Bitcode/Writer/BitcodeWriter.cpp

	Show First 20 Lines • Show All 391 Lines • ▼ Show 20 Lines

	static unsigned getEncodedLinkage(const GlobalValue *GV) {			static unsigned getEncodedLinkage(const GlobalValue *GV) {
	switch (GV->getLinkage()) {			switch (GV->getLinkage()) {
	case GlobalValue::ExternalLinkage: return 0;			case GlobalValue::ExternalLinkage: return 0;
	case GlobalValue::WeakAnyLinkage: return 1;			case GlobalValue::WeakAnyLinkage: return 1;
	case GlobalValue::AppendingLinkage: return 2;			case GlobalValue::AppendingLinkage: return 2;
	case GlobalValue::InternalLinkage: return 3;			case GlobalValue::InternalLinkage: return 3;
	case GlobalValue::LinkOnceAnyLinkage: return 4;			case GlobalValue::LinkOnceAnyLinkage: return 4;
	case GlobalValue::DLLImportLinkage: return 5;
	case GlobalValue::DLLExportLinkage: return 6;
	case GlobalValue::ExternalWeakLinkage: return 7;			case GlobalValue::ExternalWeakLinkage: return 7;
	case GlobalValue::CommonLinkage: return 8;			case GlobalValue::CommonLinkage: return 8;
	case GlobalValue::PrivateLinkage: return 9;			case GlobalValue::PrivateLinkage: return 9;
	case GlobalValue::WeakODRLinkage: return 10;			case GlobalValue::WeakODRLinkage: return 10;
	case GlobalValue::LinkOnceODRLinkage: return 11;			case GlobalValue::LinkOnceODRLinkage: return 11;
	case GlobalValue::AvailableExternallyLinkage: return 12;			case GlobalValue::AvailableExternallyLinkage: return 12;
	case GlobalValue::LinkerPrivateLinkage: return 13;			case GlobalValue::LinkerPrivateLinkage: return 13;
	case GlobalValue::LinkerPrivateWeakLinkage: return 14;			case GlobalValue::LinkerPrivateWeakLinkage: return 14;
	▲ Show 20 Lines • Show All 1,611 Lines • Show Last 20 Lines

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Show First 20 Lines • Show All 234 Lines • ▼ Show 20 Lines	if (MAI->getWeakDefDirective() != 0) {
// .globl _foo		// .globl _foo
OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);		OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
//NOTE: linkonce is handled by the section the symbol was assigned to.		//NOTE: linkonce is handled by the section the symbol was assigned to.
} else {		} else {
// .weak _foo		// .weak _foo
OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak);		OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak);
}		}
break;		break;
case GlobalValue::DLLExportLinkage:
case GlobalValue::AppendingLinkage:		case GlobalValue::AppendingLinkage:
// FIXME: appending linkage variables should go into a section of		// FIXME: appending linkage variables should go into a section of
// their name or something. For now, just emit them as external.		// their name or something. For now, just emit them as external.
case GlobalValue::ExternalLinkage:		case GlobalValue::ExternalLinkage:
// If external or appending, declare as a global symbol.		// If external or appending, declare as a global symbol.
// .globl _foo		// .globl _foo
OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);		OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
break;		break;
▲ Show 20 Lines • Show All 1,971 Lines • Show Last 20 Lines

lib/ExecutionEngine/ExecutionEngine.cpp

Show First 20 Lines • Show All 1,193 Lines • ▼ Show 20 Lines	for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
// If this is the first time we've seen this global, it is the canonical		// If this is the first time we've seen this global, it is the canonical
// version.		// version.
if (!GVEntry) {		if (!GVEntry) {
GVEntry = GV;		GVEntry = GV;
continue;		continue;
}		}

// If the existing global is strong, never replace it.		// If the existing global is strong, never replace it.
if (GVEntry->hasExternalLinkage() \|\|		if (GVEntry->hasExternalLinkage())
GVEntry->hasDLLImportLinkage() \|\|
GVEntry->hasDLLExportLinkage())
continue;		continue;

// Otherwise, we know it's linkonce/weak, replace it if this is a strong		// Otherwise, we know it's linkonce/weak, replace it if this is a strong
// symbol. FIXME is this right for common?		// symbol. FIXME is this right for common?
if (GV->hasExternalLinkage() \|\| GVEntry->hasExternalWeakLinkage())		if (GV->hasExternalLinkage() \|\| GVEntry->hasExternalWeakLinkage())
GVEntry = GV;		GVEntry = GV;
}		}
}		}
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 1,393 Lines • ▼ Show 20 Lines	static void PrintLinkage(GlobalValue::LinkageTypes LT,
case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break;		case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break;
case GlobalValue::LinkOnceODRAutoHideLinkage:		case GlobalValue::LinkOnceODRAutoHideLinkage:
Out << "linkonce_odr_auto_hide ";		Out << "linkonce_odr_auto_hide ";
break;		break;
case GlobalValue::WeakAnyLinkage: Out << "weak "; break;		case GlobalValue::WeakAnyLinkage: Out << "weak "; break;
case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break;		case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break;
case GlobalValue::CommonLinkage: Out << "common "; break;		case GlobalValue::CommonLinkage: Out << "common "; break;
case GlobalValue::AppendingLinkage: Out << "appending "; break;		case GlobalValue::AppendingLinkage: Out << "appending "; break;
case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
case GlobalValue::DLLExportLinkage: Out << "dllexport "; break;
case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;		case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
case GlobalValue::AvailableExternallyLinkage:		case GlobalValue::AvailableExternallyLinkage:
Out << "available_externally ";		Out << "available_externally ";
break;		break;
}		}
}		}


▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
if (GV->hasSection()) {		if (GV->hasSection()) {
Out << ", section \"";		Out << ", section \"";
PrintEscapedString(GV->getSection(), Out);		PrintEscapedString(GV->getSection(), Out);
Out << '"';		Out << '"';
}		}
if (GV->getAlignment())		if (GV->getAlignment())
Out << ", align " << GV->getAlignment();		Out << ", align " << GV->getAlignment();

		switch (GV->getDLLStorageClass()) {
		case GlobalVariable::DefaultStorageClass: break;
		case GlobalVariable::DLLImportStorageClass: Out << ", dllimport"; break;
		case GlobalVariable::DLLExportStorageClass: Out << ", dllexport"; break;
		}

printInfoComment(*GV);		printInfoComment(*GV);
}		}

void AssemblyWriter::printAlias(const GlobalAlias *GA) {		void AssemblyWriter::printAlias(const GlobalAlias *GA) {
if (GA->isMaterializable())		if (GA->isMaterializable())
Out << "; Materializable\n";		Out << "; Materializable\n";

// Don't crash when dumping partially built GA		// Don't crash when dumping partially built GA
▲ Show 20 Lines • Show All 734 Lines • Show Last 20 Lines

lib/IR/Attributes.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines	std::string Attribute::getAsString(bool InAttrGrp) const {
if (hasAttribute(Attribute::SanitizeAddress))		if (hasAttribute(Attribute::SanitizeAddress))
return "sanitize_address";		return "sanitize_address";
if (hasAttribute(Attribute::AlwaysInline))		if (hasAttribute(Attribute::AlwaysInline))
return "alwaysinline";		return "alwaysinline";
if (hasAttribute(Attribute::Builtin))		if (hasAttribute(Attribute::Builtin))
return "builtin";		return "builtin";
if (hasAttribute(Attribute::ByVal))		if (hasAttribute(Attribute::ByVal))
return "byval";		return "byval";
		if (hasAttribute(Attribute::DLLExport))
		return "dllexport";
		if (hasAttribute(Attribute::DLLImport))
		return "dllimport";
if (hasAttribute(Attribute::InlineHint))		if (hasAttribute(Attribute::InlineHint))
return "inlinehint";		return "inlinehint";
if (hasAttribute(Attribute::InReg))		if (hasAttribute(Attribute::InReg))
return "inreg";		return "inreg";
if (hasAttribute(Attribute::MinSize))		if (hasAttribute(Attribute::MinSize))
return "minsize";		return "minsize";
if (hasAttribute(Attribute::Naked))		if (hasAttribute(Attribute::Naked))
return "naked";		return "naked";
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines	uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
case Attribute::NoDuplicate: return 1ULL << 34;		case Attribute::NoDuplicate: return 1ULL << 34;
case Attribute::StackProtectStrong: return 1ULL << 35;		case Attribute::StackProtectStrong: return 1ULL << 35;
case Attribute::SanitizeThread: return 1ULL << 36;		case Attribute::SanitizeThread: return 1ULL << 36;
case Attribute::SanitizeMemory: return 1ULL << 37;		case Attribute::SanitizeMemory: return 1ULL << 37;
case Attribute::NoBuiltin: return 1ULL << 38;		case Attribute::NoBuiltin: return 1ULL << 38;
case Attribute::Returned: return 1ULL << 39;		case Attribute::Returned: return 1ULL << 39;
case Attribute::Cold: return 1ULL << 40;		case Attribute::Cold: return 1ULL << 40;
case Attribute::Builtin: return 1ULL << 41;		case Attribute::Builtin: return 1ULL << 41;
		case Attribute::DLLExport: return 1ULL << 42;
		case Attribute::DLLImport: return 1ULL << 43;
}		}
llvm_unreachable("Unsupported attribute type");		llvm_unreachable("Unsupported attribute type");
}		}

//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
// AttributeSetNode Definition		// AttributeSetNode Definition
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

▲ Show 20 Lines • Show All 751 Lines • Show Last 20 Lines

lib/IR/Core.cpp

Show First 20 Lines • Show All 1,120 Lines • ▼ Show 20 Lines	LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
case GlobalValue::InternalLinkage:		case GlobalValue::InternalLinkage:
return LLVMInternalLinkage;		return LLVMInternalLinkage;
case GlobalValue::PrivateLinkage:		case GlobalValue::PrivateLinkage:
return LLVMPrivateLinkage;		return LLVMPrivateLinkage;
case GlobalValue::LinkerPrivateLinkage:		case GlobalValue::LinkerPrivateLinkage:
return LLVMLinkerPrivateLinkage;		return LLVMLinkerPrivateLinkage;
case GlobalValue::LinkerPrivateWeakLinkage:		case GlobalValue::LinkerPrivateWeakLinkage:
return LLVMLinkerPrivateWeakLinkage;		return LLVMLinkerPrivateWeakLinkage;
case GlobalValue::DLLImportLinkage:
return LLVMDLLImportLinkage;
case GlobalValue::DLLExportLinkage:
return LLVMDLLExportLinkage;
case GlobalValue::ExternalWeakLinkage:		case GlobalValue::ExternalWeakLinkage:
return LLVMExternalWeakLinkage;		return LLVMExternalWeakLinkage;
case GlobalValue::CommonLinkage:		case GlobalValue::CommonLinkage:
return LLVMCommonLinkage;		return LLVMCommonLinkage;
}		}

llvm_unreachable("Invalid GlobalValue linkage!");		llvm_unreachable("Invalid GlobalValue linkage!");
}		}
Show All 33 Lines	case LLVMPrivateLinkage:
GV->setLinkage(GlobalValue::PrivateLinkage);		GV->setLinkage(GlobalValue::PrivateLinkage);
break;		break;
case LLVMLinkerPrivateLinkage:		case LLVMLinkerPrivateLinkage:
GV->setLinkage(GlobalValue::LinkerPrivateLinkage);		GV->setLinkage(GlobalValue::LinkerPrivateLinkage);
break;		break;
case LLVMLinkerPrivateWeakLinkage:		case LLVMLinkerPrivateWeakLinkage:
GV->setLinkage(GlobalValue::LinkerPrivateWeakLinkage);		GV->setLinkage(GlobalValue::LinkerPrivateWeakLinkage);
break;		break;
case LLVMDLLImportLinkage:
GV->setLinkage(GlobalValue::DLLImportLinkage);
break;
case LLVMDLLExportLinkage:
GV->setLinkage(GlobalValue::DLLExportLinkage);
break;
case LLVMExternalWeakLinkage:		case LLVMExternalWeakLinkage:
GV->setLinkage(GlobalValue::ExternalWeakLinkage);		GV->setLinkage(GlobalValue::ExternalWeakLinkage);
break;		break;
case LLVMGhostLinkage:		case LLVMGhostLinkage:
DEBUG(errs()		DEBUG(errs()
<< "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");		<< "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
break;		break;
case LLVMCommonLinkage:		case LLVMCommonLinkage:
▲ Show 20 Lines • Show All 1,371 Lines • Show Last 20 Lines

lib/IR/Globals.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines	GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
const Twine &Name, ThreadLocalMode TLMode,		const Twine &Name, ThreadLocalMode TLMode,
unsigned AddressSpace,		unsigned AddressSpace,
bool isExternallyInitialized)		bool isExternallyInitialized)
: GlobalValue(PointerType::get(Ty, AddressSpace),		: GlobalValue(PointerType::get(Ty, AddressSpace),
Value::GlobalVariableVal,		Value::GlobalVariableVal,
OperandTraits<GlobalVariable>::op_begin(this),		OperandTraits<GlobalVariable>::op_begin(this),
InitVal != 0, Link, Name),		InitVal != 0, Link, Name),
isConstantGlobal(constant), threadLocalMode(TLMode),		isConstantGlobal(constant), threadLocalMode(TLMode),
isExternallyInitializedConstant(isExternallyInitialized) {		isExternallyInitializedConstant(isExternallyInitialized),
		dllStorageClass(DefaultStorageClass) {
if (InitVal) {		if (InitVal) {
assert(InitVal->getType() == Ty &&		assert(InitVal->getType() == Ty &&
"Initializer should be the same type as the GlobalVariable!");		"Initializer should be the same type as the GlobalVariable!");
Op<0>() = InitVal;		Op<0>() = InitVal;
}		}

LeakDetector::addGarbageObject(this);		LeakDetector::addGarbageObject(this);
}		}

GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,		GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
LinkageTypes Link, Constant *InitVal,		LinkageTypes Link, Constant *InitVal,
const Twine &Name,		const Twine &Name,
GlobalVariable *Before, ThreadLocalMode TLMode,		GlobalVariable *Before, ThreadLocalMode TLMode,
unsigned AddressSpace,		unsigned AddressSpace,
bool isExternallyInitialized)		bool isExternallyInitialized)
: GlobalValue(PointerType::get(Ty, AddressSpace),		: GlobalValue(PointerType::get(Ty, AddressSpace),
Value::GlobalVariableVal,		Value::GlobalVariableVal,
OperandTraits<GlobalVariable>::op_begin(this),		OperandTraits<GlobalVariable>::op_begin(this),
InitVal != 0, Link, Name),		InitVal != 0, Link, Name),
isConstantGlobal(constant), threadLocalMode(TLMode),		isConstantGlobal(constant), threadLocalMode(TLMode),
isExternallyInitializedConstant(isExternallyInitialized) {		isExternallyInitializedConstant(isExternallyInitialized),
		dllStorageClass(DefaultStorageClass) {
if (InitVal) {		if (InitVal) {
assert(InitVal->getType() == Ty &&		assert(InitVal->getType() == Ty &&
"Initializer should be the same type as the GlobalVariable!");		"Initializer should be the same type as the GlobalVariable!");
Op<0>() = InitVal;		Op<0>() = InitVal;
}		}

LeakDetector::addGarbageObject(this);		LeakDetector::addGarbageObject(this);

▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

lib/IR/Verifier.cpp

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines	void Verifier::visit(Instruction &I) {
InstVisitor<Verifier>::visit(I);		InstVisitor<Verifier>::visit(I);
}		}


void Verifier::visitGlobalValue(GlobalValue &GV) {		void Verifier::visitGlobalValue(GlobalValue &GV) {
Assert1(!GV.isDeclaration() \|\|		Assert1(!GV.isDeclaration() \|\|
GV.isMaterializable() \|\|		GV.isMaterializable() \|\|
GV.hasExternalLinkage() \|\|		GV.hasExternalLinkage() \|\|
GV.hasDLLImportLinkage() \|\|
GV.hasExternalWeakLinkage() \|\|		GV.hasExternalWeakLinkage() \|\|
(isa<GlobalAlias>(GV) &&		(isa<GlobalAlias>(GV) &&
(GV.hasLocalLinkage() \|\| GV.hasWeakLinkage())),		(GV.hasLocalLinkage() \|\| GV.hasWeakLinkage())),
"Global is external, but doesn't have external or dllimport or weak linkage!",		"Global is external, but doesn't have external or weak linkage!",
&GV);		&GV);

Assert1(!GV.hasDLLImportLinkage() \|\| GV.isDeclaration(),
"Global is marked as dllimport, but not external", &GV);

Assert1(!GV.hasAppendingLinkage() \|\| isa<GlobalVariable>(GV),		Assert1(!GV.hasAppendingLinkage() \|\| isa<GlobalVariable>(GV),
"Only global variables can have appending linkage!", &GV);		"Only global variables can have appending linkage!", &GV);

if (GV.hasAppendingLinkage()) {		if (GV.hasAppendingLinkage()) {
GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);		GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
Assert1(GVar && GVar->getType()->getElementType()->isArrayTy(),		Assert1(GVar && GVar->getType()->getElementType()->isArrayTy(),
"Only global arrays can have appending linkage!", GVar);		"Only global arrays can have appending linkage!", GVar);
}		}
Show All 13 Lines	if (GV.hasInitializer()) {
// cannot be constant.		// cannot be constant.
if (GV.hasCommonLinkage()) {		if (GV.hasCommonLinkage()) {
Assert1(GV.getInitializer()->isNullValue(),		Assert1(GV.getInitializer()->isNullValue(),
"'common' global must have a zero initializer!", &GV);		"'common' global must have a zero initializer!", &GV);
Assert1(!GV.isConstant(), "'common' global may not be marked constant!",		Assert1(!GV.isConstant(), "'common' global may not be marked constant!",
&GV);		&GV);
}		}
} else {		} else {
Assert1(GV.hasExternalLinkage() \|\| GV.hasDLLImportLinkage() \|\|		Assert1(GV.hasExternalLinkage() \|\| GV.hasExternalWeakLinkage(),
GV.hasExternalWeakLinkage(),
"invalid linkage type for global declaration", &GV);		"invalid linkage type for global declaration", &GV);
}		}

if (GV.hasName() && (GV.getName() == "llvm.global_ctors" \|\|		if (GV.hasName() && (GV.getName() == "llvm.global_ctors" \|\|
GV.getName() == "llvm.global_dtors")) {		GV.getName() == "llvm.global_dtors")) {
Assert1(!GV.hasInitializer() \|\| GV.hasAppendingLinkage(),		Assert1(!GV.hasInitializer() \|\| GV.hasAppendingLinkage(),
"invalid linkage for intrinsic global variable", &GV);		"invalid linkage for intrinsic global variable", &GV);
// Don't worry about emitting an error for it not being an array,		// Don't worry about emitting an error for it not being an array,
Show All 28 Lines	if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
isa<GlobalVariable>(V) \|\| isa<Function>(V) \|\| isa<GlobalAlias>(V),		isa<GlobalVariable>(V) \|\| isa<Function>(V) \|\| isa<GlobalAlias>(V),
"invalid llvm.used member", V);		"invalid llvm.used member", V);
Assert1(V->hasName(), "members of llvm.used must be named", V);		Assert1(V->hasName(), "members of llvm.used must be named", V);
}		}
}		}
}		}
}		}

		Assert1(!GV.hasDLLImportStorageClass() \|\| GV.isDeclaration() \|\|
		GV.getLinkage() == GlobalValue::ExternalLinkage \|\|
		GV.getLinkage() == GlobalValue::AvailableExternallyLinkage,
		"Global is marked as dllimport, but not external", &GV);

visitGlobalValue(GV);		visitGlobalValue(GV);
}		}

void Verifier::visitGlobalAlias(GlobalAlias &GA) {		void Verifier::visitGlobalAlias(GlobalAlias &GA) {
Assert1(!GA.getName().empty(),		Assert1(!GA.getName().empty(),
"Alias name cannot be empty!", &GA);		"Alias name cannot be empty!", &GA);
Assert1(GA.hasExternalLinkage() \|\| GA.hasLocalLinkage() \|\|		Assert1(GA.hasExternalLinkage() \|\| GA.hasLocalLinkage() \|\|
GA.hasWeakLinkage(),		GA.hasWeakLinkage(),
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines	if (I->getKindAsEnum() == Attribute::NoReturn \|\|
I->getKindAsEnum() == Attribute::ReturnsTwice \|\|		I->getKindAsEnum() == Attribute::ReturnsTwice \|\|
I->getKindAsEnum() == Attribute::SanitizeAddress \|\|		I->getKindAsEnum() == Attribute::SanitizeAddress \|\|
I->getKindAsEnum() == Attribute::SanitizeThread \|\|		I->getKindAsEnum() == Attribute::SanitizeThread \|\|
I->getKindAsEnum() == Attribute::SanitizeMemory \|\|		I->getKindAsEnum() == Attribute::SanitizeMemory \|\|
I->getKindAsEnum() == Attribute::MinSize \|\|		I->getKindAsEnum() == Attribute::MinSize \|\|
I->getKindAsEnum() == Attribute::NoDuplicate \|\|		I->getKindAsEnum() == Attribute::NoDuplicate \|\|
I->getKindAsEnum() == Attribute::Builtin \|\|		I->getKindAsEnum() == Attribute::Builtin \|\|
I->getKindAsEnum() == Attribute::NoBuiltin \|\|		I->getKindAsEnum() == Attribute::NoBuiltin \|\|
I->getKindAsEnum() == Attribute::Cold) {		I->getKindAsEnum() == Attribute::Cold \|\|
		I->getKindAsEnum() == Attribute::DLLImport \|\|
		I->getKindAsEnum() == Attribute::DLLExport) {
if (!isFunction) {		if (!isFunction) {
CheckFailed("Attribute '" + I->getAsString() +		CheckFailed("Attribute '" + I->getAsString() +
"' only applies to functions!", V);		"' only applies to functions!", V);
return;		return;
}		}
} else if (isFunction) {		} else if (isFunction) {
CheckFailed("Attribute '" + I->getAsString() +		CheckFailed("Attribute '" + I->getAsString() +
"' does not apply to functions!", V);		"' does not apply to functions!", V);
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines	Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,
Attribute::ReadOnly)),		Attribute::ReadOnly)),
"Attributes 'readnone and readonly' are incompatible!", V);		"Attributes 'readnone and readonly' are incompatible!", V);

Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,		Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,
Attribute::NoInline) &&		Attribute::NoInline) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex,		Attrs.hasAttribute(AttributeSet::FunctionIndex,
Attribute::AlwaysInline)),		Attribute::AlwaysInline)),
"Attributes 'noinline and alwaysinline' are incompatible!", V);		"Attributes 'noinline and alwaysinline' are incompatible!", V);

		Assert1(!(Attrs.hasAttribute(AttributeSet::FunctionIndex,
		Attribute::DLLImport) &&
		Attrs.hasAttribute(AttributeSet::FunctionIndex,
		Attribute::DLLExport)),
		"Attributes 'dllimport and dllexport' are incompatible!", V);
}		}

bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {		bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {
if (Attrs.getNumSlots() == 0)		if (Attrs.getNumSlots() == 0)
return true;		return true;

unsigned LastSlot = Attrs.getNumSlots() - 1;		unsigned LastSlot = Attrs.getNumSlots() - 1;
unsigned LastIndex = Attrs.getSlotIndex(LastSlot);		unsigned LastIndex = Attrs.getSlotIndex(LastSlot);
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines	for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end();
if (!isLLVMdotName)		if (!isLLVMdotName)
Assert2(!I->getType()->isMetadataTy(),		Assert2(!I->getType()->isMetadataTy(),
"Function takes metadata but isn't an intrinsic", I, &F);		"Function takes metadata but isn't an intrinsic", I, &F);
}		}

if (F.isMaterializable()) {		if (F.isMaterializable()) {
// Function has a body somewhere we can't see.		// Function has a body somewhere we can't see.
} else if (F.isDeclaration()) {		} else if (F.isDeclaration()) {
Assert1(F.hasExternalLinkage() \|\| F.hasDLLImportLinkage() \|\|		Assert1(F.hasExternalLinkage() \|\| F.hasExternalWeakLinkage(),
F.hasExternalWeakLinkage(),
"invalid linkage type for function declaration", &F);		"invalid linkage type for function declaration", &F);
} else {		} else {
// Verify that this function (which has a body) is not named "llvm.*". It		// Verify that this function (which has a body) is not named "llvm.*". It
// is not legal to define intrinsics.		// is not legal to define intrinsics.
Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);		Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);

// Check the entry node		// Check the entry node
BasicBlock *Entry = &F.getEntryBlock();		BasicBlock *Entry = &F.getEntryBlock();
Show All 9 Lines	void Verifier::visitFunction(Function &F) {

// If this function is actually an intrinsic, verify that it is only used in		// If this function is actually an intrinsic, verify that it is only used in
// direct call/invokes, never having its "address taken".		// direct call/invokes, never having its "address taken".
if (F.getIntrinsicID()) {		if (F.getIntrinsicID()) {
const User *U;		const User *U;
if (F.hasAddressTaken(&U))		if (F.hasAddressTaken(&U))
Assert1(0, "Invalid user of intrinsic instruction!", U);		Assert1(0, "Invalid user of intrinsic instruction!", U);
}		}

		Assert1(!F.hasFnAttribute(Attribute::DLLImport) \|\| F.isDeclaration() \|\|
		F.getLinkage() == GlobalValue::AvailableExternallyLinkage,
		"Function is marked as dllimport, but not external.", &F);
}		}

// verifyBasicBlock - Verify that a basic block is well formed...		// verifyBasicBlock - Verify that a basic block is well formed...
//		//
void Verifier::visitBasicBlock(BasicBlock &BB) {		void Verifier::visitBasicBlock(BasicBlock &BB) {
InstsInThisBlock.clear();		InstsInThisBlock.clear();

// Ensure that basic blocks have terminators!		// Ensure that basic blocks have terminators!
▲ Show 20 Lines • Show All 1,258 Lines • Show Last 20 Lines

lib/Linker/LinkModules.cpp

Show First 20 Lines • Show All 503 Lines • ▼ Show 20 Lines	if (b == GlobalValue::HiddenVisibility)
return true;		return true;
if (a == GlobalValue::ProtectedVisibility)		if (a == GlobalValue::ProtectedVisibility)
return false;		return false;
if (b == GlobalValue::ProtectedVisibility)		if (b == GlobalValue::ProtectedVisibility)
return true;		return true;
return false;		return false;
}		}

		static bool hasDLLImport(const GlobalValue *G) {
		if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
		return GV->hasDLLImportStorageClass();

		if (const Function *F = dyn_cast<Function>(G))
		return F->hasFnAttribute(Attribute::DLLImport);

		return false;
		}

Value ValueMaterializerTy::materializeValueFor(Value V) {		Value ValueMaterializerTy::materializeValueFor(Value V) {
Function *SF = dyn_cast<Function>(V);		Function *SF = dyn_cast<Function>(V);
if (!SF)		if (!SF)
return NULL;		return NULL;

Function *DF = Function::Create(TypeMap.get(SF->getFunctionType()),		Function *DF = Function::Create(TypeMap.get(SF->getFunctionType()),
SF->getLinkage(), SF->getName(), DstM);		SF->getLinkage(), SF->getName(), DstM);
copyGVAttributes(DF, SF);		copyGVAttributes(DF, SF);
Show All 13 Lines	bool ModuleLinker::getLinkageResult(GlobalValue Dest, const GlobalValue Src,
GlobalValue::VisibilityTypes &Vis,		GlobalValue::VisibilityTypes &Vis,
bool &LinkFromSrc) {		bool &LinkFromSrc) {
assert(Dest && "Must have two globals being queried");		assert(Dest && "Must have two globals being queried");
assert(!Src->hasLocalLinkage() &&		assert(!Src->hasLocalLinkage() &&
"If Src has internal linkage, Dest shouldn't be set!");		"If Src has internal linkage, Dest shouldn't be set!");

bool SrcIsDeclaration = Src->isDeclaration() && !Src->isMaterializable();		bool SrcIsDeclaration = Src->isDeclaration() && !Src->isMaterializable();
bool DestIsDeclaration = Dest->isDeclaration();		bool DestIsDeclaration = Dest->isDeclaration();

if (SrcIsDeclaration) {		if (SrcIsDeclaration) {
// If Src is external or if both Src & Dest are external.. Just link the		// If Src is external or if both Src & Dest are external.. Just link the
// external globals, we aren't adding anything.		// external globals, we aren't adding anything.
if (Src->hasDLLImportLinkage()) {		if (hasDLLImport(Src)) {
// If one of GVs has DLLImport linkage, result should be dllimport'ed.		// If one of GVs is marked as DLLImport, result should be dllimport'ed.
if (DestIsDeclaration) {		if (DestIsDeclaration) {
LinkFromSrc = true;		LinkFromSrc = true;
LT = Src->getLinkage();		LT = Src->getLinkage();
}		}
} else if (Dest->hasExternalWeakLinkage()) {		} else if (Dest->hasExternalWeakLinkage()) {
// If the Dest is weak, use the source linkage.		// If the Dest is weak, use the source linkage.
LinkFromSrc = true;		LinkFromSrc = true;
LT = Src->getLinkage();		LT = Src->getLinkage();
} else {		} else {
LinkFromSrc = false;		LinkFromSrc = false;
LT = Dest->getLinkage();		LT = Dest->getLinkage();
}		}
} else if (DestIsDeclaration && !Dest->hasDLLImportLinkage()) {		} else if (DestIsDeclaration && !hasDLLImport(Dest)) {
// If Dest is external but Src is not:		// If Dest is external but Src is not:
LinkFromSrc = true;		LinkFromSrc = true;
LT = Src->getLinkage();		LT = Src->getLinkage();
} else if (Src->isWeakForLinker()) {		} else if (Src->isWeakForLinker()) {
// At this point we know that Dest has LinkOnce, External*, Weak, Common,		// At this point we know that Dest has LinkOnce, External*, Weak, Common,
// or DLL* linkage.		// or DLL* linkage.
if (Dest->hasExternalWeakLinkage() \|\|		if (Dest->hasExternalWeakLinkage() \|\|
Dest->hasAvailableExternallyLinkage() \|\|		Dest->hasAvailableExternallyLinkage() \|\|
Show All 10 Lines	if (SrcIsDeclaration) {
if (Src->hasExternalWeakLinkage()) {		if (Src->hasExternalWeakLinkage()) {
LinkFromSrc = false;		LinkFromSrc = false;
LT = Dest->getLinkage();		LT = Dest->getLinkage();
} else {		} else {
LinkFromSrc = true;		LinkFromSrc = true;
LT = GlobalValue::ExternalLinkage;		LT = GlobalValue::ExternalLinkage;
}		}
} else {		} else {
assert((Dest->hasExternalLinkage() \|\| Dest->hasDLLImportLinkage() \|\|		assert((Dest->hasExternalLinkage() \|\| Dest->hasExternalWeakLinkage()) &&
Dest->hasDLLExportLinkage() \|\| Dest->hasExternalWeakLinkage()) &&		(Src->hasExternalLinkage() \|\| Src->hasExternalWeakLinkage()) &&
(Src->hasExternalLinkage() \|\| Src->hasDLLImportLinkage() \|\|
Src->hasDLLExportLinkage() \|\| Src->hasExternalWeakLinkage()) &&
"Unexpected linkage type!");		"Unexpected linkage type!");
return emitError("Linking globals named '" + Src->getName() +		return emitError("Linking globals named '" + Src->getName() +
"': symbol multiply defined!");		"': symbol multiply defined!");
}		}

// Compute the visibility. We follow the rules in the System V Application		// Compute the visibility. We follow the rules in the System V Application
// Binary Interface.		// Binary Interface.
Vis = isLessConstraining(Src->getVisibility(), Dest->getVisibility()) ?		Vis = isLessConstraining(Src->getVisibility(), Dest->getVisibility()) ?
▲ Show 20 Lines • Show All 767 Lines • Show Last 20 Lines

lib/Target/CppBackend/CPPBackend.cpp

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Lines	void CppWriter::printLinkageType(GlobalValue::LinkageTypes LT) {
case GlobalValue::WeakAnyLinkage:		case GlobalValue::WeakAnyLinkage:
Out << "GlobalValue::WeakAnyLinkage"; break;		Out << "GlobalValue::WeakAnyLinkage"; break;
case GlobalValue::WeakODRLinkage:		case GlobalValue::WeakODRLinkage:
Out << "GlobalValue::WeakODRLinkage"; break;		Out << "GlobalValue::WeakODRLinkage"; break;
case GlobalValue::AppendingLinkage:		case GlobalValue::AppendingLinkage:
Out << "GlobalValue::AppendingLinkage"; break;		Out << "GlobalValue::AppendingLinkage"; break;
case GlobalValue::ExternalLinkage:		case GlobalValue::ExternalLinkage:
Out << "GlobalValue::ExternalLinkage"; break;		Out << "GlobalValue::ExternalLinkage"; break;
case GlobalValue::DLLImportLinkage:
Out << "GlobalValue::DLLImportLinkage"; break;
case GlobalValue::DLLExportLinkage:
Out << "GlobalValue::DLLExportLinkage"; break;
case GlobalValue::ExternalWeakLinkage:		case GlobalValue::ExternalWeakLinkage:
Out << "GlobalValue::ExternalWeakLinkage"; break;		Out << "GlobalValue::ExternalWeakLinkage"; break;
case GlobalValue::CommonLinkage:		case GlobalValue::CommonLinkage:
Out << "GlobalValue::CommonLinkage"; break;		Out << "GlobalValue::CommonLinkage"; break;
}		}
}		}

void CppWriter::printVisibilityType(GlobalValue::VisibilityTypes VisType) {		void CppWriter::printVisibilityType(GlobalValue::VisibilityTypes VisType) {
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines	#define HANDLE_ATTR(X) \
HANDLE_ATTR(NoRedZone);		HANDLE_ATTR(NoRedZone);
HANDLE_ATTR(NoImplicitFloat);		HANDLE_ATTR(NoImplicitFloat);
HANDLE_ATTR(Naked);		HANDLE_ATTR(Naked);
HANDLE_ATTR(InlineHint);		HANDLE_ATTR(InlineHint);
HANDLE_ATTR(ReturnsTwice);		HANDLE_ATTR(ReturnsTwice);
HANDLE_ATTR(UWTable);		HANDLE_ATTR(UWTable);
HANDLE_ATTR(NonLazyBind);		HANDLE_ATTR(NonLazyBind);
HANDLE_ATTR(MinSize);		HANDLE_ATTR(MinSize);
		HANDLE_ATTR(DLLExport);
		HANDLE_ATTR(DLLImport);
#undef HANDLE_ATTR		#undef HANDLE_ATTR

if (attrs.contains(Attribute::StackAlignment)) {		if (attrs.contains(Attribute::StackAlignment)) {
Out << "B.addStackAlignmentAttr(" << attrs.getStackAlignment()<<')';		Out << "B.addStackAlignmentAttr(" << attrs.getStackAlignment()<<')';
nl(Out);		nl(Out);
attrs.removeAttribute(Attribute::StackAlignment);		attrs.removeAttribute(Attribute::StackAlignment);
}		}

▲ Show 20 Lines • Show All 1,594 Lines • Show Last 20 Lines

lib/Target/Mangler.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "llvm/Target/Mangler.h"		#include "llvm/Target/Mangler.h"
#include "llvm/ADT/SmallString.h"		#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/Twine.h"		#include "llvm/ADT/Twine.h"
#include "llvm/IR/DataLayout.h"		#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"		#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"		#include "llvm/IR/Function.h"
		#include "llvm/IR/GlobalVariable.h"
#include "llvm/MC/MCAsmInfo.h"		#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"		#include "llvm/MC/MCContext.h"
#include "llvm/Target/TargetMachine.h"		#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
using namespace llvm;		using namespace llvm;

static bool isAcceptableChar(char C, bool AllowPeriod, bool AllowUTF8) {		static bool isAcceptableChar(char C, bool AllowPeriod, bool AllowUTF8) {
if ((C < 'a' \|\| C > 'z') &&		if ((C < 'a' \|\| C > 'z') &&
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Lines	void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
}		}
}		}

/// getSymbol - Return the MCSymbol for the specified global value. This		/// getSymbol - Return the MCSymbol for the specified global value. This
/// symbol is the main label that is the address of the global.		/// symbol is the main label that is the address of the global.
MCSymbol Mangler::getSymbol(const GlobalValue GV) {		MCSymbol Mangler::getSymbol(const GlobalValue GV) {
SmallString<60> NameStr;		SmallString<60> NameStr;
getNameWithPrefix(NameStr, GV, false);		getNameWithPrefix(NameStr, GV, false);

		if (const GlobalVariable *Var = dyn_cast<GlobalVariable>(GV)) {
		if (Var->hasDLLImportStorageClass()) {
		const char *Prefix = "__imp_";
		NameStr.insert(NameStr.begin(), Prefix, Prefix+strlen(Prefix));
		}
		}

return Context.GetOrCreateSymbol(NameStr.str());		return Context.GetOrCreateSymbol(NameStr.str());
}		}

lib/Target/X86/X86AsmPrinter.cpp

Show First 20 Lines • Show All 638 Lines • ▼ Show 20 Lines	if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho()) {

// Necessary for dllexport support		// Necessary for dllexport support
std::vector<const MCSymbol*> DLLExportedFns, DLLExportedGlobals;		std::vector<const MCSymbol*> DLLExportedFns, DLLExportedGlobals;

const TargetLoweringObjectFileCOFF &TLOFCOFF =		const TargetLoweringObjectFileCOFF &TLOFCOFF =
static_cast<const TargetLoweringObjectFileCOFF&>(getObjFileLowering());		static_cast<const TargetLoweringObjectFileCOFF&>(getObjFileLowering());

for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)		for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
if (I->hasDLLExportLinkage())		if (I->hasFnAttribute(Attribute::DLLExport))
DLLExportedFns.push_back(Mang->getSymbol(I));		DLLExportedFns.push_back(Mang->getSymbol(I));

for (Module::const_global_iterator I = M.global_begin(),		for (Module::const_global_iterator I = M.global_begin(),
E = M.global_end(); I != E; ++I)		E = M.global_end(); I != E; ++I)
if (I->hasDLLExportLinkage())		if (I->hasDLLExportStorageClass())
DLLExportedGlobals.push_back(Mang->getSymbol(I));		DLLExportedGlobals.push_back(Mang->getSymbol(I));

		for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
		I != E; ++I) {
		const GlobalValue *GV = I->getAliasedGlobal();
		while (const GlobalAlias *A = dyn_cast<GlobalAlias>(GV))
		GV = A->getAliasedGlobal();

		if (const Function *F = dyn_cast<Function>(GV)) {
		if (F->hasFnAttribute(Attribute::DLLExport))
		DLLExportedFns.push_back(Mang->getSymbol(I));
		} else if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV)) {
		if (V->hasDLLExportStorageClass())
		DLLExportedGlobals.push_back(Mang->getSymbol(I));
		}
		}

// Output linker support code for dllexported globals on windows.		// Output linker support code for dllexported globals on windows.
if (!DLLExportedGlobals.empty() \|\| !DLLExportedFns.empty()) {		if (!DLLExportedGlobals.empty() \|\| !DLLExportedFns.empty()) {
OutStreamer.SwitchSection(TLOFCOFF.getDrectveSection());		OutStreamer.SwitchSection(TLOFCOFF.getDrectveSection());
SmallString<128> name;		SmallString<128> name;
for (unsigned i = 0, e = DLLExportedGlobals.size(); i != e; ++i) {		for (unsigned i = 0, e = DLLExportedGlobals.size(); i != e; ++i) {
if (Subtarget->isTargetWindows())		if (Subtarget->isTargetWindows())
name = " /EXPORT:";		name = " /EXPORT:";
else		else
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lib/Target/X86/X86FastISel.cpp

Show First 20 Lines • Show All 629 Lines • ▼ Show 20 Lines	if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
if (TM.getCodeModel() != CodeModel::Small)		if (TM.getCodeModel() != CodeModel::Small)
return false;		return false;

// RIP-relative addresses can't have additional register operands.		// RIP-relative addresses can't have additional register operands.
if (Subtarget->isPICStyleRIPRel() &&		if (Subtarget->isPICStyleRIPRel() &&
(AM.Base.Reg != 0 \|\| AM.IndexReg != 0))		(AM.Base.Reg != 0 \|\| AM.IndexReg != 0))
return false;		return false;

		if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
		// Can't handle TLS.
		if (GVar->isThreadLocal())
		return false;

// Can't handle DLLImport.		// Can't handle DLLImport.
if (GV->hasDLLImportLinkage())		if (GVar->hasDLLImportStorageClass())
return false;		return false;
		}

// Can't handle TLS.		if (const Function *F = dyn_cast<Function>(GV))
if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))		// Can't handle DLLImport.
if (GVar->isThreadLocal())		if (F->hasFnAttribute(Attribute::DLLImport))
return false;		return false;

// Okay, we've committed to selecting this global. Set up the basic address.		// Okay, we've committed to selecting this global. Set up the basic address.
AM.GV = GV;		AM.GV = GV;

// No ABI requires an extra load for anything other than DLLImport, which		// No ABI requires an extra load for anything other than DLLImport, which
// we rejected above. Return a direct reference to the global.		// we rejected above. Return a direct reference to the global.
if (Subtarget->isPICStyleRIPRel()) {		if (Subtarget->isPICStyleRIPRel()) {
▲ Show 20 Lines • Show All 1,810 Lines • Show Last 20 Lines

lib/Target/X86/X86ISelLowering.cpp

This file is larger than 256 KB, so syntax highlighting is disabled by default.

Show First 20 Lines • Show All 2,265 Lines • ▼ Show 20 Lines	int NewReturnAddrFI =
MF.getFrameInfo()->CreateFixedObject(SlotSize, FPDiff-SlotSize, false);		MF.getFrameInfo()->CreateFixedObject(SlotSize, FPDiff-SlotSize, false);
SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);		SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);
Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,		Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
MachinePointerInfo::getFixedStack(NewReturnAddrFI),		MachinePointerInfo::getFixedStack(NewReturnAddrFI),
false, false, 0);		false, false, 0);
return Chain;		return Chain;
}		}

		static bool hasDLLImport(const GlobalValue *G) {
		if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
		return GV->hasDLLImportStorageClass();

		if (const Function *F = dyn_cast<Function>(G))
		return F->hasFnAttribute(Attribute::DLLImport);

		return false;
		}

SDValue		SDValue
X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,		X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const {		SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG;		SelectionDAG &DAG = CLI.DAG;
SDLoc &dl = CLI.DL;		SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;		SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals;		SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;		SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
▲ Show 20 Lines • Show All 280 Lines • ▼ Show 20 Lines	X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
} else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {		} else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
// If the callee is a GlobalAddress node (quite common, every direct call		// If the callee is a GlobalAddress node (quite common, every direct call
// is) turn it into a TargetGlobalAddress node so that legalize doesn't hack		// is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
// it.		// it.

// We should use extra load for direct calls to dllimported functions in		// We should use extra load for direct calls to dllimported functions in
// non-JIT mode.		// non-JIT mode.
const GlobalValue *GV = G->getGlobal();		const GlobalValue *GV = G->getGlobal();
if (!GV->hasDLLImportLinkage()) {		if (!hasDLLImport(GV)) {
unsigned char OpFlags = 0;		unsigned char OpFlags = 0;
bool ExtraLoad = false;		bool ExtraLoad = false;
unsigned WrapperKind = ISD::DELETED_NODE;		unsigned WrapperKind = ISD::DELETED_NODE;

// On ELF targets, in both X86-64 and X86-32 mode, direct calls to		// On ELF targets, in both X86-64 and X86-32 mode, direct calls to
// external symbols most go through the PLT in PIC mode. If the symbol		// external symbols most go through the PLT in PIC mode. If the symbol
// has hidden or protected visibility, or if it is static or local, then		// has hidden or protected visibility, or if it is static or local, then
// we don't need to use the PLT - we can directly call it.		// we don't need to use the PLT - we can directly call it.
▲ Show 20 Lines • Show All 16,065 Lines • Show Last 20 Lines

lib/Target/X86/X86Subtarget.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#define DEBUG_TYPE "subtarget"		#define DEBUG_TYPE "subtarget"
#include "X86Subtarget.h"		#include "X86Subtarget.h"
#include "X86InstrInfo.h"		#include "X86InstrInfo.h"
#include "llvm/IR/Attributes.h"		#include "llvm/IR/Attributes.h"
#include "llvm/IR/Function.h"		#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalValue.h"		#include "llvm/IR/GlobalValue.h"
		#include "llvm/IR/GlobalVariable.h"
#include "llvm/Support/Debug.h"		#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"		#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Host.h"		#include "llvm/Support/Host.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"		#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"		#include "llvm/Target/TargetOptions.h"

#define GET_SUBTARGETINFO_TARGET_DESC		#define GET_SUBTARGETINFO_TARGET_DESC
Show All 15 Lines	unsigned char X86Subtarget::ClassifyBlockAddressReference() const {

if (isPICStyleStubPIC()) // Darwin/32 in PIC mode.		if (isPICStyleStubPIC()) // Darwin/32 in PIC mode.
return X86II::MO_PIC_BASE_OFFSET;		return X86II::MO_PIC_BASE_OFFSET;

// Direct static reference to label.		// Direct static reference to label.
return X86II::MO_NO_FLAG;		return X86II::MO_NO_FLAG;
}		}

		static bool hasDLLImport(const GlobalValue *G) {
		if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
		return GV->hasDLLImportStorageClass();

		if (const Function *F = dyn_cast<Function>(G))
		return F->hasFnAttribute(Attribute::DLLImport);

		return false;
		}

/// ClassifyGlobalReference - Classify a global variable reference for the		/// ClassifyGlobalReference - Classify a global variable reference for the
/// current subtarget according to how we should reference it in a non-pcrel		/// current subtarget according to how we should reference it in a non-pcrel
/// context.		/// context.
unsigned char X86Subtarget::		unsigned char X86Subtarget::
ClassifyGlobalReference(const GlobalValue *GV, const TargetMachine &TM) const {		ClassifyGlobalReference(const GlobalValue *GV, const TargetMachine &TM) const {
// DLLImport only exists on windows, it is implemented as a load from a		// DLLImport only exists on windows, it is implemented as a load from a
// DLLIMPORT stub.		// DLLIMPORT stub.
if (GV->hasDLLImportLinkage())		if (hasDLLImport(GV))
return X86II::MO_DLLIMPORT;		return X86II::MO_DLLIMPORT;

// Determine whether this is a reference to a definition or a declaration.		// Determine whether this is a reference to a definition or a declaration.
// Materializable GVs (in JIT lazy compilation mode) do not require an extra		// Materializable GVs (in JIT lazy compilation mode) do not require an extra
// load from stub.		// load from stub.
bool isDecl = GV->hasAvailableExternallyLinkage();		bool isDecl = GV->hasAvailableExternallyLinkage();
if (GV->isDeclaration() && !GV->isMaterializable())		if (GV->isDeclaration() && !GV->isMaterializable())
isDecl = true;		isDecl = true;
▲ Show 20 Lines • Show All 452 Lines • Show Last 20 Lines

lib/Target/XCore/XCoreAsmPrinter.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines	case GlobalValue::ExternalLinkage:

// TODO Use COMDAT groups for LinkOnceLinkage		// TODO Use COMDAT groups for LinkOnceLinkage
if (GV->hasWeakLinkage() \|\| GV->hasLinkOnceLinkage())		if (GV->hasWeakLinkage() \|\| GV->hasLinkOnceLinkage())
OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak);		OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak);
// FALL THROUGH		// FALL THROUGH
case GlobalValue::InternalLinkage:		case GlobalValue::InternalLinkage:
case GlobalValue::PrivateLinkage:		case GlobalValue::PrivateLinkage:
break;		break;
case GlobalValue::DLLImportLinkage:
llvm_unreachable("DLLImport linkage is not supported by this target!");
case GlobalValue::DLLExportLinkage:
llvm_unreachable("DLLExport linkage is not supported by this target!");
default:		default:
llvm_unreachable("Unknown linkage type!");		llvm_unreachable("Unknown linkage type!");
}		}

EmitAlignment(Align > 2 ? Align : 2, GV);		EmitAlignment(Align > 2 ? Align : 2, GV);

if (GV->isThreadLocal()) {		if (GV->isThreadLocal()) {
report_fatal_error("TLS is not supported by this target!");		report_fatal_error("TLS is not supported by this target!");
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

test/CodeGen/X86/dll-linkage.ll

This file was deleted.

	; RUN: llc < %s -mtriple=i386-pc-mingw32 \| FileCheck %s

	; RUN: llc < %s -mtriple=i386-pc-mingw32 -O0 \| FileCheck %s -check-prefix=FAST
	; PR6275

	declare dllimport void @foo()

	define void @bar() nounwind {
	; CHECK: calll *__imp__foo
	; FAST: movl __imp__foo, [[R:%[a-z]{3}]]
	; FAST: calll *[[R]]
	call void @foo()
	ret void
	}

test/CodeGen/X86/dllexport-x86_64.ll

This file was added.

				; RUN: llc -mtriple x86_64-pc-win32 < %s \| FileCheck %s

				; CHECK: .text

				; CHECK: .globl f1
				define void @f1() dllexport {
				ret void
				}

				; CHECK: .globl f2
				define void @f2() unnamed_addr dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl lnk1
				define linkonce_odr void @lnk1() dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl lnk2
				define linkonce_odr void @lnk2() alwaysinline dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl weak1
				define weak_odr void @weak1() dllexport {
				ret void
				}


				; CHECK: .data

				; CHECK: .globl Var1
				@Var1 = global i32 1, align 4, dllexport

				; CHECK: .globl Var2
				@Var2 = unnamed_addr constant i32 1, dllexport

				; CHECK: .comm Var3
				@Var3 = common global i32 0, align 4, dllexport

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl WeakVar1
				@WeakVar1 = weak_odr global i32 1, align 4, dllexport

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl WeakVar2
				@WeakVar2 = weak_odr unnamed_addr constant i32 1, dllexport


				; CHECK: .globl alias
				; CHECK: alias = f1
				@alias = alias void()* @f1

				; CHECK: .globl alias2
				; CHECK: alias2 = alias
				@alias2 = alias void()* @alias

				; CHECK: .weak weak_alias
				; CHECK: weak_alias = f1
				@weak_alias = alias weak_odr void()* @f1


				; CHECK: .section .drectve
				; CHECK: /EXPORT:Var1,DATA
				; CHECK: /EXPORT:Var2,DATA
				; CHECK: /EXPORT:Var3,DATA
				; CHECK: /EXPORT:WeakVar1,DATA
				; CHECK: /EXPORT:WeakVar2,DATA
				; CHECK: /EXPORT:f1
				; CHECK: /EXPORT:f2
				; CHECK: /EXPORT:lnk1
				; CHECK: /EXPORT:lnk2
				; CHECK: /EXPORT:weak1
				; CHECK: /EXPORT:alias
				; CHECK: /EXPORT:alias2
				; CHECK: /EXPORT:weak_alias

test/CodeGen/X86/dllexport.ll

	; RUN: llc < %s \| FileCheck %s			; RUN: llc -mtriple i386-pc-win32 < %s \| FileCheck %s
	; PR2936

	target triple = "i386-pc-mingw32"			; CHECK: .text

	define dllexport x86_fastcallcc i32 @foo() nounwind {			; CHECK: .globl _f1
	entry:			define void @f1() dllexport {
				ret void
				}

				; CHECK: .globl _f2
				define void @f2() unnamed_addr dllexport {
				ret void
				}

				; CHECK: .globl _stdfun@0
				define x86_stdcallcc void @stdfun() nounwind dllexport {
				ret void
				}

				; CHECK: .globl @fastfun@0
				define x86_fastcallcc i32 @fastfun() nounwind dllexport {
	ret i32 0			ret i32 0
	}			}

				; CHECK: .globl _thisfun
				define x86_thiscallcc void @thisfun() nounwind dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl _lnk1
				define linkonce_odr void @lnk1() dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl _lnk2
				define linkonce_odr void @lnk2() alwaysinline dllexport {
				ret void
				}

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl _weak1
				define weak_odr void @weak1() dllexport {
				ret void
				}


				; CHECK: .data

				; CHECK: .globl _Var1
				@Var1 = global i32 1, align 4, dllexport

				; CHECK: .globl _Var2
				@Var2 = unnamed_addr constant i32 1, dllexport

				; CHECK: .comm _Var3
				@Var3 = common global i32 0, align 4, dllexport

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl _WeakVar1
				@WeakVar1 = weak_odr global i32 1, align 4, dllexport

				; CHECK: .section
				; CHECK: .linkonce discard
				; CHECK: .globl _WeakVar2
				@WeakVar2 = weak_odr unnamed_addr constant i32 1, dllexport


				; CHECK: .globl _alias
				; CHECK: _alias = _f1
				@alias = alias void()* @f1

				; CHECK: .globl _alias2
				; CHECK: alias2 = _alias
				@alias2 = alias void()* @alias

				; CHECK: .weak _weak_alias
				; CHECK: _weak_alias = _f1
				@weak_alias = alias weak_odr void()* @f1


	; CHECK: .section .drectve			; CHECK: .section .drectve
	; CHECK: -export:@foo@0			; CHECK: /EXPORT:_Var1,DATA
				; CHECK: /EXPORT:_Var2,DATA
				; CHECK: /EXPORT:_Var3,DATA
				; CHECK: /EXPORT:_WeakVar1,DATA
				; CHECK: /EXPORT:_WeakVar2,DATA
				; CHECK: /EXPORT:_f1
				; CHECK: /EXPORT:_f2
				; CHECK: /EXPORT:_stdfun@0
				; CHECK: /EXPORT:@fastfun@0
				; CHECK: /EXPORT:_thisfun
				; CHECK: /EXPORT:_lnk1
				; CHECK: /EXPORT:_lnk2
				; CHECK: /EXPORT:_weak1
				; CHECK: /EXPORT:_alias
				; CHECK: /EXPORT:_alias2
				; CHECK: /EXPORT:_weak_alias

test/CodeGen/X86/dllimport-x86_64.ll

This file was added.

				; RUN: llc -mtriple x86_64-pc-win32 < %s \| FileCheck %s
				; RUN: llc -mtriple x86_64-pc-mingw32 < %s \| FileCheck %s
				;
				; RUN: llc -mtriple x86_64-pc-mingw32 -O0 < %s \| FileCheck %s -check-prefix=FAST
				; PR6275
				;
				; RUN: opt -mtriple x86_64-pc-win32 -std-compile-opts -S < %s \| FileCheck %s -check-prefix=OPT

				@Var1 = external global i32, dllimport
				@Var2 = available_externally unnamed_addr constant i32 1, dllimport

				declare void @fun() dllimport

				define available_externally void @inline1() dllimport {
				ret void
				}

				define available_externally void @inline2() alwaysinline dllimport {
				ret void
				}

				declare void @dummy(...)

				define void @use() nounwind {
				; CHECK: callq *__imp_fun(%rip)
				; FAST: movq __imp_fun(%rip), [[R:%[a-z]{3}]]
				; FAST: callq *[[R]]
				call void @fun()
				rnkUnsubmitted Not Done Reply Inline Actions Should this be FAST-NEXT: or have some other way to avoid matching one of the calls from below? rnk: Should this be FAST-NEXT: or have some other way to avoid matching one of the calls from below?
				nrieckAuthorUnsubmitted Not Done Reply Inline Actions Yeah, would be better. nrieck: Yeah, would be better.

				; CHECK: callq *__imp_inline1(%rip)
				; CHECK: callq *__imp_inline2(%rip)
				call void @inline1()
				call void @inline2()

				; available_externally uses go away
				; OPT-NOT: call void @inline1()
				; OPT-NOT: call void @inline2()
				; OPT-NOT: load i32* @Var2
				; OPT: call void (...)* @dummy(i32 %1, i32 1)

				; CHECK-DAG: movq __imp_Var1(%rip), [[R1:%[a-z]{3}]]
				; CHECK-DAG: movq __imp_Var2(%rip), [[R2:%[a-z]{3}]]
				%1 = load i32* @Var1
				%2 = load i32* @Var2
				call void(...)* @dummy(i32 %1, i32 %2)

				ret void
				}


				; CHECK: .globl _ZTC1C0_1B
				; CHECK: .quad __imp__ZTI1B
				@_ZTI1B = external constant i8*, dllimport
				@_ZTC1C0_1B = constant [1 x i8] [i8 @_ZTI1B]

test/CodeGen/X86/dllimport.ll

This file was added.

				; RUN: llc -mtriple i386-pc-win32 < %s \| FileCheck %s
				; RUN: llc -mtriple i386-pc-mingw32 < %s \| FileCheck %s
				;
				; RUN: llc -mtriple i386-pc-mingw32 -O0 < %s \| FileCheck %s -check-prefix=FAST
				; PR6275
				;
				; RUN: opt -mtriple i386-pc-win32 -std-compile-opts -S < %s \| FileCheck %s -check-prefix=OPT

				@Var1 = external global i32, dllimport
				@Var2 = available_externally unnamed_addr constant i32 1, dllimport

				declare void @fun() dllimport

				define available_externally void @inline1() dllimport {
				ret void
				}

				define available_externally void @inline2() alwaysinline dllimport {
				ret void
				}

				declare x86_stdcallcc void @stdfun() nounwind dllimport
				declare x86_fastcallcc void @fastfun() nounwind dllimport
				declare x86_thiscallcc void @thisfun() nounwind dllimport

				declare void @dummy(...)

				define void @use() nounwind {
				; CHECK: calll *__imp__fun
				; FAST: movl __imp__fun, [[R:%[a-z]{3}]]
				; FAST: calll *[[R]]
				call void @fun()
				rnkUnsubmitted Not Done Reply Inline Actions ditto rnk: ditto

				; CHECK: calll *__imp__inline1
				; CHECK: calll *__imp__inline2
				call void @inline1()
				call void @inline2()

				; CHECK: calll *__imp__stdfun@0
				; CHECK: calll *__imp_@fastfun@0
				; CHECK: calll *__imp__thisfun
				call void @stdfun()
				call void @fastfun()
				call void @thisfun()

				; available_externally uses go away
				; OPT-NOT: call void @inline1()
				; OPT-NOT: call void @inline2()
				; OPT-NOT: load i32* @Var2
				; OPT: call void (...)* @dummy(i32 %1, i32 1)

				; CHECK-DAG: movl __imp__Var1, [[R1:%[a-z]{3}]]
				; CHECK-DAG: movl __imp__Var2, [[R2:%[a-z]{3}]]
				%1 = load i32* @Var1
				%2 = load i32* @Var2
				call void(...)* @dummy(i32 %1, i32 %2)

				ret void
				}


				; CHECK: .globl __ZTC1C0_1B
				; CHECK: .long __imp___ZTI1B
				@_ZTI1B = external constant i8*, dllimport
				@_ZTC1C0_1B = constant [1 x i8] [i8 @_ZTI1B]

test/MC/COFF/linker-options.ll

	; RUN: llc -O0 -mtriple=i386-pc-win32 -filetype=asm -o - %s \| FileCheck %s			; RUN: llc -O0 -mtriple=i386-pc-win32 -filetype=asm -o - %s \| FileCheck %s

	!0 = metadata !{ i32 6, metadata !"Linker Options",			!0 = metadata !{ i32 6, metadata !"Linker Options",
	metadata !{			metadata !{
	metadata !{ metadata !"/DEFAULTLIB:msvcrt.lib" },			metadata !{ metadata !"/DEFAULTLIB:msvcrt.lib" },
	metadata !{ metadata !"/DEFAULTLIB:msvcrt.lib",			metadata !{ metadata !"/DEFAULTLIB:msvcrt.lib",
	metadata !"/DEFAULTLIB:secur32.lib" },			metadata !"/DEFAULTLIB:secur32.lib" },
	metadata !{ metadata !"/with spaces" } } }			metadata !{ metadata !"/with spaces" } } }

	!llvm.module.flags = !{ !0 }			!llvm.module.flags = !{ !0 }

	define dllexport void @foo() {			define void @foo() dllexport {
	ret void			ret void
	}			}

	; CHECK: .section .drectve,"r"			; CHECK: .section .drectve,"r"
	; CHECK: .ascii " /DEFAULTLIB:msvcrt.lib"			; CHECK: .ascii " /DEFAULTLIB:msvcrt.lib"
	; CHECK: .ascii " /DEFAULTLIB:msvcrt.lib"			; CHECK: .ascii " /DEFAULTLIB:msvcrt.lib"
	; CHECK: .ascii " /DEFAULTLIB:secur32.lib"			; CHECK: .ascii " /DEFAULTLIB:secur32.lib"
	; CHECK: .ascii " \"/with spaces\""			; CHECK: .ascii " \"/with spaces\""
	; CHECK: .ascii " /EXPORT:_foo"			; CHECK: .ascii " /EXPORT:_foo"

This is an archive of the discontinued LLVM Phabricator instance.

Change representation of dllexport/dllimportClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 2710

docs/LangRef.rst

include/llvm-c/Core.h

include/llvm/IR/Attributes.h

include/llvm/IR/GlobalValue.h

include/llvm/IR/GlobalVariable.h

lib/AsmParser/LLParser.cpp

lib/Bitcode/Reader/BitcodeReader.cpp

lib/Bitcode/Writer/BitcodeWriter.cpp

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

lib/ExecutionEngine/ExecutionEngine.cpp

lib/IR/AsmWriter.cpp

lib/IR/Attributes.cpp

lib/IR/Core.cpp

lib/IR/Globals.cpp

lib/IR/Verifier.cpp

lib/Linker/LinkModules.cpp

lib/Target/CppBackend/CPPBackend.cpp

lib/Target/Mangler.cpp

lib/Target/X86/X86AsmPrinter.cpp

lib/Target/X86/X86FastISel.cpp

lib/Target/X86/X86ISelLowering.cpp

lib/Target/X86/X86Subtarget.cpp

lib/Target/XCore/XCoreAsmPrinter.cpp

test/CodeGen/X86/dll-linkage.ll

test/CodeGen/X86/dllexport-x86_64.ll

test/CodeGen/X86/dllexport.ll

test/CodeGen/X86/dllimport-x86_64.ll

test/CodeGen/X86/dllimport.ll

test/MC/COFF/linker-options.ll

Change representation of dllexport/dllimport
ClosedPublic