aboutsummaryrefslogtreecommitdiff
path: root/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp
AgeCommit message (Collapse)AuthorFilesLines
2015-02-26Put jump tables in distinct sections if -ffunction-sections is used.Rafael Espindola1-20/+28
A small regression in r230411 was that we were basing the decision on -fdata-sections. llvm-svn: 230707
2015-02-25Support SHF_MERGE sections in COMDATs.Rafael Espindola1-77/+48
This patch unifies the comdat and non-comdat code paths. By doing this it add missing features to the comdat side and removes the fixed section assumptions from the non-comdat side. In ELF there is no one true section for "4 byte mergeable" constants. We are better off computing the required properties of the section and asking the context for it. llvm-svn: 230411
2015-02-20Use short names for jumptable sections.Rafael Espindola1-29/+25
Also refactor code to remove some duplication. llvm-svn: 230087
2015-02-17Add r228939 back with a fix.Rafael Espindola1-0/+7
The problem in the original patch was not switching back to .text after printing an eh table. Original message: On ELF, put PIC jump tables in a non executable section. Fixes PR22558. llvm-svn: 229586
2015-02-17Add r228980 back.Rafael Espindola1-14/+17
Add support for having multiple sections with the same name and comdat. Using this in combination with -ffunction-sections allows LLVM to output a .o file with mulitple sections named .text. This saves space by avoiding long unique names of the form .text.<C++ mangled name>. llvm-svn: 229541
2015-02-16Fix quoting of #pragma comment for MS compat, LLVM part.Michael Kuperstein1-14/+3
For #pragma comment(linker, ...) MSVC expects the comment string to be quoted, but for #pragma comment(lib, ...) the compiler itself quotes the library name. Since this distinction disappears by the time the directive reaches the backend, move quoting for the "lib" version to the frontend. Differential Revision: http://reviews.llvm.org/D7652 llvm-svn: 229375
2015-02-14Revert "On ELF, put PIC jump tables in a non executable section."Matthias Braun1-7/+0
This reverts commit r228939. The commit broke something in the output of exception handling tables on darwin x86-64. llvm-svn: 229203
2015-02-13Revert a series of commits starting at r228886 which is triggering someChandler Carruth1-17/+14
regressions for LLDB on Linux. Rafael indicated on lldb-dev that we should just go ahead and revert these but that he wasn't at a computer. The patches backed out are as follows: r228980: Add support for having multiple sections with the name and ... r228889: Invert the section relocation map. r228888: Use the existing SymbolTableIndex intsead of doing a lookup. r228886: Create the Section -> Rel Section map when it is first needed. These patches look pretty nice to me, so hoping its not too hard to get them re-instated. =D llvm-svn: 229080
2015-02-12Add support for having multiple sections with the same name and comdat.Rafael Espindola1-14/+17
Using this in combination with -ffunction-sections allows LLVM to output a .o file with mulitple sections named .text. This saves space by avoiding long unique names of the form .text.<C++ mangled name>. llvm-svn: 228980
2015-02-12On ELF, put PIC jump tables in a non executable section.Rafael Espindola1-0/+7
Fixes PR22558. llvm-svn: 228939
2015-02-12Put each jump table in an independent section if the function is too.Rafael Espindola1-0/+22
This allows the linker to GC both, fixing pr22557. llvm-svn: 228937
2015-02-11Don't repeat name in comment and clang-format a function.Rafael Espindola1-14/+20
llvm-svn: 228831
2015-02-05Add a FIXME.Rafael Espindola1-0/+3
Thanks to Eric for the suggestion. llvm-svn: 228300
2015-02-04Don' try to make sections in comdats SHF_MERGE.Rafael Espindola1-4/+4
Parts of llvm were not expecting it and we wouldn't print the entity size of the section. Given what comdats are used for, having SHF_MERGE sections would be just a small improvement, so just disable it for now. Fixes pr22463. llvm-svn: 228196
2015-01-29Compute the ELF SectionKind from the flags.Rafael Espindola1-26/+15
Any code creating an MCSectionELF knows ELF and already provides the flags. SectionKind is an abstraction used by common code that uses a plain MCSection. Use the flags to compute the SectionKind. This removes a lot of guessing and boilerplate from the MCSectionELF construction. llvm-svn: 227476
2015-01-29Use isMergeableConst now that it is sane.Rafael Espindola1-3/+1
llvm-svn: 227441
2015-01-29Don't create multiple mergeable sections with -fdata-sections.Rafael Espindola1-9/+10
ELF has support for sections that can be split into fixed size or null terminated entities. Since these sections can be split by the linker, it is not necessary to split them in codegen. This reduces the combined .o size in a llvm+clang build from 202,394,570 to 173,819,098 bytes. The time for linking clang with gold (on a VM, on a laptop) goes from 2.250089985 to 1.383001792 seconds. The flip side is the size of rodata in clang goes from 10,926,785 to 10,929,345 bytes. The increase seems to be because of http://sourceware.org/bugzilla/show_bug.cgi?id=17902. llvm-svn: 227431
2015-01-28Simplify code. NFC.Rafael Espindola1-3/+1
llvm-svn: 227333
2015-01-26Move DataLayout back to the TargetMachine from TargetSubtargetInfoEric Christopher1-9/+5
derived classes. Since global data alignment, layout, and mangling is often based on the DataLayout, move it to the TargetMachine. This ensures that global data is going to be layed out and mangled consistently if the subtarget changes on a per function basis. Prior to this all targets(*) have had subtarget dependent code moved out and onto the TargetMachine. *One target hasn't been migrated as part of this change: R600. The R600 port has, as a subtarget feature, the size of pointers and this affects global data layout. I've currently hacked in a FIXME to enable progress, but the port needs to be updated to either pass the 64-bitness to the TargetMachine, or fix the DataLayout to avoid subtarget dependent features. llvm-svn: 227113
2015-01-19Bring r226038 back.Rafael Espindola1-14/+5
No change in this commit, but clang was changed to also produce trivial comdats when needed. Original message: Don't create new comdats in CodeGen. This patch stops the implicit creation of comdats during codegen. Clang now sets the comdat explicitly when it is required. With this patch clang and gcc now produce the same result in pr19848. llvm-svn: 226467
2015-01-16Revert r226242 - Revert Revert Don't create new comdats in CodeGenTimur Iskhodzhanov1-5/+14
This breaks AddressSanitizer (ninja check-asan) on Windows llvm-svn: 226251
2015-01-16Revert "Revert Don't create new comdats in CodeGen"Rafael Espindola1-14/+5
This reverts commit r226173, adding r226038 back. No change in this commit, but clang was changed to also produce trivial comdats for costructors, destructors and vtables when needed. Original message: Don't create new comdats in CodeGen. This patch stops the implicit creation of comdats during codegen. Clang now sets the comdat explicitly when it is required. With this patch clang and gcc now produce the same result in pr19848. llvm-svn: 226242
2015-01-15Revert Don't create new comdats in CodeGenTimur Iskhodzhanov1-5/+14
It breaks AddressSanitizer on Windows. llvm-svn: 226173
2015-01-14Don't create new comdats in CodeGen.Rafael Espindola1-14/+5
This patch stops the implicit creation of comdats during codegen. Clang now sets the comdat explicitly when it is required. With this patch clang and gcc now produce the same result in pr19848. llvm-svn: 226038
2015-01-09Recommit r224935 with a fix for the ObjC++/AArch64 bug that that revisionLang Hames1-54/+0
introduced. A test case for the bug was already committed in r225385. Patch by Rafael Espindola. llvm-svn: 225534
2015-01-06Revert r224935 "Refactor duplicated code. No intended functionality change."Lang Hames1-0/+54
This is affecting the behavior of some ObjC++ / AArch64 test cases on Darwin. Reverting to get the bots green while I track down the source of the changed behavior. llvm-svn: 225311
2014-12-30[COFF] Don't try to add quotes to already quoted linker directivesMichael Kuperstein1-1/+1
If a linker directive is already quoted, don't try to quote it again, otherwise it creates a mess. This pops up in places like: #pragma comment(linker,"\"/foo bar'\"") Differential Revision: http://reviews.llvm.org/D6792 llvm-svn: 224998
2014-12-29Refactor duplicated code.Rafael Espindola1-54/+0
No intended functionality change. llvm-svn: 224935
2014-12-09IR: Split Metadata from ValueDuncan P. N. Exon Smith1-4/+4
Split `Metadata` away from the `Value` class hierarchy, as part of PR21532. Assembly and bitcode changes are in the wings, but this is the bulk of the change for the IR C++ API. I have a follow-up patch prepared for `clang`. If this breaks other sub-projects, I apologize in advance :(. Help me compile it on Darwin I'll try to fix it. FWIW, the errors should be easy to fix, so it may be simpler to just fix it yourself. This breaks the build for all metadata-related code that's out-of-tree. Rest assured the transition is mechanical and the compiler should catch almost all of the problems. Here's a quick guide for updating your code: - `Metadata` is the root of a class hierarchy with three main classes: `MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from the `Value` class hierarchy. It is typeless -- i.e., instances do *not* have a `Type`. - `MDNode`'s operands are all `Metadata *` (instead of `Value *`). - `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively. If you're referring solely to resolved `MDNode`s -- post graph construction -- just use `MDNode*`. - `MDNode` (and the rest of `Metadata`) have only limited support for `replaceAllUsesWith()`. As long as an `MDNode` is pointing at a forward declaration -- the result of `MDNode::getTemporary()` -- it maintains a side map of its uses and can RAUW itself. Once the forward declarations are fully resolved RAUW support is dropped on the ground. This means that uniquing collisions on changing operands cause nodes to become "distinct". (This already happened fairly commonly, whenever an operand went to null.) If you're constructing complex (non self-reference) `MDNode` cycles, you need to call `MDNode::resolveCycles()` on each node (or on a top-level node that somehow references all of the nodes). Also, don't do that. Metadata cycles (and the RAUW machinery needed to construct them) are expensive. - An `MDNode` can only refer to a `Constant` through a bridge called `ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`). As a side effect, accessing an operand of an `MDNode` that is known to be, e.g., `ConstantInt`, takes three steps: first, cast from `Metadata` to `ConstantAsMetadata`; second, extract the `Constant`; third, cast down to `ConstantInt`. The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have metadata schema owners transition away from using `Constant`s when the type isn't important (and they don't care about referring to `GlobalValue`s). In the meantime, I've added transitional API to the `mdconst` namespace that matches semantics with the old code, in order to avoid adding the error-prone three-step equivalent to every call site. If your old code was: MDNode *N = foo(); bar(isa <ConstantInt>(N->getOperand(0))); baz(cast <ConstantInt>(N->getOperand(1))); bak(cast_or_null <ConstantInt>(N->getOperand(2))); bat(dyn_cast <ConstantInt>(N->getOperand(3))); bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4))); you can trivially match its semantics with: MDNode *N = foo(); bar(mdconst::hasa <ConstantInt>(N->getOperand(0))); baz(mdconst::extract <ConstantInt>(N->getOperand(1))); bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2))); bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3))); bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4))); and when you transition your metadata schema to `MDInt`: MDNode *N = foo(); bar(isa <MDInt>(N->getOperand(0))); baz(cast <MDInt>(N->getOperand(1))); bak(cast_or_null <MDInt>(N->getOperand(2))); bat(dyn_cast <MDInt>(N->getOperand(3))); bay(dyn_cast_or_null<MDInt>(N->getOperand(4))); - A `CallInst` -- specifically, intrinsic instructions -- can refer to metadata through a bridge called `MetadataAsValue`. This is a subclass of `Value` where `getType()->isMetadataTy()`. `MetadataAsValue` is the *only* class that can legally refer to a `LocalAsMetadata`, which is a bridged form of non-`Constant` values like `Argument` and `Instruction`. It can also refer to any other `Metadata` subclass. (I'll break all your testcases in a follow-up commit, when I propagate this change to assembly.) llvm-svn: 223802
2014-11-21[Objective-C] Support a new special module flag that will be put into theManman Ren1-1/+2
objc_imageinfo struct. rdar://17954668 llvm-svn: 222558
2014-11-06Add three other sections when L symbols are allowed.Rafael Espindola1-0/+15
llvm-svn: 221436
2014-11-06Allow L symbols in no_dead_strip sections.Rafael Espindola1-0/+4
If a section cannot be dead stripped, it is safe to use L symbols, since the linker will keep all of it in the end. llvm-svn: 221431
2014-09-22MC: ReadOnlyWithRel section kinds should map to rdata in COFFDavid Majnemer1-4/+4
Don't consider ReadOnlyWithRel as a writable section in COFF, they really belong in .rdata. llvm-svn: 218268
2014-09-20MC: Treat ReadOnlyWithRel and ReadOnlyWithRelLocal as ReadOnly for COFFDavid Majnemer1-2/+2
A problem with our old behavior becomes observable under x86-64 COFF when we need a read-only GV which has an initializer which is referenced using a relocation: we would mark the section as writable. Marking the section as writable interferes with section merging. This fixes PR21009. llvm-svn: 218179
2014-09-19Fix an it's vs. its typo.Hans Wennborg1-1/+1
llvm-svn: 218093
2014-09-05Revert "Disable the fix for pr20793 because of a gnu ld bug."Rafael Espindola1-11/+0
This reverts commit r217211. Both the bfd ld and gold outputs were valid. They were using a Rela relocation, so the value present in the relocated location was not used, which caused me to misread the output. llvm-svn: 217264
2014-09-05Disable the fix for pr20793 because of a gnu ld bug.Rafael Espindola1-0/+11
llvm-svn: 217211
2014-09-05Refactor to avoid code duplication. NFC.Rafael Espindola1-34/+25
llvm-svn: 217207
2014-09-04Fix pr20793.Rafael Espindola1-24/+48
With this patch the third field of llvm.global_ctors is also used on ELF. llvm-svn: 217202
2014-09-04MC Win64: Put unwind info for COMDAT code into the same COMDAT groupReid Kleckner1-19/+4
Summary: This fixes a long standing issue where we would emit many little .text sections and only one .pdata and .xdata section. Now we generate one .pdata / .xdata pair per .text section and associate them correctly. Fixes PR19667. Reviewers: majnemer Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D5181 llvm-svn: 217176
2014-08-28On MachO, don't put non-private constants in mergeable sections.Rafael Espindola1-1/+3
On MachO, putting a symbol that doesn't start with a 'L' or 'l' in one of the __TEXT,__literal* sections prevents the linker from merging the context of the section. Since private GVs are the ones the get mangled to start with 'L' or 'l', we now only put those on the __TEXT,__literal* sections. llvm-svn: 216682
2014-08-04Remove the TargetMachine forwards for TargetSubtargetInfo basedEric Christopher1-5/+10
information and update all callers. No functional change. llvm-svn: 214781
2014-07-14CodeGen: Stick constant pool entries in COMDAT sections for WinCOFFDavid Majnemer1-3/+5
COFF lacks a feature that other object file formats support: mergeable sections. To work around this, MSVC sticks constant pool entries in special COMDAT sections so that each constant is in it's own section. This permits unused constants to be dropped and it also allows duplicate constants in different translation units to get merged together. This fixes PR20262. Differential Revision: http://reviews.llvm.org/D4482 llvm-svn: 213006
2014-07-07Make helper functions static.Benjamin Kramer1-1/+1
llvm-svn: 212460
2014-06-27IR: Add COMDATs to the IRDavid Majnemer1-18/+115
This new IR facility allows us to represent the object-file semantic of a COMDAT group. COMDATs allow us to tie together sections and make the inclusion of one dependent on another. This is required to implement features like MS ABI VFTables and optimizing away certain kinds of initialization in C++. This functionality is only representable in COFF and ELF, Mach-O has no similar mechanism. Differential Revision: http://reviews.llvm.org/D4178 llvm-svn: 211920
2014-06-24CodeGen: Avoid multiple strlen callsDavid Majnemer1-5/+4
Use a StringRef to hold our section prefix. This avoids multiple calls to strlen. llvm-svn: 211602
2014-06-06Fix a few issues with comdat handling on COFF.Rafael Espindola1-10/+8
* Section association cannot use just the section name as many sections can have the same name. With this patch, the comdat symbol in an assoc section is interpreted to mean a symbol in the associated section and the mapping is discovered from it. * Comdat symbols were not being set correctly. Instead we were getting whatever was output first for that section. A consequence is that associative sections now must use .section to set the association. Using .linkonce would not work since it is not possible to change a sections comdat symbol (it is used to decide if we should create a new section or reuse an existing one). This includes r210298, which was reverted because it was asserting on an associated section having the same comdat as the associated section. llvm-svn: 210367
2014-05-30Fix MIPS exception personality encoding.Logan Chien1-8/+4
For MIPS, we have to encode the personality routine with an indirect pointer to absptr; otherwise, some link warning warning will be raised, and the program might crash in some early MIPS Android device. llvm-svn: 209907
2014-05-16Add comdat key field to llvm.global_ctors and llvm.global_dtorsReid Kleckner1-4/+33
This allows us to put dynamic initializers for weak data into the same comdat group as the data being initialized. This is necessary for MSVC ABI compatibility. Once we have comdats for guard variables, we can use the combination to help GlobalOpt fire more often for weak data with guarded initialization on other platforms. Reviewers: nlewycky Differential Revision: http://reviews.llvm.org/D3499 llvm-svn: 209015
2014-04-14[C++11] More 'nullptr' conversion. In some cases just using a boolean check ↵Craig Topper1-5/+5
instead of comparing to nullptr. llvm-svn: 206142
generated by cgit v1.1 at 2025-10-11 18:48:29 +0000