d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Vendor import of lld release_60 branch r323948:

Browse Source 
https://llvm.org/svn/llvm-project/lld/branches/release_60@323948
This commit is contained in:
Dimitry Andric 2018-02-01 21:14:34 +00:00
parent a506d0d6a9
commit a8506ab674
9 changed files with 111 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ELF/AArch64ErrataFix.cpp
View File

@ -47,6 +47,7 @@
using namespace llvm;
using namespace llvm::ELF;
using namespace llvm::object;
using namespace llvm::support;
using namespace llvm::support::endian;
using namespace lld;
@ -357,7 +358,7 @@ static uint64_t scanCortexA53Errata843419(InputSection *IS, uint64_t &Off,
uint64_t PatchOff = 0;
const uint8_t *Buf = IS->Data.begin();
const uint32_t *InstBuf = reinterpret_cast<const uint32_t *>(Buf + Off);
const ulittle32_t *InstBuf = reinterpret_cast<const ulittle32_t *>(Buf + Off);
uint32_t Instr1 = *InstBuf++;
uint32_t Instr2 = *InstBuf++;
uint32_t Instr3 = *InstBuf++;

48
ELF/LinkerScript.cpp
View File

@ -589,8 +589,12 @@ void LinkerScript::output(InputSection *S) {
// If there is a memory region associated with this input section, then
// place the section in that region and update the region index.
if (Ctx->LMARegion)
Ctx->LMARegion->CurPos += Pos - Before;
// FIXME: should we also produce overflow errors for LMARegion?
if (Ctx->MemRegion) {
uint64_t &CurOffset = Ctx->MemRegionOffset[Ctx->MemRegion];
uint64_t &CurOffset = Ctx->MemRegion->CurPos;
CurOffset += Pos - Before;
uint64_t CurSize = CurOffset - Ctx->MemRegion->Origin;
if (CurSize > Ctx->MemRegion->Length) {
@ -617,9 +621,8 @@ MemoryRegion *LinkerScript::findMemoryRegion(OutputSection *Sec) {
// If a memory region name was specified in the output section command,
// then try to find that region first.
if (!Sec->MemoryRegionName.empty()) {
auto It = MemoryRegions.find(Sec->MemoryRegionName);
if (It != MemoryRegions.end())
return It->second;
if (MemoryRegion *M = MemoryRegions.lookup(Sec->MemoryRegionName))
return M;
error("memory region '" + Sec->MemoryRegionName + "' not declared");
return nullptr;
}
@ -652,31 +655,24 @@ void LinkerScript::assignOffsets(OutputSection *Sec) {
setDot(Sec->AddrExpr, Sec->Location, false);
Ctx->MemRegion = Sec->MemRegion;
Ctx->LMARegion = Sec->LMARegion;
if (Ctx->MemRegion)
Dot = Ctx->MemRegionOffset[Ctx->MemRegion];
Dot = Ctx->MemRegion->CurPos;
switchTo(Sec);
if (Sec->LMAExpr) {
uint64_t D = Dot;
Ctx->LMAOffset = [=] { return Sec->LMAExpr().getValue() - D; };
}
if (Sec->LMAExpr)
Ctx->LMAOffset = Sec->LMAExpr().getValue() - Dot;
if (!Sec->LMARegionName.empty()) {
if (MemoryRegion *MR = MemoryRegions.lookup(Sec->LMARegionName)) {
uint64_t Offset = MR->Origin - Dot;
Ctx->LMAOffset = [=] { return Offset; };
} else {
error("memory region '" + Sec->LMARegionName + "' not declared");
}
}
if (MemoryRegion *MR = Sec->LMARegion)
Ctx->LMAOffset = MR->CurPos - Dot;
// If neither AT nor AT> is specified for an allocatable section, the linker
// will set the LMA such that the difference between VMA and LMA for the
// section is the same as the preceding output section in the same region
// https://sourceware.org/binutils/docs-2.20/ld/Output-Section-LMA.html
if (Ctx->LMAOffset)
Ctx->OutSec->LMAOffset = Ctx->LMAOffset();
if (PhdrEntry *L = Ctx->OutSec->PtLoad)
L->LMAOffset = Ctx->LMAOffset;
// The Size previously denoted how many InputSections had been added to this
// section, and was used for sorting SHF_LINK_ORDER sections. Reset it to
@ -698,7 +694,9 @@ void LinkerScript::assignOffsets(OutputSection *Sec) {
Cmd->Offset = Dot - Ctx->OutSec->Addr;
Dot += Cmd->Size;
if (Ctx->MemRegion)
Ctx->MemRegionOffset[Ctx->MemRegion] += Cmd->Size;
Ctx->MemRegion->CurPos += Cmd->Size;
if (Ctx->LMARegion)
Ctx->LMARegion->CurPos += Cmd->Size;
Ctx->OutSec->Size = Dot - Ctx->OutSec->Addr;
continue;
}
@ -797,6 +795,12 @@ void LinkerScript::adjustSectionsAfterSorting() {
if (auto *Sec = dyn_cast<OutputSection>(Base)) {
if (!Sec->Live)
continue;
if (!Sec->LMARegionName.empty()) {
if (MemoryRegion *M = MemoryRegions.lookup(Sec->LMARegionName))
Sec->LMARegion = M;
else
error("memory region '" + Sec->LMARegionName + "' not declared");
}
Sec->MemRegion = findMemoryRegion(Sec);
// Handle align (e.g. ".foo : ALIGN(16) { ... }").
if (Sec->AlignExpr)
@ -887,8 +891,8 @@ void LinkerScript::allocateHeaders(std::vector<PhdrEntry *> &Phdrs) {
LinkerScript::AddressState::AddressState() {
for (auto &MRI : Script->MemoryRegions) {
const MemoryRegion *MR = MRI.second;
MemRegionOffset[MR] = MR->Origin;
MemoryRegion *MR = MRI.second;
MR->CurPos = MR->Origin;
}
}

10
ELF/LinkerScript.h
View File

@ -118,11 +118,17 @@ enum class ConstraintKind { NoConstraint, ReadOnly, ReadWrite };
// target memory. Instances of the struct are created by parsing the
// MEMORY command.
struct MemoryRegion {
MemoryRegion(StringRef Name, uint64_t Origin, uint64_t Length, uint32_t Flags,
uint32_t NegFlags)
: Name(Name), Origin(Origin), Length(Length), Flags(Flags),
NegFlags(NegFlags) {}
std::string Name;
uint64_t Origin;
uint64_t Length;
uint32_t Flags;
uint32_t NegFlags;
uint64_t CurPos = 0;
};
// This struct represents one section match pattern in SECTIONS() command.
@ -200,8 +206,8 @@ class LinkerScript final {
uint64_t ThreadBssOffset = 0;
OutputSection *OutSec = nullptr;
MemoryRegion *MemRegion = nullptr;
llvm::DenseMap<const MemoryRegion *, uint64_t> MemRegionOffset;
std::function<uint64_t()> LMAOffset;
MemoryRegion *LMARegion = nullptr;
uint64_t LMAOffset = 0;
};
llvm::DenseMap<StringRef, OutputSection *> NameToOutputSection;

4
ELF/OutputSections.h
View File

@ -49,7 +49,7 @@ class OutputSection final : public BaseCommand, public SectionBase {
static bool classof(const BaseCommand *C);
uint64_t getLMA() const { return Addr + LMAOffset; }
uint64_t getLMA() const { return PtLoad ? Addr + PtLoad->LMAOffset : Addr; }
template <typename ELFT> void writeHeaderTo(typename ELFT::Shdr *SHdr);
unsigned SectionIndex;
@ -78,7 +78,6 @@ class OutputSection final : public BaseCommand, public SectionBase {
// The following fields correspond to Elf_Shdr members.
uint64_t Offset = 0;
uint64_t LMAOffset = 0;
uint64_t Addr = 0;
uint32_t ShName = 0;
@ -89,6 +88,7 @@ class OutputSection final : public BaseCommand, public SectionBase {
// The following members are normally only used in linker scripts.
MemoryRegion *MemRegion = nullptr;
MemoryRegion *LMARegion = nullptr;
Expr AddrExpr;
Expr AlignExpr;
Expr LMAExpr;

4
ELF/ScriptParser.cpp
View File

@ -1293,8 +1293,8 @@ void ScriptParser::readMemory() {
// Add the memory region to the region map.
if (Script->MemoryRegions.count(Name))
setError("region '" + Name + "' already defined");
MemoryRegion *MR = make<MemoryRegion>();
*MR = {Name, Origin, Length, Flags, NegFlags};
MemoryRegion *MR =
make<MemoryRegion>(Name, Origin, Length, Flags, NegFlags);
Script->MemoryRegions[Name] = MR;
}
}

6
ELF/Writer.cpp
View File

@ -822,6 +822,8 @@ void PhdrEntry::add(OutputSection *Sec) {
p_align = std::max(p_align, Sec->Alignment);
if (p_type == PT_LOAD)
Sec->PtLoad = this;
if (Sec->LMAExpr)
ASectionHasLMA = true;
}
// The beginning and the ending of .rel[a].plt section are marked
@ -1626,7 +1628,9 @@ template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
// different flags or is loaded at a discontiguous address using AT linker
// script command.
uint64_t NewFlags = computeFlags(Sec->getPhdrFlags());
if (Sec->LMAExpr || Flags != NewFlags) {
if ((Sec->LMAExpr && Load->ASectionHasLMA) ||
Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags) {
Load = AddHdr(PT_LOAD, NewFlags);
Flags = NewFlags;
}

7
ELF/Writer.h
View File

@ -44,6 +44,13 @@ struct PhdrEntry {
OutputSection *FirstSec = nullptr;
OutputSection *LastSec = nullptr;
bool HasLMA = false;
// True if one of the sections in this program header has a LMA specified via
// linker script: AT(addr). We never allow 2 or more sections with LMA in the
// same program header.
bool ASectionHasLMA = false;
uint64_t LMAOffset = 0;
};
void addReservedSymbols();

38
test/ELF/linkerscript/at3.s Normal file
View File

@ -0,0 +1,38 @@
# REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
# RUN: echo "MEMORY { \
# RUN: FOO (ax) : ORIGIN = 0x1000, LENGTH = 0x100 \
# RUN: BAR (ax) : ORIGIN = 0x2000, LENGTH = 0x100 \
# RUN: ZED (ax) : ORIGIN = 0x3000, LENGTH = 0x100 \
# RUN: FLASH (ax) : ORIGIN = 0x6000, LENGTH = 0x200 \
# RUN: } \
# RUN: SECTIONS { \
# RUN: .foo1 : { *(.foo1) } > FOO AT>FLASH \
# RUN: .foo2 : { *(.foo2) BYTE(0x42) } > BAR AT>FLASH \
# RUN: .foo3 : { *(.foo3) } > ZED AT>FLASH \
# RUN: }" > %t.script
# RUN: ld.lld %t.o --script %t.script -o %t
# RUN: llvm-readelf -sections -program-headers %t | FileCheck %s
# CHECK: .foo1 PROGBITS 0000000000001000 001000
# CHECK: .foo2 PROGBITS 0000000000002000 002000
# CHECK: .foo3 PROGBITS 0000000000003000 003000
# CHECK: Program Headers:
# CHECK-NOT: LOAD
# CHECK: Type Offset VirtAddr PhysAddr
# CHECK-NEXT: LOAD 0x001000 0x0000000000001000 0x0000000000006000
# CHECK-NEXT: LOAD 0x002000 0x0000000000002000 0x0000000000006008
# CHECK-NEXT: LOAD 0x003000 0x0000000000003000 0x0000000000006011
# CHECK-NOT: LOAD
.section .foo1, "a"
.quad 0
.section .foo2, "ax"
.quad 0
.section .foo3, "ax"
.quad 0

21
test/ELF/linkerscript/merge-header-load.s Normal file
View File

@ -0,0 +1,21 @@
# REQUIRES: x86
# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
# RUN: echo "SECTIONS { \
# RUN: . = 0xffffffff80000200; \
# RUN: .text : AT (0x4200) { *(.text) } \
# RUN: }" > %t.script
# RUN: ld.lld %t.o --script %t.script -o %t
# RUN: llvm-readelf -program-headers %t | FileCheck %s
# Test that we put the header in the first PT_LOAD. We used to create a PT_LOAD
# just for it and it would have a different virtual to physical address delta.
# CHECK: Program Headers:
# CHECK: Type Offset VirtAddr PhysAddr
# CHECK-NEXT: PHDR 0x000040 0xffffffff80000040 0x0000000000004040
# CHECK-NEXT: LOAD 0x000000 0xffffffff80000000 0x0000000000004000
# CHECK-NOT: LOAD
.global _start
_start:
nop