2017-02-28 06:45:06 +08:00
|
|
|
//===- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info ---===//
|
2010-02-16 06:37:53 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-02-16 06:37:53 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
|
|
|
|
// This file implements classes used to handle lowerings specific to common
|
|
|
|
|
// object file formats.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/COFF.h"
|
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.h"
|
|
|
|
|
#include "llvm/BinaryFormat/ELF.h"
|
|
|
|
|
#include "llvm/BinaryFormat/MachO.h"
|
2020-09-17 12:40:00 +08:00
|
|
|
#include "llvm/CodeGen/BasicBlockSectionUtils.h"
|
2020-03-17 06:56:02 +08:00
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfoImpls.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Comdat.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
|
|
|
#include "llvm/IR/DiagnosticPrinter.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/GlobalAlias.h"
|
|
|
|
|
#include "llvm/IR/GlobalObject.h"
|
|
|
|
|
#include "llvm/IR/GlobalValue.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2014-01-08 05:19:40 +08:00
|
|
|
#include "llvm/IR/Mangler.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
[CSSPGO] Pseudo probe encoding and emission.
This change implements pseudo probe encoding and emission for CSSPGO. Please see RFC here for more context: https://groups.google.com/g/llvm-dev/c/1p1rdYbL93s
Pseudo probes are in the form of intrinsic calls on IR/MIR but they do not turn into any machine instructions. Instead they are emitted into the binary as a piece of data in standalone sections. The probe-specific sections are not needed to be loaded into memory at execution time, thus they do not incur a runtime overhead.
**ELF object emission**
The binary data to emit are organized as two ELF sections, i.e, the `.pseudo_probe_desc` section and the `.pseudo_probe` section. The `.pseudo_probe_desc` section stores a function descriptor for each function and the `.pseudo_probe` section stores the actual probes, each fo which corresponds to an IR basic block or an IR function callsite. A function descriptor is stored as a module-level metadata during the compilation and is serialized into the object file during object emission.
Both the probe descriptors and pseudo probes can be emitted into a separate ELF section per function to leverage the linker for deduplication. A `.pseudo_probe` section shares the same COMDAT group with the function code so that when the function is dead, the probes are dead and disposed too. On the contrary, a `.pseudo_probe_desc` section has its own COMDAT group. This is because even if a function is dead, its probes may be inlined into other functions and its descriptor is still needed by the profile generation tool.
The format of `.pseudo_probe_desc` section looks like:
```
.section .pseudo_probe_desc,"",@progbits
.quad 6309742469962978389 // Func GUID
.quad 4294967295 // Func Hash
.byte 9 // Length of func name
.ascii "_Z5funcAi" // Func name
.quad 7102633082150537521
.quad 138828622701
.byte 12
.ascii "_Z8funcLeafi"
.quad 446061515086924981
.quad 4294967295
.byte 9
.ascii "_Z5funcBi"
.quad -2016976694713209516
.quad 72617220756
.byte 7
.ascii "_Z3fibi"
```
For each `.pseudoprobe` section, the encoded binary data consists of a single function record corresponding to an outlined function (i.e, a function with a code entry in the `.text` section). A function record has the following format :
```
FUNCTION BODY (one for each outlined function present in the text section)
GUID (uint64)
GUID of the function
NPROBES (ULEB128)
Number of probes originating from this function.
NUM_INLINED_FUNCTIONS (ULEB128)
Number of callees inlined into this function, aka number of
first-level inlinees
PROBE RECORDS
A list of NPROBES entries. Each entry contains:
INDEX (ULEB128)
TYPE (uint4)
0 - block probe, 1 - indirect call, 2 - direct call
ATTRIBUTE (uint3)
reserved
ADDRESS_TYPE (uint1)
0 - code address, 1 - address delta
CODE_ADDRESS (uint64 or ULEB128)
code address or address delta, depending on ADDRESS_TYPE
INLINED FUNCTION RECORDS
A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
callees. Each record contains:
INLINE SITE
GUID of the inlinee (uint64)
ID of the callsite probe (ULEB128)
FUNCTION BODY
A FUNCTION BODY entry describing the inlined function.
```
To support building a context-sensitive profile, probes from inlinees are grouped by their inline contexts. An inline context is logically a call path through which a callee function lands in a caller function. The probe emitter builds an inline tree based on the debug metadata for each outlined function in the form of a trie tree. A tree root is the outlined function. Each tree edge stands for a callsite where inlining happens. Pseudo probes originating from an inlinee function are stored in a tree node and the tree path starting from the root all the way down to the tree node is the inline context of the probes. The emission happens on the whole tree top-down recursively. Probes of a tree node will be emitted altogether with their direct parent edge. Since a pseudo probe corresponds to a real code address, for size savings, the address is encoded as a delta from the previous probe except for the first probe. Variant-sized integer encoding, aka LEB128, is used for address delta and probe index.
**Assembling**
Pseudo probes can be printed as assembly directives alternatively. This allows for good assembly code readability and also provides a view of how optimizations and pseudo probes affect each other, especially helpful for diff time assembly analysis.
A pseudo probe directive has the following operands in order: function GUID, probe index, probe type, probe attributes and inline context. The directive is generated by the compiler and can be parsed by the assembler to form an encoded `.pseudoprobe` section in the object file.
A example assembly looks like:
```
foo2: # @foo2
# %bb.0: # %bb0
pushq %rax
testl %edi, %edi
.pseudoprobe 837061429793323041 1 0 0
je .LBB1_1
# %bb.2: # %bb2
.pseudoprobe 837061429793323041 6 2 0
callq foo
.pseudoprobe 837061429793323041 3 0 0
.pseudoprobe 837061429793323041 4 0 0
popq %rax
retq
.LBB1_1: # %bb1
.pseudoprobe 837061429793323041 5 1 0
callq *%rsi
.pseudoprobe 837061429793323041 2 0 0
.pseudoprobe 837061429793323041 4 0 0
popq %rax
retq
# -- End function
.section .pseudo_probe_desc,"",@progbits
.quad 6699318081062747564
.quad 72617220756
.byte 3
.ascii "foo"
.quad 837061429793323041
.quad 281547593931412
.byte 4
.ascii "foo2"
```
With inlining turned on, the assembly may look different around %bb2 with an inlined probe:
```
# %bb.2: # %bb2
.pseudoprobe 837061429793323041 3 0
.pseudoprobe 6699318081062747564 1 0 @ 837061429793323041:6
.pseudoprobe 837061429793323041 4 0
popq %rax
retq
```
**Disassembling**
We have a disassembling tool (llvm-profgen) that can display disassembly alongside with pseudo probes. So far it only supports ELF executable file.
An example disassembly looks like:
```
00000000002011a0 <foo2>:
2011a0: 50 push rax
2011a1: 85 ff test edi,edi
[Probe]: FUNC: foo2 Index: 1 Type: Block
2011a3: 74 02 je 2011a7 <foo2+0x7>
[Probe]: FUNC: foo2 Index: 3 Type: Block
[Probe]: FUNC: foo2 Index: 4 Type: Block
[Probe]: FUNC: foo Index: 1 Type: Block Inlined: @ foo2:6
2011a5: 58 pop rax
2011a6: c3 ret
[Probe]: FUNC: foo2 Index: 2 Type: Block
2011a7: bf 01 00 00 00 mov edi,0x1
[Probe]: FUNC: foo2 Index: 5 Type: IndirectCall
2011ac: ff d6 call rsi
[Probe]: FUNC: foo2 Index: 4 Type: Block
2011ae: 58 pop rax
2011af: c3 ret
```
Reviewed By: wmi
Differential Revision: https://reviews.llvm.org/D91878
2020-12-09 07:37:32 +08:00
|
|
|
#include "llvm/IR/PseudoProbe.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Type.h"
|
2015-11-04 07:40:03 +08:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/MC/MCContext.h"
|
|
|
|
|
#include "llvm/MC/MCExpr.h"
|
2010-05-08 01:17:41 +08:00
|
|
|
#include "llvm/MC/MCSectionCOFF.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/MC/MCSectionELF.h"
|
|
|
|
|
#include "llvm/MC/MCSectionMachO.h"
|
2017-02-22 09:23:18 +08:00
|
|
|
#include "llvm/MC/MCSectionWasm.h"
|
2019-07-23 03:15:29 +08:00
|
|
|
#include "llvm/MC/MCSectionXCOFF.h"
|
2011-04-16 11:51:21 +08:00
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
2015-06-02 08:25:12 +08:00
|
|
|
#include "llvm/MC/MCSymbolELF.h"
|
2015-03-06 21:49:05 +08:00
|
|
|
#include "llvm/MC/MCValue.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/MC/SectionKind.h"
|
2016-01-15 02:09:45 +08:00
|
|
|
#include "llvm/ProfileData/InstrProf.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
|
#include "llvm/Support/CodeGen.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2020-03-17 06:56:02 +08:00
|
|
|
#include "llvm/Support/Format.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2014-03-04 18:07:28 +08:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include <cassert>
|
|
|
|
|
#include <string>
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
using namespace llvm;
|
2010-02-22 04:28:15 +08:00
|
|
|
using namespace dwarf;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
|
2017-06-06 05:26:39 +08:00
|
|
|
StringRef &Section) {
|
2017-06-13 04:10:48 +08:00
|
|
|
SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
|
|
|
|
|
M.getModuleFlagsMetadata(ModuleFlags);
|
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
for (const auto &MFE: ModuleFlags) {
|
|
|
|
|
// Ignore flags with 'Require' behaviour.
|
|
|
|
|
if (MFE.Behavior == Module::Require)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
StringRef Key = MFE.Key->getString();
|
|
|
|
|
if (Key == "Objective-C Image Info Version") {
|
|
|
|
|
Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
|
|
|
|
|
} else if (Key == "Objective-C Garbage Collection" ||
|
|
|
|
|
Key == "Objective-C GC Only" ||
|
|
|
|
|
Key == "Objective-C Is Simulated" ||
|
|
|
|
|
Key == "Objective-C Class Properties" ||
|
|
|
|
|
Key == "Objective-C Image Swift Version") {
|
|
|
|
|
Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
|
|
|
|
|
} else if (Key == "Objective-C Image Info Section") {
|
|
|
|
|
Section = cast<MDString>(MFE.Val)->getString();
|
|
|
|
|
}
|
2020-03-11 03:46:40 +08:00
|
|
|
// Backend generates L_OBJC_IMAGE_INFO from Swift ABI version + major + minor +
|
|
|
|
|
// "Objective-C Garbage Collection".
|
|
|
|
|
else if (Key == "Swift ABI Version") {
|
|
|
|
|
Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 8;
|
|
|
|
|
} else if (Key == "Swift Major Version") {
|
|
|
|
|
Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 24;
|
|
|
|
|
} else if (Key == "Swift Minor Version") {
|
|
|
|
|
Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 16;
|
|
|
|
|
}
|
2017-06-06 05:26:39 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// ELF
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2020-04-02 06:25:04 +08:00
|
|
|
TargetLoweringObjectFileELF::TargetLoweringObjectFileELF()
|
|
|
|
|
: TargetLoweringObjectFile() {
|
|
|
|
|
SupportDSOLocalEquivalentLowering = true;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-16 08:28:24 +08:00
|
|
|
void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
|
|
|
|
|
const TargetMachine &TgtM) {
|
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TgtM);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
2018-08-13 14:06:53 +08:00
|
|
|
CodeModel::Model CM = TgtM.getCodeModel();
|
2020-03-20 13:58:42 +08:00
|
|
|
InitializeELF(TgtM.Options.UseInitArray);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
|
|
|
|
switch (TgtM.getTargetTriple().getArch()) {
|
|
|
|
|
case Triple::arm:
|
|
|
|
|
case Triple::armeb:
|
|
|
|
|
case Triple::thumb:
|
|
|
|
|
case Triple::thumbeb:
|
|
|
|
|
if (Ctx.getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM)
|
|
|
|
|
break;
|
|
|
|
|
// Fallthrough if not using EHABI
|
|
|
|
|
LLVM_FALLTHROUGH;
|
|
|
|
|
case Triple::ppc:
|
2021-01-03 02:17:22 +08:00
|
|
|
case Triple::ppcle:
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
case Triple::x86:
|
|
|
|
|
PersonalityEncoding = isPositionIndependent()
|
|
|
|
|
? dwarf::DW_EH_PE_indirect |
|
|
|
|
|
dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4
|
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
|
LSDAEncoding = isPositionIndependent()
|
|
|
|
|
? dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
|
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = isPositionIndependent()
|
|
|
|
|
? dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4
|
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
|
break;
|
|
|
|
|
case Triple::x86_64:
|
|
|
|
|
if (isPositionIndependent()) {
|
2018-08-13 14:06:53 +08:00
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
((CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
|
? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel |
|
2018-08-13 14:06:53 +08:00
|
|
|
(CM == CodeModel::Small
|
|
|
|
|
? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
2018-08-13 14:06:53 +08:00
|
|
|
((CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
|
? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
} else {
|
|
|
|
|
PersonalityEncoding =
|
2018-08-13 14:06:53 +08:00
|
|
|
(CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
|
|
|
|
LSDAEncoding = (CM == CodeModel::Small)
|
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = (CM == CodeModel::Small)
|
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case Triple::hexagon:
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
|
PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
|
|
|
|
|
LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
|
|
|
|
|
TTypeEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case Triple::aarch64:
|
|
|
|
|
case Triple::aarch64_be:
|
2019-09-12 18:22:23 +08:00
|
|
|
case Triple::aarch64_32:
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
// The small model guarantees static code/data size < 4GB, but not where it
|
|
|
|
|
// will be in memory. Most of these could end up >2GB away so even a signed
|
|
|
|
|
// pc-relative 32-bit address is insufficient, theoretically.
|
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata8;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata8;
|
|
|
|
|
} else {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case Triple::lanai:
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
break;
|
|
|
|
|
case Triple::mips:
|
|
|
|
|
case Triple::mipsel:
|
|
|
|
|
case Triple::mips64:
|
|
|
|
|
case Triple::mips64el:
|
|
|
|
|
// MIPS uses indirect pointer to refer personality functions and types, so
|
|
|
|
|
// that the eh_frame section can be read-only. DW.ref.personality will be
|
|
|
|
|
// generated for relocation.
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect;
|
|
|
|
|
// FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
|
|
|
|
|
// identify N64 from just a triple.
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
// We don't support PC-relative LSDA references in GAS so we use the default
|
|
|
|
|
// DW_EH_PE_absptr for those.
|
|
|
|
|
|
|
|
|
|
// FreeBSD must be explicit about the data size and using pcrel since it's
|
|
|
|
|
// assembler/linker won't do the automatic conversion that the Linux tools
|
|
|
|
|
// do.
|
|
|
|
|
if (TgtM.getTargetTriple().isOSFreeBSD()) {
|
|
|
|
|
PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case Triple::ppc64:
|
|
|
|
|
case Triple::ppc64le:
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_udata8;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_udata8;
|
|
|
|
|
break;
|
|
|
|
|
case Triple::sparcel:
|
|
|
|
|
case Triple::sparc:
|
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
} else {
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
}
|
2019-07-17 22:00:35 +08:00
|
|
|
CallSiteEncoding = dwarf::DW_EH_PE_udata4;
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
break;
|
2019-07-17 21:54:38 +08:00
|
|
|
case Triple::riscv32:
|
|
|
|
|
case Triple::riscv64:
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
2019-07-17 22:00:35 +08:00
|
|
|
CallSiteEncoding = dwarf::DW_EH_PE_udata4;
|
2019-07-17 21:54:38 +08:00
|
|
|
break;
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
case Triple::sparcv9:
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
} else {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case Triple::systemz:
|
|
|
|
|
// All currently-defined code models guarantee that 4-byte PC-relative
|
|
|
|
|
// values will be in range.
|
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
} else {
|
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2018-07-16 08:28:24 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
|
Module &M) const {
|
2018-01-31 00:29:29 +08:00
|
|
|
auto &C = getContext();
|
|
|
|
|
|
|
|
|
|
if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
|
|
|
|
auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
|
|
|
|
|
ELF::SHF_EXCLUDE);
|
|
|
|
|
|
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
|
|
2020-01-02 00:23:21 +08:00
|
|
|
for (const auto *Operand : LinkerOptions->operands()) {
|
2018-01-31 00:29:29 +08:00
|
|
|
if (cast<MDNode>(Operand)->getNumOperands() != 2)
|
|
|
|
|
report_fatal_error("invalid llvm.linker.options");
|
|
|
|
|
for (const auto &Option : cast<MDNode>(Operand)->operands()) {
|
2020-02-15 10:16:24 +08:00
|
|
|
Streamer.emitBytes(cast<MDString>(Option)->getString());
|
2020-03-01 00:25:22 +08:00
|
|
|
Streamer.emitInt8(0);
|
2018-01-31 00:29:29 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
|
|
|
|
|
auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
|
|
|
|
|
ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
|
|
|
|
|
|
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
|
|
2020-01-02 00:23:21 +08:00
|
|
|
for (const auto *Operand : DependentLibraries->operands()) {
|
2020-02-15 10:16:24 +08:00
|
|
|
Streamer.emitBytes(
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
|
2020-03-01 00:25:22 +08:00
|
|
|
Streamer.emitInt8(0);
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
[CSSPGO] Pseudo probe encoding and emission.
This change implements pseudo probe encoding and emission for CSSPGO. Please see RFC here for more context: https://groups.google.com/g/llvm-dev/c/1p1rdYbL93s
Pseudo probes are in the form of intrinsic calls on IR/MIR but they do not turn into any machine instructions. Instead they are emitted into the binary as a piece of data in standalone sections. The probe-specific sections are not needed to be loaded into memory at execution time, thus they do not incur a runtime overhead.
**ELF object emission**
The binary data to emit are organized as two ELF sections, i.e, the `.pseudo_probe_desc` section and the `.pseudo_probe` section. The `.pseudo_probe_desc` section stores a function descriptor for each function and the `.pseudo_probe` section stores the actual probes, each fo which corresponds to an IR basic block or an IR function callsite. A function descriptor is stored as a module-level metadata during the compilation and is serialized into the object file during object emission.
Both the probe descriptors and pseudo probes can be emitted into a separate ELF section per function to leverage the linker for deduplication. A `.pseudo_probe` section shares the same COMDAT group with the function code so that when the function is dead, the probes are dead and disposed too. On the contrary, a `.pseudo_probe_desc` section has its own COMDAT group. This is because even if a function is dead, its probes may be inlined into other functions and its descriptor is still needed by the profile generation tool.
The format of `.pseudo_probe_desc` section looks like:
```
.section .pseudo_probe_desc,"",@progbits
.quad 6309742469962978389 // Func GUID
.quad 4294967295 // Func Hash
.byte 9 // Length of func name
.ascii "_Z5funcAi" // Func name
.quad 7102633082150537521
.quad 138828622701
.byte 12
.ascii "_Z8funcLeafi"
.quad 446061515086924981
.quad 4294967295
.byte 9
.ascii "_Z5funcBi"
.quad -2016976694713209516
.quad 72617220756
.byte 7
.ascii "_Z3fibi"
```
For each `.pseudoprobe` section, the encoded binary data consists of a single function record corresponding to an outlined function (i.e, a function with a code entry in the `.text` section). A function record has the following format :
```
FUNCTION BODY (one for each outlined function present in the text section)
GUID (uint64)
GUID of the function
NPROBES (ULEB128)
Number of probes originating from this function.
NUM_INLINED_FUNCTIONS (ULEB128)
Number of callees inlined into this function, aka number of
first-level inlinees
PROBE RECORDS
A list of NPROBES entries. Each entry contains:
INDEX (ULEB128)
TYPE (uint4)
0 - block probe, 1 - indirect call, 2 - direct call
ATTRIBUTE (uint3)
reserved
ADDRESS_TYPE (uint1)
0 - code address, 1 - address delta
CODE_ADDRESS (uint64 or ULEB128)
code address or address delta, depending on ADDRESS_TYPE
INLINED FUNCTION RECORDS
A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
callees. Each record contains:
INLINE SITE
GUID of the inlinee (uint64)
ID of the callsite probe (ULEB128)
FUNCTION BODY
A FUNCTION BODY entry describing the inlined function.
```
To support building a context-sensitive profile, probes from inlinees are grouped by their inline contexts. An inline context is logically a call path through which a callee function lands in a caller function. The probe emitter builds an inline tree based on the debug metadata for each outlined function in the form of a trie tree. A tree root is the outlined function. Each tree edge stands for a callsite where inlining happens. Pseudo probes originating from an inlinee function are stored in a tree node and the tree path starting from the root all the way down to the tree node is the inline context of the probes. The emission happens on the whole tree top-down recursively. Probes of a tree node will be emitted altogether with their direct parent edge. Since a pseudo probe corresponds to a real code address, for size savings, the address is encoded as a delta from the previous probe except for the first probe. Variant-sized integer encoding, aka LEB128, is used for address delta and probe index.
**Assembling**
Pseudo probes can be printed as assembly directives alternatively. This allows for good assembly code readability and also provides a view of how optimizations and pseudo probes affect each other, especially helpful for diff time assembly analysis.
A pseudo probe directive has the following operands in order: function GUID, probe index, probe type, probe attributes and inline context. The directive is generated by the compiler and can be parsed by the assembler to form an encoded `.pseudoprobe` section in the object file.
A example assembly looks like:
```
foo2: # @foo2
# %bb.0: # %bb0
pushq %rax
testl %edi, %edi
.pseudoprobe 837061429793323041 1 0 0
je .LBB1_1
# %bb.2: # %bb2
.pseudoprobe 837061429793323041 6 2 0
callq foo
.pseudoprobe 837061429793323041 3 0 0
.pseudoprobe 837061429793323041 4 0 0
popq %rax
retq
.LBB1_1: # %bb1
.pseudoprobe 837061429793323041 5 1 0
callq *%rsi
.pseudoprobe 837061429793323041 2 0 0
.pseudoprobe 837061429793323041 4 0 0
popq %rax
retq
# -- End function
.section .pseudo_probe_desc,"",@progbits
.quad 6699318081062747564
.quad 72617220756
.byte 3
.ascii "foo"
.quad 837061429793323041
.quad 281547593931412
.byte 4
.ascii "foo2"
```
With inlining turned on, the assembly may look different around %bb2 with an inlined probe:
```
# %bb.2: # %bb2
.pseudoprobe 837061429793323041 3 0
.pseudoprobe 6699318081062747564 1 0 @ 837061429793323041:6
.pseudoprobe 837061429793323041 4 0
popq %rax
retq
```
**Disassembling**
We have a disassembling tool (llvm-profgen) that can display disassembly alongside with pseudo probes. So far it only supports ELF executable file.
An example disassembly looks like:
```
00000000002011a0 <foo2>:
2011a0: 50 push rax
2011a1: 85 ff test edi,edi
[Probe]: FUNC: foo2 Index: 1 Type: Block
2011a3: 74 02 je 2011a7 <foo2+0x7>
[Probe]: FUNC: foo2 Index: 3 Type: Block
[Probe]: FUNC: foo2 Index: 4 Type: Block
[Probe]: FUNC: foo Index: 1 Type: Block Inlined: @ foo2:6
2011a5: 58 pop rax
2011a6: c3 ret
[Probe]: FUNC: foo2 Index: 2 Type: Block
2011a7: bf 01 00 00 00 mov edi,0x1
[Probe]: FUNC: foo2 Index: 5 Type: IndirectCall
2011ac: ff d6 call rsi
[Probe]: FUNC: foo2 Index: 4 Type: Block
2011ae: 58 pop rax
2011af: c3 ret
```
Reviewed By: wmi
Differential Revision: https://reviews.llvm.org/D91878
2020-12-09 07:37:32 +08:00
|
|
|
if (NamedMDNode *FuncInfo = M.getNamedMetadata(PseudoProbeDescMetadataName)) {
|
|
|
|
|
// Emit a descriptor for every function including functions that have an
|
|
|
|
|
// available external linkage. We may not want this for imported functions
|
|
|
|
|
// that has code in another thinLTO module but we don't have a good way to
|
|
|
|
|
// tell them apart from inline functions defined in header files. Therefore
|
|
|
|
|
// we put each descriptor in a separate comdat section and rely on the
|
|
|
|
|
// linker to deduplicate.
|
|
|
|
|
for (const auto *Operand : FuncInfo->operands()) {
|
|
|
|
|
const auto *MD = cast<MDNode>(Operand);
|
|
|
|
|
auto *GUID = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
|
|
|
|
|
auto *Hash = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
|
|
|
|
|
auto *Name = cast<MDString>(MD->getOperand(2));
|
|
|
|
|
auto *S = C.getObjectFileInfo()->getPseudoProbeDescSection(
|
|
|
|
|
TM->getFunctionSections() ? Name->getString() : StringRef());
|
|
|
|
|
|
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
|
Streamer.emitInt64(GUID->getZExtValue());
|
|
|
|
|
Streamer.emitInt64(Hash->getZExtValue());
|
|
|
|
|
Streamer.emitULEB128IntValue(Name->getString().size());
|
|
|
|
|
Streamer.emitBytes(Name->getString());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
unsigned Version = 0;
|
|
|
|
|
unsigned Flags = 0;
|
|
|
|
|
StringRef Section;
|
|
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
GetObjCImageInfo(M, Version, Flags, Section);
|
2018-07-16 08:28:24 +08:00
|
|
|
if (!Section.empty()) {
|
|
|
|
|
auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
|
|
|
|
|
Streamer.SwitchSection(S);
|
2020-02-15 11:21:58 +08:00
|
|
|
Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
|
2020-03-01 00:25:22 +08:00
|
|
|
Streamer.emitInt32(Version);
|
|
|
|
|
Streamer.emitInt32(Flags);
|
2018-07-16 08:28:24 +08:00
|
|
|
Streamer.AddBlankLine();
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-12 09:21:23 +08:00
|
|
|
emitCGProfileMetadata(Streamer, M);
|
2017-06-06 05:26:39 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-20 01:23:20 +08:00
|
|
|
MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, const TargetMachine &TM,
|
2014-02-20 01:23:20 +08:00
|
|
|
MachineModuleInfo *MMI) const {
|
2011-04-28 07:17:57 +08:00
|
|
|
unsigned Encoding = getPersonalityEncoding();
|
2017-02-28 06:45:06 +08:00
|
|
|
if ((Encoding & 0x80) == DW_EH_PE_indirect)
|
2015-05-19 02:43:14 +08:00
|
|
|
return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
|
2016-11-23 00:17:20 +08:00
|
|
|
TM.getSymbol(GV)->getName());
|
2017-02-28 06:45:06 +08:00
|
|
|
if ((Encoding & 0x70) == DW_EH_PE_absptr)
|
2016-11-23 00:17:20 +08:00
|
|
|
return TM.getSymbol(GV);
|
2014-05-31 00:48:56 +08:00
|
|
|
report_fatal_error("We do not support this DWARF encoding yet!");
|
2011-04-16 11:51:21 +08:00
|
|
|
}
|
|
|
|
|
|
2015-07-16 14:04:17 +08:00
|
|
|
void TargetLoweringObjectFileELF::emitPersonalityValue(
|
|
|
|
|
MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
|
2011-06-13 11:09:13 +08:00
|
|
|
SmallString<64> NameData("DW.ref.");
|
|
|
|
|
NameData += Sym->getName();
|
2015-06-02 08:25:12 +08:00
|
|
|
MCSymbolELF *Label =
|
|
|
|
|
cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
|
2020-02-15 10:16:24 +08:00
|
|
|
Streamer.emitSymbolAttribute(Label, MCSA_Hidden);
|
|
|
|
|
Streamer.emitSymbolAttribute(Label, MCSA_Weak);
|
2011-04-28 05:29:52 +08:00
|
|
|
unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
|
2016-07-01 14:07:38 +08:00
|
|
|
MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
|
|
|
|
|
ELF::SHT_PROGBITS, Flags, 0);
|
2015-07-16 14:04:17 +08:00
|
|
|
unsigned Size = DL.getPointerSize();
|
2011-04-28 05:29:52 +08:00
|
|
|
Streamer.SwitchSection(Sec);
|
2020-02-15 11:21:58 +08:00
|
|
|
Streamer.emitValueToAlignment(DL.getPointerABIAlignment(0).value());
|
2020-02-15 10:16:24 +08:00
|
|
|
Streamer.emitSymbolAttribute(Label, MCSA_ELF_TypeObject);
|
2015-05-30 09:25:56 +08:00
|
|
|
const MCExpr *E = MCConstantExpr::create(Size, getContext());
|
2015-06-02 08:25:12 +08:00
|
|
|
Streamer.emitELFSize(Label, E);
|
2020-02-15 11:21:58 +08:00
|
|
|
Streamer.emitLabel(Label);
|
2011-04-28 05:29:52 +08:00
|
|
|
|
2020-02-15 11:21:58 +08:00
|
|
|
Streamer.emitSymbolValue(Sym, Size);
|
2011-04-16 11:51:21 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-09 22:50:44 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
|
|
|
|
|
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2017-02-28 06:45:06 +08:00
|
|
|
if (Encoding & DW_EH_PE_indirect) {
|
2012-11-14 09:47:00 +08:00
|
|
|
MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
|
2012-11-14 09:47:00 +08:00
|
|
|
|
|
|
|
|
// Add information about the stub reference to ELFMMI so that the stub
|
|
|
|
|
// gets emitted by the asmprinter.
|
|
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2012-11-14 09:47:00 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TargetLoweringObjectFile::
|
2015-05-30 09:25:56 +08:00
|
|
|
getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
|
2017-02-28 06:45:06 +08:00
|
|
|
Encoding & ~DW_EH_PE_indirect, Streamer);
|
2012-11-14 09:47:00 +08:00
|
|
|
}
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
|
|
|
|
|
MMI, Streamer);
|
2012-11-14 09:47:00 +08:00
|
|
|
}
|
|
|
|
|
|
2017-10-21 05:28:38 +08:00
|
|
|
static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
|
2018-05-17 04:34:00 +08:00
|
|
|
// N.B.: The defaults used in here are not the same ones used in MC.
|
2011-05-24 11:10:31 +08:00
|
|
|
// We follow gcc, MC follows gas. For example, given ".section .eh_frame",
|
|
|
|
|
// both gas and MC will produce a section with no flags. Given
|
2012-07-19 08:04:14 +08:00
|
|
|
// section(".eh_frame") gcc will produce:
|
|
|
|
|
//
|
|
|
|
|
// .section .eh_frame,"a",@progbits
|
2017-04-15 01:48:40 +08:00
|
|
|
|
2017-04-15 08:09:57 +08:00
|
|
|
if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
|
2019-10-22 02:48:38 +08:00
|
|
|
/*AddSegmentInfo=*/false) ||
|
|
|
|
|
Name == getInstrProfSectionName(IPSK_covfun, Triple::ELF,
|
2020-08-26 04:37:29 +08:00
|
|
|
/*AddSegmentInfo=*/false) ||
|
|
|
|
|
Name == ".llvmbc" || Name == ".llvmcmd")
|
2016-01-15 02:09:45 +08:00
|
|
|
return SectionKind::getMetadata();
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Name.empty() || Name[0] != '.') return K;
|
|
|
|
|
|
2018-05-18 10:39:57 +08:00
|
|
|
// Default implementation based on some magic section names.
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Name == ".bss" ||
|
|
|
|
|
Name.startswith(".bss.") ||
|
|
|
|
|
Name.startswith(".gnu.linkonce.b.") ||
|
|
|
|
|
Name.startswith(".llvm.linkonce.b.") ||
|
|
|
|
|
Name == ".sbss" ||
|
|
|
|
|
Name.startswith(".sbss.") ||
|
|
|
|
|
Name.startswith(".gnu.linkonce.sb.") ||
|
|
|
|
|
Name.startswith(".llvm.linkonce.sb."))
|
|
|
|
|
return SectionKind::getBSS();
|
|
|
|
|
|
|
|
|
|
if (Name == ".tdata" ||
|
|
|
|
|
Name.startswith(".tdata.") ||
|
|
|
|
|
Name.startswith(".gnu.linkonce.td.") ||
|
|
|
|
|
Name.startswith(".llvm.linkonce.td."))
|
|
|
|
|
return SectionKind::getThreadData();
|
|
|
|
|
|
|
|
|
|
if (Name == ".tbss" ||
|
|
|
|
|
Name.startswith(".tbss.") ||
|
|
|
|
|
Name.startswith(".gnu.linkonce.tb.") ||
|
|
|
|
|
Name.startswith(".llvm.linkonce.tb."))
|
|
|
|
|
return SectionKind::getThreadBSS();
|
|
|
|
|
|
|
|
|
|
return K;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned getELFSectionType(StringRef Name, SectionKind K) {
|
2016-09-21 04:21:13 +08:00
|
|
|
// Use SHT_NOTE for section whose name starts with ".note" to allow
|
|
|
|
|
// emitting ELF notes from C variable declaration.
|
|
|
|
|
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
|
|
|
|
|
if (Name.startswith(".note"))
|
|
|
|
|
return ELF::SHT_NOTE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (Name == ".init_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_INIT_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (Name == ".fini_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_FINI_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (Name == ".preinit_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_PREINIT_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (K.isBSS() || K.isThreadBSS())
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_NOBITS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_PROGBITS;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
static unsigned getELFSectionFlags(SectionKind K) {
|
2010-02-16 06:37:53 +08:00
|
|
|
unsigned Flags = 0;
|
|
|
|
|
|
|
|
|
|
if (!K.isMetadata())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_ALLOC;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (K.isText())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_EXECINSTR;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2016-12-15 15:59:08 +08:00
|
|
|
if (K.isExecuteOnly())
|
|
|
|
|
Flags |= ELF::SHF_ARM_PURECODE;
|
|
|
|
|
|
2011-06-08 07:26:45 +08:00
|
|
|
if (K.isWriteable())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_WRITE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (K.isThreadLocal())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_TLS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
if (K.isMergeableCString() || K.isMergeableConst())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_MERGE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
if (K.isMergeableCString())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_STRINGS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
return Flags;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
static const Comdat *getELFComdat(const GlobalValue *GV) {
|
|
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
|
if (!C)
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
if (C->getSelectionKind() != Comdat::Any)
|
|
|
|
|
report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
|
|
|
|
|
C->getName() + "' cannot be lowered.");
|
|
|
|
|
|
|
|
|
|
return C;
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-06 03:24:15 +08:00
|
|
|
static const MCSymbolELF *getLinkedToSymbol(const GlobalObject *GO,
|
|
|
|
|
const TargetMachine &TM) {
|
2017-03-18 06:17:24 +08:00
|
|
|
MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
|
|
|
|
|
if (!MD)
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
2017-05-09 07:46:20 +08:00
|
|
|
const MDOperand &Op = MD->getOperand(0);
|
|
|
|
|
if (!Op.get())
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
auto *VM = dyn_cast<ValueAsMetadata>(Op);
|
2017-03-18 06:17:24 +08:00
|
|
|
if (!VM)
|
|
|
|
|
report_fatal_error("MD_associated operand is not ValueAsMetadata");
|
|
|
|
|
|
2019-07-19 05:37:16 +08:00
|
|
|
auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
|
|
|
|
|
return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr;
|
2017-03-18 06:17:24 +08:00
|
|
|
}
|
|
|
|
|
|
[MC][ELF] fix newly added test
Summary:
Reland of
- r344197 "[MC][ELF] compute entity size for explicit sections"
- r344206 "[MC][ELF] Fix section_mergeable_size.ll"
after being reverted in r344278 due to build breakages from not
specifying a target triple.
Move test from test/CodeGen/Generic/ to test/MC/ELF/.
Add explicit target triple so we don't try to run
this test on non ELF targets.
Reported: https://reviews.llvm.org/D53056#1261707
Reviewers: fhahn, rnk, espindola, NoQ
Reviewed By: fhahn, rnk
Subscribers: NoQ, MaskRay, rengolin, emaste, arichardson, llvm-commits, pirama, srhines
Differential Revision: https://reviews.llvm.org/D53146
llvm-svn: 344360
2018-10-13 00:35:44 +08:00
|
|
|
static unsigned getEntrySizeForKind(SectionKind Kind) {
|
|
|
|
|
if (Kind.isMergeable1ByteCString())
|
|
|
|
|
return 1;
|
|
|
|
|
else if (Kind.isMergeable2ByteCString())
|
|
|
|
|
return 2;
|
|
|
|
|
else if (Kind.isMergeable4ByteCString())
|
|
|
|
|
return 4;
|
|
|
|
|
else if (Kind.isMergeableConst4())
|
|
|
|
|
return 4;
|
|
|
|
|
else if (Kind.isMergeableConst8())
|
|
|
|
|
return 8;
|
|
|
|
|
else if (Kind.isMergeableConst16())
|
|
|
|
|
return 16;
|
|
|
|
|
else if (Kind.isMergeableConst32())
|
|
|
|
|
return 32;
|
|
|
|
|
else {
|
|
|
|
|
// We shouldn't have mergeable C strings or mergeable constants that we
|
|
|
|
|
// didn't handle above.
|
|
|
|
|
assert(!Kind.isMergeableCString() && "unknown string width");
|
|
|
|
|
assert(!Kind.isMergeableConst() && "unknown data width");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
/// Return the section prefix name used by options FunctionsSections and
|
|
|
|
|
/// DataSections.
|
|
|
|
|
static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
|
|
|
|
|
if (Kind.isText())
|
|
|
|
|
return ".text";
|
|
|
|
|
if (Kind.isReadOnly())
|
|
|
|
|
return ".rodata";
|
|
|
|
|
if (Kind.isBSS())
|
|
|
|
|
return ".bss";
|
|
|
|
|
if (Kind.isThreadData())
|
|
|
|
|
return ".tdata";
|
|
|
|
|
if (Kind.isThreadBSS())
|
|
|
|
|
return ".tbss";
|
|
|
|
|
if (Kind.isData())
|
|
|
|
|
return ".data";
|
|
|
|
|
if (Kind.isReadOnlyWithRel())
|
|
|
|
|
return ".data.rel.ro";
|
|
|
|
|
llvm_unreachable("Unknown section kind");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static SmallString<128>
|
|
|
|
|
getELFSectionNameForGlobal(const GlobalObject *GO, SectionKind Kind,
|
|
|
|
|
Mangler &Mang, const TargetMachine &TM,
|
|
|
|
|
unsigned EntrySize, bool UniqueSectionName) {
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
if (Kind.isMergeableCString()) {
|
|
|
|
|
// We also need alignment here.
|
|
|
|
|
// FIXME: this is getting the alignment of the character, not the
|
|
|
|
|
// alignment of the global!
|
2020-06-29 19:24:36 +08:00
|
|
|
Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
cast<GlobalVariable>(GO));
|
|
|
|
|
|
|
|
|
|
std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
|
2020-06-29 19:24:36 +08:00
|
|
|
Name = SizeSpec + utostr(Alignment.value());
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
} else if (Kind.isMergeableConst()) {
|
|
|
|
|
Name = ".rodata.cst";
|
|
|
|
|
Name += utostr(EntrySize);
|
|
|
|
|
} else {
|
|
|
|
|
Name = getSectionPrefixForGlobal(Kind);
|
|
|
|
|
}
|
|
|
|
|
|
[TargetLoweringObjectFileImpl] Produce .text.hot. instead of .text.hot for -fno-unique-section-names
GNU ld's internal linker script uses (https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=add44f8d5c5c05e08b11e033127a744d61c26aee)
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(SORT(.text.sorted.*))
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf.em. */
*(.gnu.warning)
}
Because `*(.text.exit .text.exit.*)` is ordered before `*(.text .text.*)`, in a -ffunction-sections build, the C library function `exit` will be placed before other functions.
gold's `-z keep-text-section-prefix` has the same problem.
In lld, `-z keep-text-section-prefix` recognizes `.text.{exit,hot,startup,unlikely,unknown}.*`, but not `.text.{exit,hot,startup,unlikely,unknown}`, to avoid the strange placement problem.
In -fno-function-sections or -fno-unique-section-names mode, a function whose `function_section_prefix` is set to `.exit"`
will go to the output section `.text` instead of `.text.exit` when linked by lld.
To address the problem, append a dot to become `.text.exit.`
Reviewed By: grimar
Differential Revision: https://reviews.llvm.org/D79600
2020-05-08 05:00:24 +08:00
|
|
|
bool HasPrefix = false;
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
if (const auto *F = dyn_cast<Function>(GO)) {
|
[TargetLoweringObjectFileImpl] Produce .text.hot. instead of .text.hot for -fno-unique-section-names
GNU ld's internal linker script uses (https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=add44f8d5c5c05e08b11e033127a744d61c26aee)
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(SORT(.text.sorted.*))
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf.em. */
*(.gnu.warning)
}
Because `*(.text.exit .text.exit.*)` is ordered before `*(.text .text.*)`, in a -ffunction-sections build, the C library function `exit` will be placed before other functions.
gold's `-z keep-text-section-prefix` has the same problem.
In lld, `-z keep-text-section-prefix` recognizes `.text.{exit,hot,startup,unlikely,unknown}.*`, but not `.text.{exit,hot,startup,unlikely,unknown}`, to avoid the strange placement problem.
In -fno-function-sections or -fno-unique-section-names mode, a function whose `function_section_prefix` is set to `.exit"`
will go to the output section `.text` instead of `.text.exit` when linked by lld.
To address the problem, append a dot to become `.text.exit.`
Reviewed By: grimar
Differential Revision: https://reviews.llvm.org/D79600
2020-05-08 05:00:24 +08:00
|
|
|
if (Optional<StringRef> Prefix = F->getSectionPrefix()) {
|
[CodeGen] Add text section prefix for COFF object file
Text section prefix is created in CodeGenPrepare, it's file format independent implementation, text section name is written into object file in TargetLoweringObjectFile, it's file format dependent implementation, port code of adding text section prefix to text section name from ELF to COFF.
Different with ELF that use '.' as concatenation character, COFF use '$' as concatenation character. That is, concatenation character is variable, so split concatenation character from text section prefix.
Text section prefix is existing feature of ELF, it can help to reduce icache and itlb misses, it's also make possible aggregate other compilers e.g. v8 created same prefix sections. Furthermore, the recent feature Machine Function Splitter (basic block level text prefix section) is based on text section prefix.
Reviewed By: pengfei, rnk
Differential Revision: https://reviews.llvm.org/D92073
2020-12-08 17:57:03 +08:00
|
|
|
raw_svector_ostream(Name) << '.' << *Prefix;
|
[TargetLoweringObjectFileImpl] Produce .text.hot. instead of .text.hot for -fno-unique-section-names
GNU ld's internal linker script uses (https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=add44f8d5c5c05e08b11e033127a744d61c26aee)
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(SORT(.text.sorted.*))
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf.em. */
*(.gnu.warning)
}
Because `*(.text.exit .text.exit.*)` is ordered before `*(.text .text.*)`, in a -ffunction-sections build, the C library function `exit` will be placed before other functions.
gold's `-z keep-text-section-prefix` has the same problem.
In lld, `-z keep-text-section-prefix` recognizes `.text.{exit,hot,startup,unlikely,unknown}.*`, but not `.text.{exit,hot,startup,unlikely,unknown}`, to avoid the strange placement problem.
In -fno-function-sections or -fno-unique-section-names mode, a function whose `function_section_prefix` is set to `.exit"`
will go to the output section `.text` instead of `.text.exit` when linked by lld.
To address the problem, append a dot to become `.text.exit.`
Reviewed By: grimar
Differential Revision: https://reviews.llvm.org/D79600
2020-05-08 05:00:24 +08:00
|
|
|
HasPrefix = true;
|
|
|
|
|
}
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (UniqueSectionName) {
|
|
|
|
|
Name.push_back('.');
|
|
|
|
|
TM.getNameWithPrefix(Name, GO, Mang, /*MayAlwaysUsePrivate*/true);
|
[TargetLoweringObjectFileImpl] Produce .text.hot. instead of .text.hot for -fno-unique-section-names
GNU ld's internal linker script uses (https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=add44f8d5c5c05e08b11e033127a744d61c26aee)
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(SORT(.text.sorted.*))
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf.em. */
*(.gnu.warning)
}
Because `*(.text.exit .text.exit.*)` is ordered before `*(.text .text.*)`, in a -ffunction-sections build, the C library function `exit` will be placed before other functions.
gold's `-z keep-text-section-prefix` has the same problem.
In lld, `-z keep-text-section-prefix` recognizes `.text.{exit,hot,startup,unlikely,unknown}.*`, but not `.text.{exit,hot,startup,unlikely,unknown}`, to avoid the strange placement problem.
In -fno-function-sections or -fno-unique-section-names mode, a function whose `function_section_prefix` is set to `.exit"`
will go to the output section `.text` instead of `.text.exit` when linked by lld.
To address the problem, append a dot to become `.text.exit.`
Reviewed By: grimar
Differential Revision: https://reviews.llvm.org/D79600
2020-05-08 05:00:24 +08:00
|
|
|
} else if (HasPrefix)
|
|
|
|
|
Name.push_back('.');
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
return Name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
class LoweringDiagnosticInfo : public DiagnosticInfo {
|
|
|
|
|
const Twine &Msg;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
LoweringDiagnosticInfo(const Twine &DiagMsg,
|
|
|
|
|
DiagnosticSeverity Severity = DS_Error)
|
|
|
|
|
: DiagnosticInfo(DK_Lowering, Severity), Msg(DiagMsg) {}
|
|
|
|
|
void print(DiagnosticPrinter &DP) const override { DP << Msg; }
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
|
StringRef SectionName = GO->getSection();
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2017-06-05 18:09:13 +08:00
|
|
|
// Check if '#pragma clang section' name is applicable.
|
|
|
|
|
// Note that pragma directive overrides -ffunction-section, -fdata-section
|
|
|
|
|
// and so section name is exactly as user specified and not uniqued.
|
|
|
|
|
const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
|
|
|
|
|
if (GV && GV->hasImplicitSection()) {
|
|
|
|
|
auto Attrs = GV->getAttributes();
|
|
|
|
|
if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
|
|
|
|
|
SectionName = Attrs.getAttribute("bss-section").getValueAsString();
|
|
|
|
|
} else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
|
|
|
|
|
SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
|
2019-10-16 02:31:10 +08:00
|
|
|
} else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
|
|
|
|
|
SectionName = Attrs.getAttribute("relro-section").getValueAsString();
|
2017-06-05 18:09:13 +08:00
|
|
|
} else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
|
|
|
|
|
SectionName = Attrs.getAttribute("data-section").getValueAsString();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
const Function *F = dyn_cast<Function>(GO);
|
|
|
|
|
if (F && F->hasFnAttribute("implicit-section-name")) {
|
|
|
|
|
SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
// Infer section flags from the section name if we can.
|
|
|
|
|
Kind = getELFKindForNamedSection(SectionName, Kind);
|
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
StringRef Group = "";
|
2015-02-25 08:52:15 +08:00
|
|
|
unsigned Flags = getELFSectionFlags(Kind);
|
2016-10-25 03:23:39 +08:00
|
|
|
if (const Comdat *C = getELFComdat(GO)) {
|
2014-06-28 02:19:56 +08:00
|
|
|
Group = C->getName();
|
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
|
}
|
2017-03-18 06:17:24 +08:00
|
|
|
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
unsigned EntrySize = getEntrySizeForKind(Kind);
|
|
|
|
|
|
2017-03-18 06:17:24 +08:00
|
|
|
// A section can have at most one associated section. Put each global with
|
|
|
|
|
// MD_associated in a unique section.
|
2019-08-08 04:45:23 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
2020-02-06 03:24:15 +08:00
|
|
|
const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
|
2020-08-04 04:35:59 +08:00
|
|
|
if (GO->getMetadata(LLVMContext::MD_associated)) {
|
2019-08-08 04:45:23 +08:00
|
|
|
UniqueID = NextUniqueID++;
|
2017-03-18 06:17:24 +08:00
|
|
|
Flags |= ELF::SHF_LINK_ORDER;
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
} else {
|
|
|
|
|
if (getContext().getAsmInfo()->useIntegratedAssembler()) {
|
|
|
|
|
// Symbols must be placed into sections with compatible entry
|
|
|
|
|
// sizes. Generate unique sections for symbols that have not
|
|
|
|
|
// been assigned to compatible sections.
|
|
|
|
|
if (Flags & ELF::SHF_MERGE) {
|
|
|
|
|
auto maybeID = getContext().getELFUniqueIDForEntsize(SectionName, Flags,
|
|
|
|
|
EntrySize);
|
|
|
|
|
if (maybeID)
|
|
|
|
|
UniqueID = *maybeID;
|
|
|
|
|
else {
|
|
|
|
|
// If the user has specified the same section name as would be created
|
|
|
|
|
// implicitly for this symbol e.g. .rodata.str1.1, then we don't need
|
|
|
|
|
// to unique the section as the entry size for this symbol will be
|
|
|
|
|
// compatible with implicitly created sections.
|
|
|
|
|
SmallString<128> ImplicitSectionNameStem = getELFSectionNameForGlobal(
|
|
|
|
|
GO, Kind, getMangler(), TM, EntrySize, false);
|
|
|
|
|
if (!(getContext().isELFImplicitMergeableSectionNamePrefix(
|
|
|
|
|
SectionName) &&
|
|
|
|
|
SectionName.startswith(ImplicitSectionNameStem)))
|
|
|
|
|
UniqueID = NextUniqueID++;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// We need to unique the section if the user has explicity
|
|
|
|
|
// assigned a non-mergeable symbol to a section name for
|
|
|
|
|
// a generic mergeable section.
|
|
|
|
|
if (getContext().isELFGenericMergeableSection(SectionName)) {
|
|
|
|
|
auto maybeID = getContext().getELFUniqueIDForEntsize(
|
|
|
|
|
SectionName, Flags, EntrySize);
|
|
|
|
|
UniqueID = maybeID ? *maybeID : NextUniqueID++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// If two symbols with differing sizes end up in the same mergeable
|
|
|
|
|
// section that section can be assigned an incorrect entry size. To avoid
|
|
|
|
|
// this we usually put symbols of the same size into distinct mergeable
|
|
|
|
|
// sections with the same name. Doing so relies on the ",unique ,"
|
|
|
|
|
// assembly feature. This feature is not avalible until bintuils
|
|
|
|
|
// version 2.35 (https://sourceware.org/bugzilla/show_bug.cgi?id=25380).
|
|
|
|
|
Flags &= ~ELF::SHF_MERGE;
|
|
|
|
|
EntrySize = 0;
|
|
|
|
|
}
|
2017-03-18 06:17:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSectionELF *Section = getContext().getELFSection(
|
|
|
|
|
SectionName, getELFSectionType(SectionName, Kind), Flags,
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
EntrySize, Group, UniqueID, LinkedToSym);
|
2017-03-18 06:17:24 +08:00
|
|
|
// Make sure that we did not get some other section with incompatible sh_link.
|
|
|
|
|
// This should not be possible due to UniqueID code above.
|
2020-02-06 03:24:15 +08:00
|
|
|
assert(Section->getLinkedToSymbol() == LinkedToSym &&
|
2018-06-21 15:15:14 +08:00
|
|
|
"Associated symbol mismatch between sections");
|
2010-02-16 06:37:53 +08:00
|
|
|
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
if (!getContext().getAsmInfo()->useIntegratedAssembler()) {
|
|
|
|
|
// If we are not using the integrated assembler then this symbol might have
|
|
|
|
|
// been placed in an incompatible mergeable section. Emit an error if this
|
|
|
|
|
// is the case to avoid creating broken output.
|
|
|
|
|
if ((Section->getFlags() & ELF::SHF_MERGE) &&
|
|
|
|
|
(Section->getEntrySize() != getEntrySizeForKind(Kind)))
|
|
|
|
|
GO->getContext().diagnose(LoweringDiagnosticInfo(
|
|
|
|
|
"Symbol '" + GO->getName() + "' from module '" +
|
|
|
|
|
(GO->getParent() ? GO->getParent()->getSourceFileName() : "unknown") +
|
|
|
|
|
"' required a section with entry-size=" +
|
|
|
|
|
Twine(getEntrySizeForKind(Kind)) + " but was placed in section '" +
|
|
|
|
|
SectionName + "' with entry-size=" + Twine(Section->getEntrySize()) +
|
|
|
|
|
": Explicit assignment by pragma or attribute of an incompatible "
|
|
|
|
|
"symbol to this section?"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return Section;
|
2010-04-13 08:36:43 +08:00
|
|
|
}
|
|
|
|
|
|
2017-03-18 06:17:24 +08:00
|
|
|
static MCSectionELF *selectELFSectionForGlobal(
|
|
|
|
|
MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
|
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
|
|
|
|
|
unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
StringRef Group = "";
|
2016-10-25 03:23:39 +08:00
|
|
|
if (const Comdat *C = getELFComdat(GO)) {
|
2015-02-25 08:52:15 +08:00
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
|
Group = C->getName();
|
|
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2018-08-01 09:29:30 +08:00
|
|
|
// Get the section entry size based on the kind.
|
|
|
|
|
unsigned EntrySize = getEntrySizeForKind(Kind);
|
|
|
|
|
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
bool UniqueSectionName = false;
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
2018-08-01 09:03:34 +08:00
|
|
|
if (EmitUniqueSection) {
|
|
|
|
|
if (TM.getUniqueSectionNames()) {
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
UniqueSectionName = true;
|
2018-08-01 09:03:34 +08:00
|
|
|
} else {
|
|
|
|
|
UniqueID = *NextUniqueID;
|
|
|
|
|
(*NextUniqueID)++;
|
|
|
|
|
}
|
2015-04-05 02:02:01 +08:00
|
|
|
}
|
[MC][ELF] Put explicit section name symbols into entry size compatible sections
Ensure that symbols explicitly* assigned a section name are placed into
a section with a compatible entry size.
This is done by creating multiple sections with the same name** if
incompatible symbols are explicitly given the name of an incompatible
section, whilst:
- Avoiding using uniqued sections where possible (for readability and
to maximize compatibly with assemblers).
- Creating as few SHF_MERGE sections as possible (for efficiency).
Given that each symbol is assigned to a section in a single pass, we
must decide which section each symbol is assigned to without seeing the
properties of all symbols. A stable and easy to understand assignment is
desirable. The following rules facilitate this: The "generic" section
for a given section name will be mergeable if the name is a mergeable
"default" section name (such as .debug_str), a mergeable "implicit"
section name (such as .rodata.str2.2), or MC has already created a
mergeable "generic" section for the given section name (e.g. in response
to a section directive in inline assembly). Otherwise, the "generic"
section for a given name is non-mergeable; and, non-mergeable symbols
are assigned to the "generic" section, while mergeable symbols are
assigned to uniqued sections.
Terminology:
"default" sections are those always created by MC initially, e.g. .text
or .debug_str.
"implicit" sections are those created normally by MC in response to the
symbols that it encounters, i.e. in the absence of an explicit section
name assignment on the symbol, e.g. a function foo might be placed into
a .text.foo section.
"generic" sections are those that are referred to when a unique section
ID is not supplied, e.g. if there are multiple unique .bob sections then
".quad .bob" will reference the generic .bob section. Typically, the
generic section is just the first section of a given name to be created.
Default sections are always generic.
* Typically, section names might be explicitly assigned in source code
using a language extension e.g. a section attribute: _attribute_
((section ("section-name"))) -
https://clang.llvm.org/docs/AttributeReference.html
** I refer to such sections as unique/uniqued sections. In assembly the
", unique," assembly syntax is used to express such sections.
Fixes https://bugs.llvm.org/show_bug.cgi?id=43457.
See https://reviews.llvm.org/D68101 for previous discussions leading to
this patch.
Some minor fixes were required to LLVM's tests, for tests had been using
the old behavior - which allowed for explicitly assigning globals with
incompatible entry sizes to a section.
This fix relies on the ",unique ," assembly feature. This feature is not
available until bintuils version 2.35
(https://sourceware.org/bugzilla/show_bug.cgi?id=25380). If the
integrated assembler is not being used then we avoid using this feature
for compatibility and instead try to place mergeable symbols into
non-mergeable sections or issue an error otherwise.
Differential Revision: https://reviews.llvm.org/D72194
2020-04-16 18:45:31 +08:00
|
|
|
SmallString<128> Name = getELFSectionNameForGlobal(
|
|
|
|
|
GO, Kind, Mang, TM, EntrySize, UniqueSectionName);
|
|
|
|
|
|
2018-08-01 09:03:34 +08:00
|
|
|
// Use 0 as the unique ID for execute-only text.
|
2016-12-15 15:59:08 +08:00
|
|
|
if (Kind.isExecuteOnly())
|
|
|
|
|
UniqueID = 0;
|
2015-02-27 07:55:11 +08:00
|
|
|
return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
|
2017-03-18 06:17:24 +08:00
|
|
|
EntrySize, Group, UniqueID, AssociatedSymbol);
|
2015-02-27 07:55:11 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2015-02-27 07:55:11 +08:00
|
|
|
unsigned Flags = getELFSectionFlags(Kind);
|
|
|
|
|
|
|
|
|
|
// If we have -ffunction-section or -fdata-section then we should emit the
|
|
|
|
|
// global value to a uniqued section specifically for it.
|
|
|
|
|
bool EmitUniqueSection = false;
|
|
|
|
|
if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
|
|
|
|
|
if (Kind.isText())
|
|
|
|
|
EmitUniqueSection = TM.getFunctionSections();
|
|
|
|
|
else
|
|
|
|
|
EmitUniqueSection = TM.getDataSections();
|
|
|
|
|
}
|
2016-10-25 03:23:39 +08:00
|
|
|
EmitUniqueSection |= GO->hasComdat();
|
2015-02-27 07:55:11 +08:00
|
|
|
|
2020-02-06 03:24:15 +08:00
|
|
|
const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
|
|
|
|
|
if (LinkedToSym) {
|
2017-03-18 06:17:24 +08:00
|
|
|
EmitUniqueSection = true;
|
|
|
|
|
Flags |= ELF::SHF_LINK_ORDER;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSectionELF *Section = selectELFSectionForGlobal(
|
|
|
|
|
getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
|
2020-02-06 03:24:15 +08:00
|
|
|
&NextUniqueID, LinkedToSym);
|
|
|
|
|
assert(Section->getLinkedToSymbol() == LinkedToSym);
|
2017-03-18 06:17:24 +08:00
|
|
|
return Section;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
|
2016-09-16 15:33:15 +08:00
|
|
|
const Function &F, const TargetMachine &TM) const {
|
2015-02-13 01:16:46 +08:00
|
|
|
// If the function can be removed, produce a unique section so that
|
|
|
|
|
// the table doesn't prevent the removal.
|
|
|
|
|
const Comdat *C = F.getComdat();
|
|
|
|
|
bool EmitUniqueSection = TM.getFunctionSections() || C;
|
|
|
|
|
if (!EmitUniqueSection)
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
2015-02-27 07:55:11 +08:00
|
|
|
return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
|
2017-03-18 06:17:24 +08:00
|
|
|
getMangler(), TM, EmitUniqueSection,
|
|
|
|
|
ELF::SHF_ALLOC, &NextUniqueID,
|
|
|
|
|
/* AssociatedSymbol */ nullptr);
|
2015-02-13 01:16:46 +08:00
|
|
|
}
|
|
|
|
|
|
[AsmPrinter] Split up .gcc_except_table
MC currently produces monolithic .gcc_except_table section. GCC can split up .gcc_except_table:
* if comdat: `.section .gcc_except_table._Z6comdatv,"aG",@progbits,_Z6comdatv,comdat`
* otherwise, if -ffunction-sections: `.section .gcc_except_table._Z3fooi,"a",@progbits`
This ensures that (a) non-prevailing copies are discarded and (b)
.gcc_except_table associated to discarded text sections can be discarded by a
.gcc_except_table-aware linker (GNU ld, but not gold or LLD)
This patches matches the GCC behavior. If -fno-unique-section-names is
specified, we don't append the suffix. If -ffunction-sections is additionally specified,
use `.section ...,unique`.
Note, if clang driver communicates that the linker is LLD and we know it
is new (11.0.0 or later) we can use SHF_LINK_ORDER to avoid string table
costs, at least in the -fno-unique-section-names case. We cannot use it on GNU
ld because as of binutils 2.35 it does not support mixed SHF_LINK_ORDER &
non-SHF_LINK_ORDER components in an output section
https://sourceware.org/bugzilla/show_bug.cgi?id=26256
For RISC-V -mrelax, this patch additionally fixes an assembler-linker
interaction problem: because a section is shrinkable, the length of a call-site
code range is not a constant. Relocations referencing the associated text
section (STT_SECTION) are needed. However, a STB_LOCAL relocation referencing a
discarded section group member from outside the group is disallowed by the ELF
specification (PR46675):
```
// a.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int main() { return comdat(); }
// b.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int foo() { return comdat(); }
clang++ -target riscv64-linux -c a.cc b.cc -fPIC -mno-relax
ld.lld -shared a.o b.o => ld.lld: error: relocation refers to a symbol in a discarded section:
```
-fbasic-block-sections= is similar to RISC-V -mrelax: there are outstanding relocations.
Reviewed By: jrtc27, rahmanl
Differential Revision: https://reviews.llvm.org/D83655
2020-11-03 06:36:25 +08:00
|
|
|
MCSection *
|
|
|
|
|
TargetLoweringObjectFileELF::getSectionForLSDA(const Function &F,
|
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
// If neither COMDAT nor function sections, use the monolithic LSDA section.
|
2020-11-03 11:57:46 +08:00
|
|
|
// Re-use this path if LSDASection is null as in the Arm EHABI.
|
|
|
|
|
if (!LSDASection || (!F.hasComdat() && !TM.getFunctionSections()))
|
[AsmPrinter] Split up .gcc_except_table
MC currently produces monolithic .gcc_except_table section. GCC can split up .gcc_except_table:
* if comdat: `.section .gcc_except_table._Z6comdatv,"aG",@progbits,_Z6comdatv,comdat`
* otherwise, if -ffunction-sections: `.section .gcc_except_table._Z3fooi,"a",@progbits`
This ensures that (a) non-prevailing copies are discarded and (b)
.gcc_except_table associated to discarded text sections can be discarded by a
.gcc_except_table-aware linker (GNU ld, but not gold or LLD)
This patches matches the GCC behavior. If -fno-unique-section-names is
specified, we don't append the suffix. If -ffunction-sections is additionally specified,
use `.section ...,unique`.
Note, if clang driver communicates that the linker is LLD and we know it
is new (11.0.0 or later) we can use SHF_LINK_ORDER to avoid string table
costs, at least in the -fno-unique-section-names case. We cannot use it on GNU
ld because as of binutils 2.35 it does not support mixed SHF_LINK_ORDER &
non-SHF_LINK_ORDER components in an output section
https://sourceware.org/bugzilla/show_bug.cgi?id=26256
For RISC-V -mrelax, this patch additionally fixes an assembler-linker
interaction problem: because a section is shrinkable, the length of a call-site
code range is not a constant. Relocations referencing the associated text
section (STT_SECTION) are needed. However, a STB_LOCAL relocation referencing a
discarded section group member from outside the group is disallowed by the ELF
specification (PR46675):
```
// a.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int main() { return comdat(); }
// b.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int foo() { return comdat(); }
clang++ -target riscv64-linux -c a.cc b.cc -fPIC -mno-relax
ld.lld -shared a.o b.o => ld.lld: error: relocation refers to a symbol in a discarded section:
```
-fbasic-block-sections= is similar to RISC-V -mrelax: there are outstanding relocations.
Reviewed By: jrtc27, rahmanl
Differential Revision: https://reviews.llvm.org/D83655
2020-11-03 06:36:25 +08:00
|
|
|
return LSDASection;
|
|
|
|
|
|
|
|
|
|
const auto *LSDA = cast<MCSectionELF>(LSDASection);
|
|
|
|
|
unsigned Flags = LSDA->getFlags();
|
|
|
|
|
StringRef Group;
|
|
|
|
|
if (F.hasComdat()) {
|
|
|
|
|
Group = F.getComdat()->getName();
|
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Append the function name as the suffix like GCC, assuming
|
|
|
|
|
// -funique-section-names applies to .gcc_except_table sections.
|
|
|
|
|
if (TM.getUniqueSectionNames())
|
|
|
|
|
return getContext().getELFSection(LSDA->getName() + "." + F.getName(),
|
|
|
|
|
LSDA->getType(), Flags, 0, Group,
|
|
|
|
|
MCSection::NonUniqueID, nullptr);
|
|
|
|
|
|
|
|
|
|
// Allocate a unique ID if function sections && (integrated assembler or GNU
|
|
|
|
|
// as>=2.35). Note we could use SHF_LINK_ORDER to facilitate --gc-sections but
|
|
|
|
|
// that would require that we know the linker is a modern LLD (12.0 or later).
|
|
|
|
|
// GNU ld as of 2.35 does not support mixed SHF_LINK_ORDER &
|
|
|
|
|
// non-SHF_LINK_ORDER components in an output section
|
|
|
|
|
// https://sourceware.org/bugzilla/show_bug.cgi?id=26256
|
|
|
|
|
unsigned ID = TM.getFunctionSections() &&
|
|
|
|
|
getContext().getAsmInfo()->useIntegratedAssembler()
|
|
|
|
|
? NextUniqueID++
|
|
|
|
|
: MCSection::NonUniqueID;
|
|
|
|
|
return getContext().getELFSection(LSDA->getName(), LSDA->getType(), Flags, 0,
|
|
|
|
|
Group, ID, nullptr);
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-18 07:34:51 +08:00
|
|
|
bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
|
|
|
|
|
bool UsesLabelDifference, const Function &F) const {
|
|
|
|
|
// We can always create relative relocations, so use another section
|
|
|
|
|
// that can be marked non-executable.
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
/// Given a mergeable constant with the specified size and relocation
|
|
|
|
|
/// information, return a section that it should be placed in.
|
2015-07-16 14:04:17 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForConstant(
|
2016-02-21 09:30:30 +08:00
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
2020-05-22 06:23:00 +08:00
|
|
|
Align &Alignment) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isMergeableConst4() && MergeableConst4Section)
|
|
|
|
|
return MergeableConst4Section;
|
|
|
|
|
if (Kind.isMergeableConst8() && MergeableConst8Section)
|
|
|
|
|
return MergeableConst8Section;
|
|
|
|
|
if (Kind.isMergeableConst16() && MergeableConst16Section)
|
|
|
|
|
return MergeableConst16Section;
|
2016-02-23 06:23:11 +08:00
|
|
|
if (Kind.isMergeableConst32() && MergeableConst32Section)
|
|
|
|
|
return MergeableConst32Section;
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isReadOnly())
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
|
|
assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
|
|
|
|
|
return DataRelROSection;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-17 06:56:02 +08:00
|
|
|
/// Returns a unique section for the given machine basic block.
|
|
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock(
|
|
|
|
|
const Function &F, const MachineBasicBlock &MBB,
|
|
|
|
|
const TargetMachine &TM) const {
|
2020-04-14 03:14:42 +08:00
|
|
|
assert(MBB.isBeginSection() && "Basic block does not start a section!");
|
|
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
2020-04-14 03:12:34 +08:00
|
|
|
|
2020-10-08 02:42:02 +08:00
|
|
|
// For cold sections use the .text.split. prefix along with the parent
|
2020-04-25 05:35:19 +08:00
|
|
|
// function name. All cold blocks for the same function go to the same
|
|
|
|
|
// section. Similarly all exception blocks are grouped by symbol name
|
|
|
|
|
// under the .text.eh prefix. For regular sections, we either use a unique
|
|
|
|
|
// name, or a unique ID for the section.
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
if (MBB.getSectionID() == MBBSectionID::ColdSectionID) {
|
2020-09-17 12:40:00 +08:00
|
|
|
Name += BBSectionsColdTextPrefix;
|
2020-04-25 05:35:19 +08:00
|
|
|
Name += MBB.getParent()->getName();
|
|
|
|
|
} else if (MBB.getSectionID() == MBBSectionID::ExceptionSectionID) {
|
|
|
|
|
Name += ".text.eh.";
|
|
|
|
|
Name += MBB.getParent()->getName();
|
|
|
|
|
} else {
|
|
|
|
|
Name += MBB.getParent()->getSection()->getName();
|
2020-06-02 14:17:29 +08:00
|
|
|
if (TM.getUniqueBasicBlockSectionNames()) {
|
2020-04-14 03:14:42 +08:00
|
|
|
Name += ".";
|
|
|
|
|
Name += MBB.getSymbol()->getName();
|
2020-04-25 05:35:19 +08:00
|
|
|
} else {
|
2020-04-14 03:14:42 +08:00
|
|
|
UniqueID = NextUniqueID++;
|
2020-04-25 05:35:19 +08:00
|
|
|
}
|
2020-04-14 03:12:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
|
|
|
|
|
std::string GroupName = "";
|
|
|
|
|
if (F.hasComdat()) {
|
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
|
GroupName = F.getComdat()->getName().str();
|
|
|
|
|
}
|
|
|
|
|
return getContext().getELFSection(Name, ELF::SHT_PROGBITS, Flags,
|
2020-04-14 03:14:42 +08:00
|
|
|
0 /* Entry Size */, GroupName, UniqueID,
|
|
|
|
|
nullptr);
|
2020-04-14 03:12:34 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
|
|
|
|
|
bool IsCtor, unsigned Priority,
|
|
|
|
|
const MCSymbol *KeySym) {
|
2014-09-05 07:03:58 +08:00
|
|
|
std::string Name;
|
|
|
|
|
unsigned Type;
|
|
|
|
|
unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
|
|
|
|
|
StringRef COMDAT = KeySym ? KeySym->getName() : "";
|
|
|
|
|
|
|
|
|
|
if (KeySym)
|
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
2012-01-26 06:24:19 +08:00
|
|
|
|
2012-06-19 08:48:28 +08:00
|
|
|
if (UseInitArray) {
|
2014-09-05 08:02:50 +08:00
|
|
|
if (IsCtor) {
|
|
|
|
|
Type = ELF::SHT_INIT_ARRAY;
|
|
|
|
|
Name = ".init_array";
|
|
|
|
|
} else {
|
|
|
|
|
Type = ELF::SHT_FINI_ARRAY;
|
|
|
|
|
Name = ".fini_array";
|
|
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
if (Priority != 65535) {
|
|
|
|
|
Name += '.';
|
|
|
|
|
Name += utostr(Priority);
|
|
|
|
|
}
|
2012-06-19 08:48:28 +08:00
|
|
|
} else {
|
2014-09-05 07:03:58 +08:00
|
|
|
// The default scheme is .ctor / .dtor, so we have to invert the priority
|
|
|
|
|
// numbering.
|
2014-09-05 08:02:50 +08:00
|
|
|
if (IsCtor)
|
|
|
|
|
Name = ".ctors";
|
|
|
|
|
else
|
|
|
|
|
Name = ".dtors";
|
2017-11-28 16:07:18 +08:00
|
|
|
if (Priority != 65535)
|
|
|
|
|
raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
|
2014-09-05 07:03:58 +08:00
|
|
|
Type = ELF::SHT_PROGBITS;
|
2012-06-19 08:48:28 +08:00
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
|
2015-01-30 01:33:21 +08:00
|
|
|
return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
|
2012-01-26 06:24:19 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2014-09-05 08:02:50 +08:00
|
|
|
return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
|
|
|
|
|
KeySym);
|
|
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
|
2014-09-05 08:02:50 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
|
return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
|
|
|
|
|
KeySym);
|
2012-06-19 08:48:28 +08:00
|
|
|
}
|
|
|
|
|
|
2016-04-23 04:40:10 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
2016-04-23 04:40:10 +08:00
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
// We may only use a PLT-relative relocation to refer to unnamed_addr
|
|
|
|
|
// functions.
|
2016-06-15 05:01:22 +08:00
|
|
|
if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
|
2016-04-23 04:40:10 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
// Basic sanity checks.
|
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
|
|
|
|
|
RHS->isThreadLocal())
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
return MCBinaryExpr::createSub(
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
|
2016-04-23 04:40:10 +08:00
|
|
|
getContext()),
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
|
2016-04-23 04:40:10 +08:00
|
|
|
}
|
|
|
|
|
|
2020-04-02 06:25:04 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileELF::lowerDSOLocalEquivalent(
|
|
|
|
|
const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
|
|
|
|
|
assert(supportDSOLocalEquivalentLowering());
|
|
|
|
|
|
|
|
|
|
const auto *GV = Equiv->getGlobalValue();
|
|
|
|
|
|
|
|
|
|
// A PLT entry is not needed for dso_local globals.
|
|
|
|
|
if (GV->isDSOLocal() || GV->isImplicitDSOLocal())
|
|
|
|
|
return MCSymbolRefExpr::create(TM.getSymbol(GV), getContext());
|
|
|
|
|
|
|
|
|
|
return MCSymbolRefExpr::create(TM.getSymbol(GV), PLTRelativeVariantKind,
|
|
|
|
|
getContext());
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-14 23:38:15 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const {
|
|
|
|
|
// Use ".GCC.command.line" since this feature is to support clang's
|
|
|
|
|
// -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
|
|
|
|
|
// same name.
|
|
|
|
|
return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
|
|
|
|
|
ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-19 08:48:28 +08:00
|
|
|
void
|
|
|
|
|
TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
|
|
|
|
|
UseInitArray = UseInitArray_;
|
2016-08-29 20:33:42 +08:00
|
|
|
MCContext &Ctx = getContext();
|
|
|
|
|
if (!UseInitArray) {
|
|
|
|
|
StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
|
|
|
|
|
ELF::SHF_ALLOC | ELF::SHF_WRITE);
|
|
|
|
|
|
|
|
|
|
StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
|
|
|
|
|
ELF::SHF_ALLOC | ELF::SHF_WRITE);
|
2012-06-19 08:48:28 +08:00
|
|
|
return;
|
2016-08-29 20:33:42 +08:00
|
|
|
}
|
2012-06-19 08:48:28 +08:00
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
|
|
|
|
|
ELF::SHF_WRITE | ELF::SHF_ALLOC);
|
|
|
|
|
StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
|
|
|
|
|
ELF::SHF_WRITE | ELF::SHF_ALLOC);
|
2012-01-26 06:24:19 +08:00
|
|
|
}
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// MachO
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2015-03-06 21:49:05 +08:00
|
|
|
TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
|
|
|
|
|
: TargetLoweringObjectFile() {
|
|
|
|
|
SupportIndirectSymViaGOTPCRel = true;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
|
|
|
|
|
const TargetMachine &TM) {
|
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TM);
|
2016-08-29 20:47:22 +08:00
|
|
|
if (TM.getRelocationModel() == Reloc::Static) {
|
2016-08-29 20:33:42 +08:00
|
|
|
StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
} else {
|
|
|
|
|
StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
|
|
|
|
|
MachO::S_MOD_INIT_FUNC_POINTERS,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
|
|
|
|
|
MachO::S_MOD_TERM_FUNC_POINTERS,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
}
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
|
|
|
|
PersonalityEncoding =
|
|
|
|
|
dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel;
|
|
|
|
|
TTypeEncoding =
|
|
|
|
|
dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
2016-08-29 20:33:42 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
|
Module &M) const {
|
2013-01-19 03:37:00 +08:00
|
|
|
// Emit the linker options if present.
|
2017-06-13 04:10:48 +08:00
|
|
|
if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
2020-01-02 00:23:21 +08:00
|
|
|
for (const auto *Option : LinkerOptions->operands()) {
|
2013-01-19 03:37:00 +08:00
|
|
|
SmallVector<std::string, 4> StrOptions;
|
2016-05-01 02:15:34 +08:00
|
|
|
for (const auto &Piece : cast<MDNode>(Option)->operands())
|
2020-01-29 03:23:46 +08:00
|
|
|
StrOptions.push_back(std::string(cast<MDString>(Piece)->getString()));
|
2020-02-15 10:16:24 +08:00
|
|
|
Streamer.emitLinkerOptions(StrOptions);
|
2013-01-19 03:37:00 +08:00
|
|
|
}
|
2012-02-15 05:28:13 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
unsigned VersionVal = 0;
|
|
|
|
|
unsigned ImageInfoFlags = 0;
|
|
|
|
|
StringRef SectionVal;
|
2017-06-13 04:10:48 +08:00
|
|
|
|
|
|
|
|
GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
|
2017-06-06 05:26:39 +08:00
|
|
|
|
2012-02-16 06:36:15 +08:00
|
|
|
// The section is mandatory. If we don't have it, then we don't have GC info.
|
2017-06-06 05:26:39 +08:00
|
|
|
if (SectionVal.empty())
|
|
|
|
|
return;
|
2012-02-16 06:36:15 +08:00
|
|
|
|
|
|
|
|
StringRef Segment, Section;
|
|
|
|
|
unsigned TAA = 0, StubSize = 0;
|
|
|
|
|
bool TAAParsed;
|
|
|
|
|
std::string ErrorCode =
|
|
|
|
|
MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
|
|
|
|
|
TAA, TAAParsed, StubSize);
|
2012-02-16 06:47:53 +08:00
|
|
|
if (!ErrorCode.empty())
|
2012-02-16 06:36:15 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2012-02-16 06:47:53 +08:00
|
|
|
report_fatal_error("Invalid section specifier '" + Section + "': " +
|
|
|
|
|
ErrorCode + ".");
|
2012-02-15 05:28:13 +08:00
|
|
|
|
2012-02-16 06:36:15 +08:00
|
|
|
// Get the section.
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSectionMachO *S = getContext().getMachOSection(
|
2015-11-18 14:02:15 +08:00
|
|
|
Segment, Section, TAA, StubSize, SectionKind::getData());
|
2012-02-16 06:36:15 +08:00
|
|
|
Streamer.SwitchSection(S);
|
2020-02-15 11:21:58 +08:00
|
|
|
Streamer.emitLabel(getContext().
|
2015-05-19 02:43:14 +08:00
|
|
|
getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
|
2020-03-01 00:25:22 +08:00
|
|
|
Streamer.emitInt32(VersionVal);
|
|
|
|
|
Streamer.emitInt32(ImageInfoFlags);
|
2012-02-15 05:28:13 +08:00
|
|
|
Streamer.AddBlankLine();
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
static void checkMachOComdat(const GlobalValue *GV) {
|
|
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
|
if (!C)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
|
|
|
|
|
"' cannot be lowered.");
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// Parse the section specifier and create it if valid.
|
|
|
|
|
StringRef Segment, Section;
|
2011-03-19 10:42:31 +08:00
|
|
|
unsigned TAA = 0, StubSize = 0;
|
|
|
|
|
bool TAAParsed;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
checkMachOComdat(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
std::string ErrorCode =
|
2016-10-25 03:23:39 +08:00
|
|
|
MCSectionMachO::ParseSectionSpecifier(GO->getSection(), Segment, Section,
|
2011-03-19 10:42:31 +08:00
|
|
|
TAA, TAAParsed, StubSize);
|
2010-02-16 06:37:53 +08:00
|
|
|
if (!ErrorCode.empty()) {
|
2010-04-08 06:58:41 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2016-10-25 03:23:39 +08:00
|
|
|
report_fatal_error("Global variable '" + GO->getName() +
|
2011-11-16 00:27:03 +08:00
|
|
|
"' has an invalid section specifier '" +
|
2016-10-25 03:23:39 +08:00
|
|
|
GO->getSection() + "': " + ErrorCode + ".");
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get the section.
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSectionMachO *S =
|
|
|
|
|
getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2011-02-22 01:27:17 +08:00
|
|
|
// If TAA wasn't set by ParseSectionSpecifier() above,
|
|
|
|
|
// use the value returned by getMachOSection() as a default.
|
2011-03-19 10:42:31 +08:00
|
|
|
if (!TAAParsed)
|
2011-02-22 01:27:17 +08:00
|
|
|
TAA = S->getTypeAndAttributes();
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
// Okay, now that we got the section, verify that the TAA & StubSize agree.
|
|
|
|
|
// If the user declared multiple globals with different section flags, we need
|
|
|
|
|
// to reject it here.
|
|
|
|
|
if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
|
2010-04-08 06:58:41 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2016-10-25 03:23:39 +08:00
|
|
|
report_fatal_error("Global variable '" + GO->getName() +
|
2011-11-16 00:27:03 +08:00
|
|
|
"' section type or attributes does not match previous"
|
|
|
|
|
" section specifier");
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return S;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
|
checkMachOComdat(GO);
|
2013-11-17 18:53:13 +08:00
|
|
|
|
|
|
|
|
// Handle thread local data.
|
|
|
|
|
if (Kind.isThreadBSS()) return TLSBSSSection;
|
|
|
|
|
if (Kind.isThreadData()) return TLSDataSection;
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isText())
|
2016-10-25 03:23:39 +08:00
|
|
|
return GO->isWeakForLinker() ? TextCoalSection : TextSection;
|
2013-08-09 05:04:16 +08:00
|
|
|
|
|
|
|
|
// If this is weak/linkonce, put this in a coalescable section, either in text
|
|
|
|
|
// or data depending on if it is writable.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->isWeakForLinker()) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isReadOnly())
|
2013-08-09 05:04:16 +08:00
|
|
|
return ConstTextCoalSection;
|
2018-04-11 04:16:35 +08:00
|
|
|
if (Kind.isReadOnlyWithRel())
|
|
|
|
|
return ConstDataCoalSection;
|
2013-08-09 05:04:16 +08:00
|
|
|
return DataCoalSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// FIXME: Alignment check should be handled by section classifier.
|
2010-03-07 12:28:09 +08:00
|
|
|
if (Kind.isMergeable1ByteCString() &&
|
2020-06-29 19:24:36 +08:00
|
|
|
GO->getParent()->getDataLayout().getPreferredAlign(
|
|
|
|
|
cast<GlobalVariable>(GO)) < Align(32))
|
2010-03-07 12:28:09 +08:00
|
|
|
return CStringSection;
|
2010-10-28 02:52:20 +08:00
|
|
|
|
2010-03-07 12:28:09 +08:00
|
|
|
// Do not put 16-bit arrays in the UString section if they have an
|
|
|
|
|
// externally visible label, this runs into issues with certain linker
|
|
|
|
|
// versions.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
|
2020-06-29 19:24:36 +08:00
|
|
|
GO->getParent()->getDataLayout().getPreferredAlign(
|
|
|
|
|
cast<GlobalVariable>(GO)) < Align(32))
|
2010-03-07 12:28:09 +08:00
|
|
|
return UStringSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2014-08-29 04:13:31 +08:00
|
|
|
// With MachO only variables whose corresponding symbol starts with 'l' or
|
|
|
|
|
// 'L' can be merged, so we only try merging GVs with private linkage.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isMergeableConst4())
|
|
|
|
|
return FourByteConstantSection;
|
|
|
|
|
if (Kind.isMergeableConst8())
|
|
|
|
|
return EightByteConstantSection;
|
2014-02-14 07:16:11 +08:00
|
|
|
if (Kind.isMergeableConst16())
|
2010-02-16 06:37:53 +08:00
|
|
|
return SixteenByteConstantSection;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Otherwise, if it is readonly, but not something we can specially optimize,
|
|
|
|
|
// just drop it in .const.
|
|
|
|
|
if (Kind.isReadOnly())
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
|
|
// If this is marked const, put it into a const section. But if the dynamic
|
|
|
|
|
// linker needs to write to it, put it in the data segment.
|
|
|
|
|
if (Kind.isReadOnlyWithRel())
|
|
|
|
|
return ConstDataSection;
|
|
|
|
|
|
|
|
|
|
// Put zero initialized globals with strong external linkage in the
|
|
|
|
|
// DATA, __common section with the .zerofill directive.
|
|
|
|
|
if (Kind.isBSSExtern())
|
|
|
|
|
return DataCommonSection;
|
|
|
|
|
|
|
|
|
|
// Put zero initialized globals with local linkage in __DATA,__bss directive
|
|
|
|
|
// with the .zerofill directive (aka .lcomm).
|
|
|
|
|
if (Kind.isBSSLocal())
|
|
|
|
|
return DataBSSSection;
|
2010-10-28 02:52:20 +08:00
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
// Otherwise, just drop the variable in the normal data section.
|
|
|
|
|
return DataSection;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-16 14:04:17 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
|
2016-02-21 09:30:30 +08:00
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
2020-05-22 06:23:00 +08:00
|
|
|
Align &Alignment) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// If this constant requires a relocation, we have to put it in the data
|
|
|
|
|
// segment, not in the text segment.
|
2015-11-18 14:02:15 +08:00
|
|
|
if (Kind.isData() || Kind.isReadOnlyWithRel())
|
2010-02-16 06:37:53 +08:00
|
|
|
return ConstDataSection;
|
|
|
|
|
|
|
|
|
|
if (Kind.isMergeableConst4())
|
|
|
|
|
return FourByteConstantSection;
|
|
|
|
|
if (Kind.isMergeableConst8())
|
|
|
|
|
return EightByteConstantSection;
|
2014-02-14 07:16:11 +08:00
|
|
|
if (Kind.isMergeableConst16())
|
2010-02-16 06:37:53 +08:00
|
|
|
return SixteenByteConstantSection;
|
|
|
|
|
return ReadOnlySection; // .const
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-09 22:50:44 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
|
|
|
|
|
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// The mach-o version of this method defaults to returning a stub reference.
|
|
|
|
|
|
2010-02-22 04:28:15 +08:00
|
|
|
if (Encoding & DW_EH_PE_indirect) {
|
|
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
|
2010-02-22 04:28:15 +08:00
|
|
|
|
|
|
|
|
// Add information about the stub reference to MachOMMI so that the stub
|
|
|
|
|
// gets emitted by the asmprinter.
|
2016-05-18 00:01:32 +08:00
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2010-03-16 04:37:38 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
2010-02-22 04:28:15 +08:00
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
|
return TargetLoweringObjectFile::
|
2015-05-30 09:25:56 +08:00
|
|
|
getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
|
2017-02-28 06:45:06 +08:00
|
|
|
Encoding & ~DW_EH_PE_indirect, Streamer);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
|
|
|
|
|
MMI, Streamer);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-20 01:23:20 +08:00
|
|
|
MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, const TargetMachine &TM,
|
2014-02-20 01:23:20 +08:00
|
|
|
MachineModuleInfo *MMI) const {
|
2011-04-28 07:08:15 +08:00
|
|
|
// The mach-o version of this method defaults to returning a stub reference.
|
|
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
|
2011-04-28 07:08:15 +08:00
|
|
|
|
|
|
|
|
// Add information about the stub reference to MachOMMI so that the stub
|
|
|
|
|
// gets emitted by the asmprinter.
|
2011-11-29 09:43:20 +08:00
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2011-04-28 07:08:15 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return SSym;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-06 21:49:05 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
|
2019-08-23 00:59:00 +08:00
|
|
|
const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
|
|
|
|
|
int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2015-08-09 02:27:36 +08:00
|
|
|
// Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
|
2015-03-06 21:49:05 +08:00
|
|
|
// as 64-bit do, we replace the GOT equivalent by accessing the final symbol
|
|
|
|
|
// through a non_lazy_ptr stub instead. One advantage is that it allows the
|
|
|
|
|
// computation of deltas to final external symbols. Example:
|
|
|
|
|
//
|
|
|
|
|
// _extgotequiv:
|
|
|
|
|
// .long _extfoo
|
|
|
|
|
//
|
|
|
|
|
// _delta:
|
|
|
|
|
// .long _extgotequiv-_delta
|
|
|
|
|
//
|
|
|
|
|
// is transformed to:
|
|
|
|
|
//
|
|
|
|
|
// _delta:
|
|
|
|
|
// .long L_extfoo$non_lazy_ptr-(_delta+0)
|
|
|
|
|
//
|
|
|
|
|
// .section __IMPORT,__pointers,non_lazy_symbol_pointers
|
|
|
|
|
// L_extfoo$non_lazy_ptr:
|
|
|
|
|
// .indirect_symbol _extfoo
|
|
|
|
|
// .long 0
|
|
|
|
|
//
|
2018-12-14 01:23:30 +08:00
|
|
|
// The indirect symbol table (and sections of non_lazy_symbol_pointers type)
|
|
|
|
|
// may point to both local (same translation unit) and global (other
|
|
|
|
|
// translation units) symbols. Example:
|
|
|
|
|
//
|
|
|
|
|
// .section __DATA,__pointers,non_lazy_symbol_pointers
|
|
|
|
|
// L1:
|
|
|
|
|
// .indirect_symbol _myGlobal
|
|
|
|
|
// .long 0
|
|
|
|
|
// L2:
|
|
|
|
|
// .indirect_symbol _myLocal
|
|
|
|
|
// .long _myLocal
|
|
|
|
|
//
|
|
|
|
|
// If the symbol is local, instead of the symbol's index, the assembler
|
|
|
|
|
// places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
|
|
|
|
|
// Then the linker will notice the constant in the table and will look at the
|
|
|
|
|
// content of the symbol.
|
2015-03-06 21:49:05 +08:00
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
|
MCContext &Ctx = getContext();
|
|
|
|
|
|
|
|
|
|
// The offset must consider the original displacement from the base symbol
|
|
|
|
|
// since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
|
|
|
|
|
Offset = -MV.getConstant();
|
|
|
|
|
const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
|
|
|
|
|
|
|
|
|
|
// Access the final symbol via sym$non_lazy_ptr and generate the appropriated
|
|
|
|
|
// non_lazy_ptr stubs.
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
StringRef Suffix = "$non_lazy_ptr";
|
2015-07-16 14:04:17 +08:00
|
|
|
Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
|
2015-03-06 21:49:05 +08:00
|
|
|
Name += Sym->getName();
|
|
|
|
|
Name += Suffix;
|
2015-05-19 02:43:14 +08:00
|
|
|
MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
|
2019-08-23 00:59:00 +08:00
|
|
|
|
|
|
|
|
if (!StubSym.getPointer())
|
2018-12-14 01:23:30 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
|
2019-08-23 00:59:00 +08:00
|
|
|
!GV->hasLocalLinkage());
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
|
const MCExpr *BSymExpr =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
const MCExpr *LHS =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
|
if (!Offset)
|
2015-05-30 09:25:56 +08:00
|
|
|
return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
|
const MCExpr *RHS =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
|
|
|
|
|
return MCBinaryExpr::createSub(LHS, RHS, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
}
|
|
|
|
|
|
2015-11-04 07:40:03 +08:00
|
|
|
static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
|
|
|
|
|
const MCSection &Section) {
|
|
|
|
|
if (!AsmInfo.isSectionAtomizableBySymbols(Section))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
// If it is not dead stripped, it is safe to use private labels.
|
|
|
|
|
const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
|
|
|
|
|
if (SMO.hasAttribute(MachO::S_ATTR_NO_DEAD_STRIP))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TargetLoweringObjectFileMachO::getNameWithPrefix(
|
2016-09-16 15:33:15 +08:00
|
|
|
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
|
2015-11-04 07:40:03 +08:00
|
|
|
const TargetMachine &TM) const {
|
2016-10-25 03:23:39 +08:00
|
|
|
bool CannotUsePrivateLabel = true;
|
|
|
|
|
if (auto *GO = GV->getBaseObject()) {
|
|
|
|
|
SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM);
|
|
|
|
|
const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
|
|
|
|
|
CannotUsePrivateLabel =
|
|
|
|
|
!canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
|
|
|
|
|
}
|
2016-09-16 15:33:15 +08:00
|
|
|
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
|
2015-11-04 07:40:03 +08:00
|
|
|
}
|
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// COFF
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2010-05-08 01:17:41 +08:00
|
|
|
static unsigned
|
2016-06-27 22:42:20 +08:00
|
|
|
getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
|
2010-05-08 01:17:41 +08:00
|
|
|
unsigned Flags = 0;
|
2016-06-27 22:42:20 +08:00
|
|
|
bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
|
2010-05-08 01:17:41 +08:00
|
|
|
|
2010-07-06 23:24:56 +08:00
|
|
|
if (K.isMetadata())
|
2010-05-08 05:49:09 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_DISCARDABLE;
|
2010-05-08 01:17:41 +08:00
|
|
|
else if (K.isText())
|
|
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_EXECUTE |
|
2010-10-28 02:52:29 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
2016-06-27 22:42:20 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_CODE |
|
|
|
|
|
(isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
|
2014-09-20 15:31:46 +08:00
|
|
|
else if (K.isBSS())
|
2010-05-08 05:49:09 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2012-02-12 01:26:53 +08:00
|
|
|
else if (K.isThreadLocal())
|
|
|
|
|
Flags |=
|
|
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2014-09-20 15:31:46 +08:00
|
|
|
else if (K.isReadOnly() || K.isReadOnlyWithRel())
|
2010-05-08 01:17:41 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ;
|
2010-05-08 01:17:41 +08:00
|
|
|
else if (K.isWriteable())
|
|
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2010-05-08 01:17:41 +08:00
|
|
|
|
|
|
|
|
return Flags;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2014-07-07 22:47:51 +08:00
|
|
|
static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
|
2014-06-28 02:19:56 +08:00
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
|
assert(C && "expected GV to have a Comdat!");
|
|
|
|
|
|
|
|
|
|
StringRef ComdatGVName = C->getName();
|
|
|
|
|
const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
|
|
|
|
|
if (!ComdatGV)
|
|
|
|
|
report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
|
|
|
|
|
"' does not exist.");
|
|
|
|
|
|
|
|
|
|
if (ComdatGV->getComdat() != C)
|
|
|
|
|
report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
|
2014-09-19 09:14:56 +08:00
|
|
|
"' is not a key for its COMDAT.");
|
2014-06-28 02:19:56 +08:00
|
|
|
|
|
|
|
|
return ComdatGV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int getSelectionForCOFF(const GlobalValue *GV) {
|
|
|
|
|
if (const Comdat *C = GV->getComdat()) {
|
|
|
|
|
const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
|
|
|
|
|
if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
|
|
|
|
|
ComdatKey = GA->getBaseObject();
|
|
|
|
|
if (ComdatKey == GV) {
|
|
|
|
|
switch (C->getSelectionKind()) {
|
|
|
|
|
case Comdat::Any:
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_ANY;
|
|
|
|
|
case Comdat::ExactMatch:
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
|
|
|
|
|
case Comdat::Largest:
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_LARGEST;
|
|
|
|
|
case Comdat::NoDuplicates:
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
|
|
|
|
|
case Comdat::SameSize:
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2012-11-14 06:04:09 +08:00
|
|
|
int Selection = 0;
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2016-10-25 03:23:39 +08:00
|
|
|
StringRef Name = GO->getSection();
|
2013-11-27 09:18:37 +08:00
|
|
|
StringRef COMDATSymName = "";
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasComdat()) {
|
|
|
|
|
Selection = getSelectionForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
const GlobalValue *ComdatGV;
|
|
|
|
|
if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = getComdatGVForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
else
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = GO;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
|
|
|
|
if (!ComdatGV->hasPrivateLinkage()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(ComdatGV);
|
2014-06-28 02:19:56 +08:00
|
|
|
COMDATSymName = Sym->getName();
|
|
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
|
|
|
|
} else {
|
|
|
|
|
Selection = 0;
|
|
|
|
|
}
|
2012-11-14 06:04:09 +08:00
|
|
|
}
|
2016-05-03 07:22:18 +08:00
|
|
|
|
|
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
|
2013-07-06 20:13:10 +08:00
|
|
|
Selection);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isText())
|
2013-11-27 09:18:37 +08:00
|
|
|
return ".text";
|
2014-04-09 06:33:40 +08:00
|
|
|
if (Kind.isBSS())
|
2013-11-27 09:18:37 +08:00
|
|
|
return ".bss";
|
|
|
|
|
if (Kind.isThreadLocal())
|
2013-11-27 23:52:11 +08:00
|
|
|
return ".tls$";
|
2014-09-23 04:39:23 +08:00
|
|
|
if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
|
|
|
|
|
return ".rdata";
|
|
|
|
|
return ".data";
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2014-03-24 01:47:39 +08:00
|
|
|
// If we have -ffunction-sections then we should emit the global value to a
|
|
|
|
|
// uniqued section specifically for it.
|
2014-03-25 14:14:26 +08:00
|
|
|
bool EmitUniquedSection;
|
|
|
|
|
if (Kind.isText())
|
|
|
|
|
EmitUniquedSection = TM.getFunctionSections();
|
|
|
|
|
else
|
|
|
|
|
EmitUniquedSection = TM.getDataSections();
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
SmallString<256> Name = getCOFFSectionNameForUniqueGlobal(Kind);
|
|
|
|
|
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2010-05-08 05:49:09 +08:00
|
|
|
|
2010-07-02 04:07:24 +08:00
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
2016-10-25 03:23:39 +08:00
|
|
|
int Selection = getSelectionForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
if (!Selection)
|
|
|
|
|
Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
|
|
|
|
|
const GlobalValue *ComdatGV;
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasComdat())
|
|
|
|
|
ComdatGV = getComdatGVForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
else
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = GO;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
|
|
|
|
if (EmitUniquedSection)
|
|
|
|
|
UniqueID = NextUniqueID++;
|
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
if (!ComdatGV->hasPrivateLinkage()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(ComdatGV);
|
2014-06-28 02:19:56 +08:00
|
|
|
StringRef COMDATSymName = Sym->getName();
|
2018-06-22 07:06:33 +08:00
|
|
|
|
[CodeGen] Add text section prefix for COFF object file
Text section prefix is created in CodeGenPrepare, it's file format independent implementation, text section name is written into object file in TargetLoweringObjectFile, it's file format dependent implementation, port code of adding text section prefix to text section name from ELF to COFF.
Different with ELF that use '.' as concatenation character, COFF use '$' as concatenation character. That is, concatenation character is variable, so split concatenation character from text section prefix.
Text section prefix is existing feature of ELF, it can help to reduce icache and itlb misses, it's also make possible aggregate other compilers e.g. v8 created same prefix sections. Furthermore, the recent feature Machine Function Splitter (basic block level text prefix section) is based on text section prefix.
Reviewed By: pengfei, rnk
Differential Revision: https://reviews.llvm.org/D92073
2020-12-08 17:57:03 +08:00
|
|
|
if (const auto *F = dyn_cast<Function>(GO))
|
|
|
|
|
if (Optional<StringRef> Prefix = F->getSectionPrefix())
|
|
|
|
|
raw_svector_ostream(Name) << '$' << *Prefix;
|
|
|
|
|
|
2018-11-22 06:01:10 +08:00
|
|
|
// Append "$symbol" to the section name *before* IR-level mangling is
|
|
|
|
|
// applied when targetting mingw. This is what GCC does, and the ld.bfd
|
2018-06-22 07:06:33 +08:00
|
|
|
// COFF linker will not properly handle comdats otherwise.
|
|
|
|
|
if (getTargetTriple().isWindowsGNUEnvironment())
|
2018-11-22 06:01:10 +08:00
|
|
|
raw_svector_ostream(Name) << '$' << ComdatGV->getName();
|
2018-06-22 07:06:33 +08:00
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind,
|
2016-05-03 07:22:18 +08:00
|
|
|
COMDATSymName, Selection, UniqueID);
|
2015-03-18 07:54:51 +08:00
|
|
|
} else {
|
|
|
|
|
SmallString<256> TmpData;
|
2016-10-25 03:23:39 +08:00
|
|
|
getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
|
2015-03-18 07:54:51 +08:00
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
|
2016-05-03 07:22:18 +08:00
|
|
|
Selection, UniqueID);
|
2014-06-28 02:19:56 +08:00
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (Kind.isText())
|
2013-08-13 09:23:53 +08:00
|
|
|
return TextSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2012-02-12 01:26:53 +08:00
|
|
|
if (Kind.isThreadLocal())
|
2013-08-13 09:23:53 +08:00
|
|
|
return TLSDataSection;
|
2012-02-12 01:26:53 +08:00
|
|
|
|
2014-09-23 04:39:23 +08:00
|
|
|
if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
|
2013-08-08 09:50:52 +08:00
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
2014-04-09 06:33:40 +08:00
|
|
|
// Note: we claim that common symbols are put in BSSSection, but they are
|
|
|
|
|
// really emitted with the magic .comm directive, which creates a symbol table
|
|
|
|
|
// entry but not a section.
|
|
|
|
|
if (Kind.isBSS() || Kind.isCommon())
|
2013-08-13 09:23:53 +08:00
|
|
|
return BSSSection;
|
|
|
|
|
|
|
|
|
|
return DataSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
2015-03-18 07:54:51 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::getNameWithPrefix(
|
2016-09-16 15:33:15 +08:00
|
|
|
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
|
2015-11-04 07:40:03 +08:00
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
bool CannotUsePrivateLabel = false;
|
2015-03-18 07:54:51 +08:00
|
|
|
if (GV->hasPrivateLinkage() &&
|
|
|
|
|
((isa<Function>(GV) && TM.getFunctionSections()) ||
|
|
|
|
|
(isa<GlobalVariable>(GV) && TM.getDataSections())))
|
|
|
|
|
CannotUsePrivateLabel = true;
|
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
|
2015-03-18 07:54:51 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
|
2016-09-16 15:33:15 +08:00
|
|
|
const Function &F, const TargetMachine &TM) const {
|
2015-03-12 03:58:37 +08:00
|
|
|
// If the function can be removed, produce a unique section so that
|
|
|
|
|
// the table doesn't prevent the removal.
|
|
|
|
|
const Comdat *C = F.getComdat();
|
|
|
|
|
bool EmitUniqueSection = TM.getFunctionSections() || C;
|
|
|
|
|
if (!EmitUniqueSection)
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
|
|
// FIXME: we should produce a symbol for F instead.
|
|
|
|
|
if (F.hasPrivateLinkage())
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(&F);
|
2015-03-12 03:58:37 +08:00
|
|
|
StringRef COMDATSymName = Sym->getName();
|
|
|
|
|
|
|
|
|
|
SectionKind Kind = SectionKind::getReadOnly();
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
StringRef SecName = getCOFFSectionNameForUniqueGlobal(Kind);
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2015-03-12 03:58:37 +08:00
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = NextUniqueID++;
|
2015-03-12 03:58:37 +08:00
|
|
|
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
return getContext().getCOFFSection(
|
|
|
|
|
SecName, Characteristics, Kind, COMDATSymName,
|
|
|
|
|
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
|
2015-03-12 03:58:37 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
|
Module &M) const {
|
2020-09-19 04:43:13 +08:00
|
|
|
emitLinkerDirectives(Streamer, M);
|
2017-06-06 05:26:39 +08:00
|
|
|
|
|
|
|
|
unsigned Version = 0;
|
|
|
|
|
unsigned Flags = 0;
|
|
|
|
|
StringRef Section;
|
|
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
GetObjCImageInfo(M, Version, Flags, Section);
|
2020-09-30 02:58:37 +08:00
|
|
|
if (!Section.empty()) {
|
|
|
|
|
auto &C = getContext();
|
|
|
|
|
auto *S = C.getCOFFSection(Section,
|
|
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
|
Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
|
|
|
|
|
Streamer.emitInt32(Version);
|
|
|
|
|
Streamer.emitInt32(Flags);
|
|
|
|
|
Streamer.AddBlankLine();
|
|
|
|
|
}
|
2017-06-06 05:26:39 +08:00
|
|
|
|
2020-12-12 09:21:23 +08:00
|
|
|
emitCGProfileMetadata(Streamer, M);
|
2013-04-26 03:34:41 +08:00
|
|
|
}
|
2014-05-17 04:39:27 +08:00
|
|
|
|
2020-09-19 04:43:13 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::emitLinkerDirectives(
|
|
|
|
|
MCStreamer &Streamer, Module &M) const {
|
|
|
|
|
if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
|
|
|
|
// Emit the linker options to the linker .drectve section. According to the
|
|
|
|
|
// spec, this section is a space-separated string containing flags for
|
|
|
|
|
// linker.
|
|
|
|
|
MCSection *Sec = getDrectveSection();
|
|
|
|
|
Streamer.SwitchSection(Sec);
|
|
|
|
|
for (const auto *Option : LinkerOptions->operands()) {
|
|
|
|
|
for (const auto &Piece : cast<MDNode>(Option)->operands()) {
|
|
|
|
|
// Lead with a space for consistency with our dllexport implementation.
|
|
|
|
|
std::string Directive(" ");
|
|
|
|
|
Directive.append(std::string(cast<MDString>(Piece)->getString()));
|
|
|
|
|
Streamer.emitBytes(Directive);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Emit /EXPORT: flags for each exported global as necessary.
|
|
|
|
|
std::string Flags;
|
|
|
|
|
for (const GlobalValue &GV : M.global_values()) {
|
|
|
|
|
raw_string_ostream OS(Flags);
|
|
|
|
|
emitLinkerFlagsForGlobalCOFF(OS, &GV, getTargetTriple(), getMangler());
|
|
|
|
|
OS.flush();
|
|
|
|
|
if (!Flags.empty()) {
|
|
|
|
|
Streamer.SwitchSection(getDrectveSection());
|
|
|
|
|
Streamer.emitBytes(Flags);
|
|
|
|
|
}
|
|
|
|
|
Flags.clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Emit /INCLUDE: flags for each used global as necessary.
|
|
|
|
|
if (const auto *LU = M.getNamedGlobal("llvm.used")) {
|
|
|
|
|
assert(LU->hasInitializer() && "expected llvm.used to have an initializer");
|
|
|
|
|
assert(isa<ArrayType>(LU->getValueType()) &&
|
|
|
|
|
"expected llvm.used to be an array type");
|
|
|
|
|
if (const auto *A = cast<ConstantArray>(LU->getInitializer())) {
|
|
|
|
|
for (const Value *Op : A->operands()) {
|
|
|
|
|
const auto *GV = cast<GlobalValue>(Op->stripPointerCasts());
|
|
|
|
|
// Global symbols with internal or private linkage are not visible to
|
|
|
|
|
// the linker, and thus would cause an error when the linker tried to
|
|
|
|
|
// preserve the symbol due to the `/include:` directive.
|
|
|
|
|
if (GV->hasLocalLinkage())
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
raw_string_ostream OS(Flags);
|
|
|
|
|
emitLinkerFlagsForUsedCOFF(OS, GV, getTargetTriple(), getMangler());
|
|
|
|
|
OS.flush();
|
|
|
|
|
|
|
|
|
|
if (!Flags.empty()) {
|
|
|
|
|
Streamer.SwitchSection(getDrectveSection());
|
|
|
|
|
Streamer.emitBytes(Flags);
|
|
|
|
|
}
|
|
|
|
|
Flags.clear();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
|
|
|
|
|
const TargetMachine &TM) {
|
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TM);
|
2020-09-30 02:58:37 +08:00
|
|
|
this->TM = &TM;
|
2016-08-29 20:33:42 +08:00
|
|
|
const Triple &T = TM.getTargetTriple();
|
2019-07-09 05:05:20 +08:00
|
|
|
if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
|
2016-08-29 20:33:42 +08:00
|
|
|
StaticCtorSection =
|
|
|
|
|
Ctx.getCOFFSection(".CRT$XCU", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
|
StaticDtorSection =
|
|
|
|
|
Ctx.getCOFFSection(".CRT$XTX", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
|
} else {
|
|
|
|
|
StaticCtorSection = Ctx.getCOFFSection(
|
|
|
|
|
".ctors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
StaticDtorSection = Ctx.getCOFFSection(
|
|
|
|
|
".dtors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-28 16:07:18 +08:00
|
|
|
static MCSectionCOFF *getCOFFStaticStructorSection(MCContext &Ctx,
|
|
|
|
|
const Triple &T, bool IsCtor,
|
|
|
|
|
unsigned Priority,
|
|
|
|
|
const MCSymbol *KeySym,
|
|
|
|
|
MCSectionCOFF *Default) {
|
2019-07-09 05:05:20 +08:00
|
|
|
if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
|
2018-09-08 07:07:55 +08:00
|
|
|
// If the priority is the default, use .CRT$XCU, possibly associative.
|
|
|
|
|
if (Priority == 65535)
|
|
|
|
|
return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
|
|
|
|
|
|
|
|
|
|
// Otherwise, we need to compute a new section name. Low priorities should
|
|
|
|
|
// run earlier. The linker will sort sections ASCII-betically, and we need a
|
|
|
|
|
// string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
|
|
|
|
|
// make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
|
|
|
|
|
// low priorities need to sort before 'L', since the CRT uses that
|
|
|
|
|
// internally, so we use ".CRT$XCA00001" for them.
|
|
|
|
|
SmallString<24> Name;
|
|
|
|
|
raw_svector_ostream OS(Name);
|
2019-08-20 05:07:03 +08:00
|
|
|
OS << ".CRT$X" << (IsCtor ? "C" : "T") <<
|
|
|
|
|
(Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
|
2018-09-08 07:07:55 +08:00
|
|
|
MCSectionCOFF *Sec = Ctx.getCOFFSection(
|
|
|
|
|
Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
|
return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
|
|
|
|
|
}
|
2017-11-28 16:07:18 +08:00
|
|
|
|
|
|
|
|
std::string Name = IsCtor ? ".ctors" : ".dtors";
|
|
|
|
|
if (Priority != 65535)
|
|
|
|
|
raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
|
|
|
|
|
|
|
|
|
|
return Ctx.getAssociativeCOFFSection(
|
|
|
|
|
Ctx.getCOFFSection(Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
|
SectionKind::getData()),
|
|
|
|
|
KeySym, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2017-11-28 16:07:18 +08:00
|
|
|
return getCOFFStaticStructorSection(getContext(), getTargetTriple(), true,
|
|
|
|
|
Priority, KeySym,
|
|
|
|
|
cast<MCSectionCOFF>(StaticCtorSection));
|
2014-05-17 04:39:27 +08:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2017-11-28 16:07:18 +08:00
|
|
|
return getCOFFStaticStructorSection(getContext(), getTargetTriple(), false,
|
|
|
|
|
Priority, KeySym,
|
|
|
|
|
cast<MCSectionCOFF>(StaticDtorSection));
|
2014-05-17 04:39:27 +08:00
|
|
|
}
|
2015-06-30 06:04:09 +08:00
|
|
|
|
2018-06-13 02:56:05 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
|
|
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
const Triple &T = TM.getTargetTriple();
|
2019-07-09 05:05:20 +08:00
|
|
|
if (T.isOSCygMing())
|
2018-06-13 02:56:05 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
// Our symbols should exist in address space zero, cowardly no-op if
|
|
|
|
|
// otherwise.
|
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0)
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
// Both ptrtoint instructions must wrap global objects:
|
|
|
|
|
// - Only global variables are eligible for image relative relocations.
|
|
|
|
|
// - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
|
|
|
|
|
// We expect __ImageBase to be a global variable without a section, externally
|
|
|
|
|
// defined.
|
|
|
|
|
//
|
|
|
|
|
// It should look something like this: @__ImageBase = external constant i8
|
|
|
|
|
if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
|
|
|
|
|
LHS->isThreadLocal() || RHS->isThreadLocal() ||
|
|
|
|
|
RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
|
|
|
|
|
cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
return MCSymbolRefExpr::create(TM.getSymbol(LHS),
|
|
|
|
|
MCSymbolRefExpr::VK_COFF_IMGREL32,
|
|
|
|
|
getContext());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static std::string APIntToHexString(const APInt &AI) {
|
|
|
|
|
unsigned Width = (AI.getBitWidth() / 8) * 2;
|
2019-08-22 09:48:34 +08:00
|
|
|
std::string HexString = AI.toString(16, /*Signed=*/false);
|
2020-05-25 11:55:08 +08:00
|
|
|
llvm::transform(HexString, HexString.begin(), tolower);
|
2018-06-13 02:56:05 +08:00
|
|
|
unsigned Size = HexString.size();
|
|
|
|
|
assert(Width >= Size && "hex string is too large!");
|
|
|
|
|
HexString.insert(HexString.begin(), Width - Size, '0');
|
|
|
|
|
|
|
|
|
|
return HexString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static std::string scalarConstantToHexString(const Constant *C) {
|
|
|
|
|
Type *Ty = C->getType();
|
|
|
|
|
if (isa<UndefValue>(C)) {
|
|
|
|
|
return APIntToHexString(APInt::getNullValue(Ty->getPrimitiveSizeInBits()));
|
|
|
|
|
} else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
|
|
|
|
|
return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
|
|
|
|
|
} else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
|
|
|
|
|
return APIntToHexString(CI->getValue());
|
|
|
|
|
} else {
|
|
|
|
|
unsigned NumElements;
|
2020-04-11 05:23:20 +08:00
|
|
|
if (auto *VTy = dyn_cast<VectorType>(Ty))
|
2020-07-10 02:51:03 +08:00
|
|
|
NumElements = cast<FixedVectorType>(VTy)->getNumElements();
|
2018-06-13 02:56:05 +08:00
|
|
|
else
|
|
|
|
|
NumElements = Ty->getArrayNumElements();
|
|
|
|
|
std::string HexString;
|
|
|
|
|
for (int I = NumElements - 1, E = -1; I != E; --I)
|
|
|
|
|
HexString += scalarConstantToHexString(C->getAggregateElement(I));
|
|
|
|
|
return HexString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
|
|
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
2020-05-22 06:23:00 +08:00
|
|
|
Align &Alignment) const {
|
2018-07-26 18:48:20 +08:00
|
|
|
if (Kind.isMergeableConst() && C &&
|
|
|
|
|
getContext().getAsmInfo()->hasCOFFComdatConstants()) {
|
|
|
|
|
// This creates comdat sections with the given symbol name, but unless
|
|
|
|
|
// AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
|
|
|
|
|
// will be created with a null storage class, which makes GNU binutils
|
|
|
|
|
// error out.
|
2018-06-13 02:56:05 +08:00
|
|
|
const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
|
COFF::IMAGE_SCN_LNK_COMDAT;
|
|
|
|
|
std::string COMDATSymName;
|
|
|
|
|
if (Kind.isMergeableConst4()) {
|
2020-05-22 06:23:00 +08:00
|
|
|
if (Alignment <= 4) {
|
2018-06-13 02:56:05 +08:00
|
|
|
COMDATSymName = "__real@" + scalarConstantToHexString(C);
|
2020-05-22 06:23:00 +08:00
|
|
|
Alignment = Align(4);
|
2018-06-13 02:56:05 +08:00
|
|
|
}
|
|
|
|
|
} else if (Kind.isMergeableConst8()) {
|
2020-05-22 06:23:00 +08:00
|
|
|
if (Alignment <= 8) {
|
2018-06-13 02:56:05 +08:00
|
|
|
COMDATSymName = "__real@" + scalarConstantToHexString(C);
|
2020-05-22 06:23:00 +08:00
|
|
|
Alignment = Align(8);
|
2018-06-13 02:56:05 +08:00
|
|
|
}
|
|
|
|
|
} else if (Kind.isMergeableConst16()) {
|
|
|
|
|
// FIXME: These may not be appropriate for non-x86 architectures.
|
2020-05-22 06:23:00 +08:00
|
|
|
if (Alignment <= 16) {
|
2018-06-13 02:56:05 +08:00
|
|
|
COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
|
2020-05-22 06:23:00 +08:00
|
|
|
Alignment = Align(16);
|
2018-06-13 02:56:05 +08:00
|
|
|
}
|
|
|
|
|
} else if (Kind.isMergeableConst32()) {
|
2020-05-22 06:23:00 +08:00
|
|
|
if (Alignment <= 32) {
|
2018-06-13 02:56:05 +08:00
|
|
|
COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
|
2020-05-22 06:23:00 +08:00
|
|
|
Alignment = Align(32);
|
2018-06-13 02:56:05 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!COMDATSymName.empty())
|
|
|
|
|
return getContext().getCOFFSection(".rdata", Characteristics, Kind,
|
|
|
|
|
COMDATSymName,
|
|
|
|
|
COFF::IMAGE_COMDAT_SELECT_ANY);
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-22 06:23:00 +08:00
|
|
|
return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C,
|
|
|
|
|
Alignment);
|
2018-06-13 02:56:05 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// Wasm
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
static const Comdat *getWasmComdat(const GlobalValue *GV) {
|
2017-02-25 07:18:00 +08:00
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
|
if (!C)
|
2018-01-10 07:43:14 +08:00
|
|
|
return nullptr;
|
2017-02-25 07:18:00 +08:00
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
if (C->getSelectionKind() != Comdat::Any)
|
|
|
|
|
report_fatal_error("WebAssembly COMDATs only support "
|
|
|
|
|
"SelectionKind::Any, '" + C->getName() + "' cannot be "
|
|
|
|
|
"lowered.");
|
|
|
|
|
|
|
|
|
|
return C;
|
2017-02-25 07:18:00 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
|
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2018-06-15 02:48:19 +08:00
|
|
|
// We don't support explict section names for functions in the wasm object
|
|
|
|
|
// format. Each function has to be in its own unique section.
|
|
|
|
|
if (isa<Function>(GO)) {
|
|
|
|
|
return SelectSectionForGlobal(GO, Kind, TM);
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-16 04:54:59 +08:00
|
|
|
StringRef Name = GO->getSection();
|
2018-01-10 07:43:14 +08:00
|
|
|
|
2020-03-31 08:37:01 +08:00
|
|
|
// Certain data sections we treat as named custom sections rather than
|
|
|
|
|
// segments within the data section.
|
|
|
|
|
// This could be avoided if all data segements (the wasm sense) were
|
2020-04-16 05:38:43 +08:00
|
|
|
// represented as their own sections (in the llvm sense).
|
2020-03-31 08:37:01 +08:00
|
|
|
// TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
|
|
|
|
|
if (Name == ".llvmcmd" || Name == ".llvmbc")
|
|
|
|
|
Kind = SectionKind::getMetadata();
|
|
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
StringRef Group = "";
|
|
|
|
|
if (const Comdat *C = getWasmComdat(GO)) {
|
|
|
|
|
Group = C->getName();
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-20 06:56:19 +08:00
|
|
|
MCSectionWasm* Section =
|
|
|
|
|
getContext().getWasmSection(Name, Kind, Group,
|
|
|
|
|
MCContext::GenericSectionID);
|
|
|
|
|
|
|
|
|
|
return Section;
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|
|
|
|
|
|
2017-09-13 02:31:24 +08:00
|
|
|
static MCSectionWasm *selectWasmSectionForGlobal(
|
|
|
|
|
MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
|
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
|
2017-02-25 07:18:00 +08:00
|
|
|
StringRef Group = "";
|
2018-01-10 07:43:14 +08:00
|
|
|
if (const Comdat *C = getWasmComdat(GO)) {
|
|
|
|
|
Group = C->getName();
|
|
|
|
|
}
|
2017-02-25 07:18:00 +08:00
|
|
|
|
|
|
|
|
bool UniqueSectionNames = TM.getUniqueSectionNames();
|
|
|
|
|
SmallString<128> Name = getSectionPrefixForGlobal(Kind);
|
|
|
|
|
|
|
|
|
|
if (const auto *F = dyn_cast<Function>(GO)) {
|
|
|
|
|
const auto &OptionalPrefix = F->getSectionPrefix();
|
|
|
|
|
if (OptionalPrefix)
|
[CodeGen] Add text section prefix for COFF object file
Text section prefix is created in CodeGenPrepare, it's file format independent implementation, text section name is written into object file in TargetLoweringObjectFile, it's file format dependent implementation, port code of adding text section prefix to text section name from ELF to COFF.
Different with ELF that use '.' as concatenation character, COFF use '$' as concatenation character. That is, concatenation character is variable, so split concatenation character from text section prefix.
Text section prefix is existing feature of ELF, it can help to reduce icache and itlb misses, it's also make possible aggregate other compilers e.g. v8 created same prefix sections. Furthermore, the recent feature Machine Function Splitter (basic block level text prefix section) is based on text section prefix.
Reviewed By: pengfei, rnk
Differential Revision: https://reviews.llvm.org/D92073
2020-12-08 17:57:03 +08:00
|
|
|
raw_svector_ostream(Name) << '.' << *OptionalPrefix;
|
2017-02-25 07:18:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (EmitUniqueSection && UniqueSectionNames) {
|
|
|
|
|
Name.push_back('.');
|
|
|
|
|
TM.getNameWithPrefix(Name, GO, Mang, true);
|
|
|
|
|
}
|
|
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
|
|
|
|
if (EmitUniqueSection && !UniqueSectionNames) {
|
|
|
|
|
UniqueID = *NextUniqueID;
|
|
|
|
|
(*NextUniqueID)++;
|
|
|
|
|
}
|
2019-02-20 06:56:19 +08:00
|
|
|
|
[WebAssembly] Remove uses of ThreadModel
Summary:
In the clang UI, replaces -mthread-model posix with -matomics as the
source of truth on threading. In the backend, replaces
-thread-model=posix with the atomics target feature, which is now
collected on the WebAssemblyTargetMachine along with all other used
features. These collected features will also be used to emit the
target features section in the future.
The default configuration for the backend is thread-model=posix and no
atomics, which was previously an invalid configuration. This change
makes the default valid because the thread model is ignored.
A side effect of this change is that objects are never emitted with
passive segments. It will instead be up to the linker to decide
whether sections should be active or passive based on whether atomics
are used in the final link.
Reviewers: aheejin, sbc100, dschuff
Subscribers: mehdi_amini, jgravelle-google, hiraditya, sunfish, steven_wu, dexonsmith, rupprecht, jfb, jdoerfert, cfe-commits, llvm-commits
Tags: #clang, #llvm
Differential Revision: https://reviews.llvm.org/D58742
llvm-svn: 355112
2019-03-01 02:39:08 +08:00
|
|
|
return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
|
2017-02-25 07:18:00 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
|
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2017-02-25 07:18:00 +08:00
|
|
|
|
|
|
|
|
if (Kind.isCommon())
|
|
|
|
|
report_fatal_error("mergable sections not supported yet on wasm");
|
|
|
|
|
|
|
|
|
|
// If we have -ffunction-section or -fdata-section then we should emit the
|
|
|
|
|
// global value to a uniqued section specifically for it.
|
|
|
|
|
bool EmitUniqueSection = false;
|
2017-02-22 09:23:18 +08:00
|
|
|
if (Kind.isText())
|
2017-02-25 07:18:00 +08:00
|
|
|
EmitUniqueSection = TM.getFunctionSections();
|
|
|
|
|
else
|
|
|
|
|
EmitUniqueSection = TM.getDataSections();
|
|
|
|
|
EmitUniqueSection |= GO->hasComdat();
|
|
|
|
|
|
|
|
|
|
return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
|
2017-09-13 02:31:24 +08:00
|
|
|
EmitUniqueSection, &NextUniqueID);
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool TargetLoweringObjectFileWasm::shouldPutJumpTableInFunctionSection(
|
|
|
|
|
bool UsesLabelDifference, const Function &F) const {
|
|
|
|
|
// We can always create relative relocations, so use another section
|
|
|
|
|
// that can be marked non-executable.
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const MCExpr *TargetLoweringObjectFileWasm::lowerRelativeReference(
|
|
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
// We may only use a PLT-relative relocation to refer to unnamed_addr
|
|
|
|
|
// functions.
|
|
|
|
|
if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
// Basic sanity checks.
|
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
|
|
|
|
|
RHS->isThreadLocal())
|
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
|
|
return MCBinaryExpr::createSub(
|
|
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(LHS), MCSymbolRefExpr::VK_None,
|
|
|
|
|
getContext()),
|
|
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-03 19:20:28 +08:00
|
|
|
void TargetLoweringObjectFileWasm::InitializeWasm() {
|
|
|
|
|
StaticCtorSection =
|
2017-10-21 05:28:38 +08:00
|
|
|
getContext().getWasmSection(".init_array", SectionKind::getData());
|
Reland "[WebAssembly] LSDA info generation"
Summary:
This adds support for LSDA (exception table) generation for wasm EH.
Wasm EH mostly follows the structure of Itanium-style exception tables,
with one exception: a call site table entry in wasm EH corresponds to
not a call site but a landing pad.
In wasm EH, the VM is responsible for stack unwinding. After an
exception occurs and the stack is unwound, the control flow is
transferred to wasm 'catch' instruction by the VM, after which the
personality function is called from the compiler-generated code. (Refer
to WasmEHPrepare pass for more information on this part.)
This patch:
- Changes wasm.landingpad.index intrinsic to take a token argument, to
make this 1:1 match with a catchpad instruction
- Stores landingpad index info and catch type info MachineFunction in
before instruction selection
- Lowers wasm.lsda intrinsic to an MCSymbol pointing to the start of an
exception table
- Adds WasmException class with overridden methods for table generation
- Adds support for LSDA section in Wasm object writer
Reviewers: dschuff, sbc100, rnk
Subscribers: mgorny, jgravelle-google, sunfish, llvm-commits
Differential Revision: https://reviews.llvm.org/D52748
llvm-svn: 345345
2018-10-26 07:55:10 +08:00
|
|
|
|
|
|
|
|
// We don't use PersonalityEncoding and LSDAEncoding because we don't emit
|
|
|
|
|
// .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
|
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
2017-12-15 08:17:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection(
|
|
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
|
return Priority == UINT16_MAX ?
|
|
|
|
|
StaticCtorSection :
|
|
|
|
|
getContext().getWasmSection(".init_array." + utostr(Priority),
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
|
|
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
|
llvm_unreachable("@llvm.global_dtors should have been lowered already");
|
|
|
|
|
return nullptr;
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|
2019-07-23 03:15:29 +08:00
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// XCOFF
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2020-12-16 22:34:59 +08:00
|
|
|
bool TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(
|
|
|
|
|
const MachineFunction *MF) {
|
|
|
|
|
if (!MF->getLandingPads().empty())
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
const Function &F = MF->getFunction();
|
|
|
|
|
if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const Function *Per =
|
|
|
|
|
dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
|
|
|
|
|
if (isNoOpWithoutInvoke(classifyEHPersonality(Per)))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSymbol *
|
|
|
|
|
TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(const MachineFunction *MF) {
|
|
|
|
|
return MF->getMMI().getContext().getOrCreateSymbol(
|
|
|
|
|
"__ehinfo." + Twine(MF->getFunctionNumber()));
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-17 03:52:34 +08:00
|
|
|
MCSymbol *
|
|
|
|
|
TargetLoweringObjectFileXCOFF::getTargetSymbol(const GlobalValue *GV,
|
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
|
// We always use a qualname symbol for a GV that represents
|
|
|
|
|
// a declaration, a function descriptor, or a common symbol.
|
2020-10-02 07:35:31 +08:00
|
|
|
// If a GV represents a GlobalVariable and -fdata-sections is enabled, we
|
|
|
|
|
// also return a qualname so that a label symbol could be avoided.
|
2020-04-17 03:52:34 +08:00
|
|
|
// It is inherently ambiguous when the GO represents the address of a
|
|
|
|
|
// function, as the GO could either represent a function descriptor or a
|
|
|
|
|
// function entry point. We choose to always return a function descriptor
|
|
|
|
|
// here.
|
|
|
|
|
if (const GlobalObject *GO = dyn_cast<GlobalObject>(GV)) {
|
2020-05-29 23:41:10 +08:00
|
|
|
if (GO->isDeclarationForLinker())
|
2020-04-17 03:52:34 +08:00
|
|
|
return cast<MCSectionXCOFF>(getSectionForExternalReference(GO, TM))
|
|
|
|
|
->getQualNameSymbol();
|
|
|
|
|
|
|
|
|
|
SectionKind GOKind = getKindForGlobal(GO, TM);
|
|
|
|
|
if (GOKind.isText())
|
|
|
|
|
return cast<MCSectionXCOFF>(
|
|
|
|
|
getSectionForFunctionDescriptor(cast<Function>(GO), TM))
|
|
|
|
|
->getQualNameSymbol();
|
2020-11-09 23:12:46 +08:00
|
|
|
if ((TM.getDataSections() && !GO->hasSection()) || GOKind.isCommon() ||
|
|
|
|
|
GOKind.isBSSLocal())
|
2020-04-17 03:52:34 +08:00
|
|
|
return cast<MCSectionXCOFF>(SectionForGlobal(GO, GOKind, TM))
|
|
|
|
|
->getQualNameSymbol();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// For all other cases, fall back to getSymbol to return the unqualified name.
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-23 03:15:29 +08:00
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal(
|
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2020-11-09 23:12:46 +08:00
|
|
|
if (!GO->hasSection())
|
|
|
|
|
report_fatal_error("#pragma clang section is not yet supported");
|
|
|
|
|
|
|
|
|
|
StringRef SectionName = GO->getSection();
|
|
|
|
|
XCOFF::StorageMappingClass MappingClass;
|
|
|
|
|
if (Kind.isText())
|
|
|
|
|
MappingClass = XCOFF::XMC_PR;
|
|
|
|
|
else if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS())
|
|
|
|
|
MappingClass = XCOFF::XMC_RW;
|
|
|
|
|
else if (Kind.isReadOnly())
|
|
|
|
|
MappingClass = XCOFF::XMC_RO;
|
|
|
|
|
else
|
|
|
|
|
report_fatal_error("XCOFF other section types not yet implemented.");
|
|
|
|
|
|
|
|
|
|
return getContext().getXCOFFSection(SectionName, MappingClass, XCOFF::XTY_SD,
|
|
|
|
|
Kind, /* MultiSymbolsAllowed*/ true);
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
|
|
|
|
|
const GlobalObject *GO, const TargetMachine &TM) const {
|
2020-05-29 23:41:10 +08:00
|
|
|
assert(GO->isDeclarationForLinker() &&
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
"Tried to get ER section for a defined global.");
|
|
|
|
|
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
getNameWithPrefix(Name, GO, TM);
|
|
|
|
|
|
|
|
|
|
// Externals go into a csect of type ER.
|
|
|
|
|
return getContext().getXCOFFSection(
|
|
|
|
|
Name, isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA, XCOFF::XTY_ER,
|
2020-08-12 03:26:19 +08:00
|
|
|
SectionKind::getMetadata());
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
}
|
|
|
|
|
|
2019-07-23 03:15:29 +08:00
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
|
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
|
// Common symbols go into a csect with matching name which will get mapped
|
|
|
|
|
// into the .bss section.
|
Enable assembly output of local commons for AIX
Summary:
This patch enable assembly output of local commons for AIX using .lcomm
directives. Adds a EmitXCOFFLocalCommonSymbol to MCStreamer so we can emit the
AIX version of .lcomm assembly directives which include a csect name. Handle the
case of BSS locals in PPCAIXAsmPrinter by using EmitXCOFFLocalCommonSymbol. Adds
a test for generating .lcomm on AIX Targets.
Reviewers: cebowleratibm, hubert.reinterpretcast, Xiangling_L, jasonliu, sfertile
Reviewed By: sfertile
Subscribers: wuzish, nemanjai, hiraditya, kbarton, MaskRay, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D64825
llvm-svn: 368306
2019-08-08 23:40:35 +08:00
|
|
|
if (Kind.isBSSLocal() || Kind.isCommon()) {
|
2019-07-23 03:15:29 +08:00
|
|
|
SmallString<128> Name;
|
|
|
|
|
getNameWithPrefix(Name, GO, TM);
|
Enable assembly output of local commons for AIX
Summary:
This patch enable assembly output of local commons for AIX using .lcomm
directives. Adds a EmitXCOFFLocalCommonSymbol to MCStreamer so we can emit the
AIX version of .lcomm assembly directives which include a csect name. Handle the
case of BSS locals in PPCAIXAsmPrinter by using EmitXCOFFLocalCommonSymbol. Adds
a test for generating .lcomm on AIX Targets.
Reviewers: cebowleratibm, hubert.reinterpretcast, Xiangling_L, jasonliu, sfertile
Reviewed By: sfertile
Subscribers: wuzish, nemanjai, hiraditya, kbarton, MaskRay, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D64825
llvm-svn: 368306
2019-08-08 23:40:35 +08:00
|
|
|
return getContext().getXCOFFSection(
|
|
|
|
|
Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM,
|
2020-11-09 23:12:46 +08:00
|
|
|
Kind);
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings
This patch adds support for generating assembly code for one-byte mergeable strings.
Generating assembly code for multi-byte mergeable strings and the `XCOFF` object code for mergeable strings will be supported later.
Reviewers: hubert.reinterpretcast, jasonliu, daltenty, sfertile, DiggerLin, Xiangling_L
Reviewed by: daltenty
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70310
2019-11-21 00:01:45 +08:00
|
|
|
if (Kind.isMergeableCString()) {
|
2020-06-29 19:24:36 +08:00
|
|
|
Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
|
[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings
This patch adds support for generating assembly code for one-byte mergeable strings.
Generating assembly code for multi-byte mergeable strings and the `XCOFF` object code for mergeable strings will be supported later.
Reviewers: hubert.reinterpretcast, jasonliu, daltenty, sfertile, DiggerLin, Xiangling_L
Reviewed by: daltenty
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70310
2019-11-21 00:01:45 +08:00
|
|
|
cast<GlobalVariable>(GO));
|
|
|
|
|
|
|
|
|
|
unsigned EntrySize = getEntrySizeForKind(Kind);
|
|
|
|
|
std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
|
|
|
|
|
SmallString<128> Name;
|
2020-06-29 19:24:36 +08:00
|
|
|
Name = SizeSpec + utostr(Alignment.value());
|
[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings
This patch adds support for generating assembly code for one-byte mergeable strings.
Generating assembly code for multi-byte mergeable strings and the `XCOFF` object code for mergeable strings will be supported later.
Reviewers: hubert.reinterpretcast, jasonliu, daltenty, sfertile, DiggerLin, Xiangling_L
Reviewed by: daltenty
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70310
2019-11-21 00:01:45 +08:00
|
|
|
|
2020-10-02 07:35:31 +08:00
|
|
|
if (TM.getDataSections())
|
|
|
|
|
getNameWithPrefix(Name, GO, TM);
|
|
|
|
|
|
2020-11-09 23:12:46 +08:00
|
|
|
return getContext().getXCOFFSection(
|
|
|
|
|
Name, XCOFF::XMC_RO, XCOFF::XTY_SD, Kind,
|
|
|
|
|
/* MultiSymbolsAllowed*/ !TM.getDataSections());
|
[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings
This patch adds support for generating assembly code for one-byte mergeable strings.
Generating assembly code for multi-byte mergeable strings and the `XCOFF` object code for mergeable strings will be supported later.
Reviewers: hubert.reinterpretcast, jasonliu, daltenty, sfertile, DiggerLin, Xiangling_L
Reviewed by: daltenty
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70310
2019-11-21 00:01:45 +08:00
|
|
|
}
|
|
|
|
|
|
2020-07-29 23:06:04 +08:00
|
|
|
if (Kind.isText()) {
|
|
|
|
|
if (TM.getFunctionSections()) {
|
|
|
|
|
return cast<MCSymbolXCOFF>(getFunctionEntryPointSymbol(GO, TM))
|
|
|
|
|
->getRepresentedCsect();
|
|
|
|
|
}
|
2019-07-27 01:25:27 +08:00
|
|
|
return TextSection;
|
2020-07-29 23:06:04 +08:00
|
|
|
}
|
2019-07-27 01:25:27 +08:00
|
|
|
|
2020-10-02 07:35:31 +08:00
|
|
|
// TODO: We may put Kind.isReadOnlyWithRel() under option control, because
|
|
|
|
|
// user may want to have read-only data with relocations placed into a
|
|
|
|
|
// read-only section by the compiler.
|
|
|
|
|
// For BSS kind, zero initialized data must be emitted to the .data section
|
|
|
|
|
// because external linkage control sections that get mapped to the .bss
|
|
|
|
|
// section will be linked as tentative defintions, which is only appropriate
|
|
|
|
|
// for SectionKind::Common.
|
|
|
|
|
if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
|
|
|
|
|
if (TM.getDataSections()) {
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
getNameWithPrefix(Name, GO, TM);
|
|
|
|
|
return getContext().getXCOFFSection(Name, XCOFF::XMC_RW, XCOFF::XTY_SD,
|
|
|
|
|
SectionKind::getData());
|
|
|
|
|
}
|
2019-10-29 04:07:10 +08:00
|
|
|
return DataSection;
|
2020-10-02 07:35:31 +08:00
|
|
|
}
|
2019-10-29 04:07:10 +08:00
|
|
|
|
2020-10-02 07:35:31 +08:00
|
|
|
if (Kind.isReadOnly()) {
|
|
|
|
|
if (TM.getDataSections()) {
|
|
|
|
|
SmallString<128> Name;
|
|
|
|
|
getNameWithPrefix(Name, GO, TM);
|
|
|
|
|
return getContext().getXCOFFSection(Name, XCOFF::XMC_RO, XCOFF::XTY_SD,
|
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
|
}
|
2019-11-16 00:30:19 +08:00
|
|
|
return ReadOnlySection;
|
2020-10-02 07:35:31 +08:00
|
|
|
}
|
2019-11-16 00:30:19 +08:00
|
|
|
|
2019-07-23 03:15:29 +08:00
|
|
|
report_fatal_error("XCOFF other section types not yet implemented.");
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-14 22:52:32 +08:00
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getSectionForJumpTable(
|
|
|
|
|
const Function &F, const TargetMachine &TM) const {
|
|
|
|
|
assert (!F.getComdat() && "Comdat not supported on XCOFF.");
|
2020-08-06 21:19:59 +08:00
|
|
|
|
|
|
|
|
if (!TM.getFunctionSections())
|
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
|
|
// If the function can be removed, produce a unique section so that
|
|
|
|
|
// the table doesn't prevent the removal.
|
|
|
|
|
SmallString<128> NameStr(".rodata.jmp..");
|
|
|
|
|
getNameWithPrefix(NameStr, &F, TM);
|
|
|
|
|
return getContext().getXCOFFSection(NameStr, XCOFF::XMC_RO, XCOFF::XTY_SD,
|
|
|
|
|
SectionKind::getReadOnly());
|
2019-11-14 22:52:32 +08:00
|
|
|
}
|
|
|
|
|
|
2019-07-23 03:15:29 +08:00
|
|
|
bool TargetLoweringObjectFileXCOFF::shouldPutJumpTableInFunctionSection(
|
|
|
|
|
bool UsesLabelDifference, const Function &F) const {
|
2019-11-14 22:52:32 +08:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Given a mergeable constant with the specified size and relocation
|
|
|
|
|
/// information, return a section that it should be placed in.
|
|
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getSectionForConstant(
|
|
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
2020-05-22 06:23:00 +08:00
|
|
|
Align &Alignment) const {
|
2019-11-14 22:52:32 +08:00
|
|
|
//TODO: Enable emiting constant pool to unique sections when we support it.
|
2019-11-21 00:26:08 +08:00
|
|
|
return ReadOnlySection;
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void TargetLoweringObjectFileXCOFF::Initialize(MCContext &Ctx,
|
|
|
|
|
const TargetMachine &TgtM) {
|
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TgtM);
|
2020-12-02 22:48:52 +08:00
|
|
|
TTypeEncoding =
|
|
|
|
|
dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
|
|
|
|
|
(TgtM.getTargetTriple().isArch32Bit() ? dwarf::DW_EH_PE_sdata4
|
|
|
|
|
: dwarf::DW_EH_PE_sdata8);
|
2019-07-23 03:15:29 +08:00
|
|
|
PersonalityEncoding = 0;
|
|
|
|
|
LSDAEncoding = 0;
|
2020-12-02 22:48:52 +08:00
|
|
|
CallSiteEncoding = dwarf::DW_EH_PE_udata4;
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getStaticCtorSection(
|
2020-07-16 04:12:22 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
|
report_fatal_error("no static constructor section on AIX");
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getStaticDtorSection(
|
2020-07-16 04:12:22 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
|
report_fatal_error("no static destructor section on AIX");
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference(
|
|
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
|
|
|
|
const TargetMachine &TM) const {
|
2019-07-30 23:37:01 +08:00
|
|
|
report_fatal_error("XCOFF not yet implemented.");
|
2019-07-23 03:15:29 +08:00
|
|
|
}
|
2019-08-21 06:03:18 +08:00
|
|
|
|
2020-07-18 02:40:02 +08:00
|
|
|
XCOFF::StorageClass
|
|
|
|
|
TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(const GlobalValue *GV) {
|
|
|
|
|
assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
|
|
|
|
|
|
|
|
|
|
switch (GV->getLinkage()) {
|
2019-08-21 06:03:18 +08:00
|
|
|
case GlobalValue::InternalLinkage:
|
[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings
This patch adds support for generating assembly code for one-byte mergeable strings.
Generating assembly code for multi-byte mergeable strings and the `XCOFF` object code for mergeable strings will be supported later.
Reviewers: hubert.reinterpretcast, jasonliu, daltenty, sfertile, DiggerLin, Xiangling_L
Reviewed by: daltenty
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D70310
2019-11-21 00:01:45 +08:00
|
|
|
case GlobalValue::PrivateLinkage:
|
2019-08-21 06:03:18 +08:00
|
|
|
return XCOFF::C_HIDEXT;
|
|
|
|
|
case GlobalValue::ExternalLinkage:
|
|
|
|
|
case GlobalValue::CommonLinkage:
|
2020-05-29 23:41:10 +08:00
|
|
|
case GlobalValue::AvailableExternallyLinkage:
|
2019-08-21 06:03:18 +08:00
|
|
|
return XCOFF::C_EXT;
|
|
|
|
|
case GlobalValue::ExternalWeakLinkage:
|
2020-04-30 21:53:41 +08:00
|
|
|
case GlobalValue::LinkOnceAnyLinkage:
|
2020-02-27 05:48:23 +08:00
|
|
|
case GlobalValue::LinkOnceODRLinkage:
|
2020-04-30 21:53:41 +08:00
|
|
|
case GlobalValue::WeakAnyLinkage:
|
|
|
|
|
case GlobalValue::WeakODRLinkage:
|
2019-08-21 06:03:18 +08:00
|
|
|
return XCOFF::C_WEAKEXT;
|
2020-02-27 05:48:23 +08:00
|
|
|
case GlobalValue::AppendingLinkage:
|
|
|
|
|
report_fatal_error(
|
|
|
|
|
"There is no mapping that implements AppendingLinkage for XCOFF.");
|
2019-08-21 06:03:18 +08:00
|
|
|
}
|
2020-04-30 21:53:41 +08:00
|
|
|
llvm_unreachable("Unknown linkage type!");
|
2019-08-21 06:03:18 +08:00
|
|
|
}
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
|
2020-05-28 01:52:21 +08:00
|
|
|
MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
|
2020-07-18 02:40:02 +08:00
|
|
|
const GlobalValue *Func, const TargetMachine &TM) const {
|
|
|
|
|
assert(
|
2020-07-23 19:51:18 +08:00
|
|
|
(isa<Function>(Func) ||
|
|
|
|
|
(isa<GlobalAlias>(Func) &&
|
|
|
|
|
isa_and_nonnull<Function>(cast<GlobalAlias>(Func)->getBaseObject()))) &&
|
|
|
|
|
"Func must be a function or an alias which has a function as base "
|
|
|
|
|
"object.");
|
2020-11-09 23:12:46 +08:00
|
|
|
|
2020-05-28 01:52:21 +08:00
|
|
|
SmallString<128> NameStr;
|
|
|
|
|
NameStr.push_back('.');
|
2020-07-18 02:40:02 +08:00
|
|
|
getNameWithPrefix(NameStr, Func, TM);
|
2020-07-29 23:06:04 +08:00
|
|
|
|
2020-11-09 23:12:46 +08:00
|
|
|
// When -function-sections is enabled and explicit section is not specified,
|
|
|
|
|
// it's not necessary to emit function entry point label any more. We will use
|
|
|
|
|
// function entry point csect instead. And for function delcarations, the
|
|
|
|
|
// undefined symbols gets treated as csect with XTY_ER property.
|
|
|
|
|
if (((TM.getFunctionSections() && !Func->hasSection()) ||
|
|
|
|
|
Func->isDeclaration()) &&
|
2020-07-29 23:06:04 +08:00
|
|
|
isa<Function>(Func)) {
|
2020-11-09 23:12:46 +08:00
|
|
|
return getContext()
|
|
|
|
|
.getXCOFFSection(NameStr, XCOFF::XMC_PR,
|
|
|
|
|
Func->isDeclaration() ? XCOFF::XTY_ER : XCOFF::XTY_SD,
|
|
|
|
|
SectionKind::getText())
|
2020-07-29 23:06:04 +08:00
|
|
|
->getQualNameSymbol();
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-28 01:52:21 +08:00
|
|
|
return getContext().getOrCreateSymbol(NameStr);
|
|
|
|
|
}
|
|
|
|
|
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
|
2020-03-27 03:46:52 +08:00
|
|
|
const Function *F, const TargetMachine &TM) const {
|
|
|
|
|
SmallString<128> NameStr;
|
|
|
|
|
getNameWithPrefix(NameStr, F, TM);
|
|
|
|
|
return getContext().getXCOFFSection(NameStr, XCOFF::XMC_DS, XCOFF::XTY_SD,
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
SectionKind::getData());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
|
2020-08-11 03:35:50 +08:00
|
|
|
const MCSymbol *Sym, const TargetMachine &TM) const {
|
|
|
|
|
// Use TE storage-mapping class when large code model is enabled so that
|
|
|
|
|
// the chance of needing -bbigtoc is decreased.
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
return getContext().getXCOFFSection(
|
2020-08-11 03:35:50 +08:00
|
|
|
cast<MCSymbolXCOFF>(Sym)->getSymbolTableName(),
|
|
|
|
|
TM.getCodeModel() == CodeModel::Large ? XCOFF::XMC_TE : XCOFF::XMC_TC,
|
2020-08-12 03:26:19 +08:00
|
|
|
XCOFF::XTY_SD, SectionKind::getData());
|
[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile
Summary:
We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.
Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.
Reviewers: DiggerLin, jasonliu, hubert.reinterpretcast
Reviewed By: jasonliu, hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D72347
2020-01-23 00:09:34 +08:00
|
|
|
}
|