This is an archive of the discontinued LLVM Phabricator instance.

Differential D10478

[lld] [ELF] Fix wrong TBSS size
ClosedPublic

Authored by zatrazz on Jun 16 2015, 10:41 AM.

Details

Reviewers
ruiu
• shankar.easwaran
Summary

This patch fixes the wrong .tbss segment size generated for cases where
multiple modules have non initialized threads variables. For instance:

  • t0.c --

thread int x0;
thread int x1;
__thread int x2;

extern thread int e0;
extern thread int e1;
extern thread int e2;
extern thread int e3;

int foo0 ()
{

return x0;

}

int main ()
{

return x0;

}

  • t1.c --

thread int e0;
thread int e1;
thread int e2;
thread int e3;

lld is generating (for aarch64):

[14] .tbss             NOBITS           0000000000401000  00001000
     0000000000000010  0000000000000000 WAT       0     0     4

Where is just taking in consideration the largest tbss segment, not all
from all objects. ld generates a correct output:

[17] .tbss             NOBITS           0000000000410dec  00000dec
     000000000000001c  0000000000000000 WAT       0     0     4

This issue is at 'lib/ReaderWriter/ELF/SegmentChunks.cpp' where
Segment<ELFT>::assignVirtualAddress is setting wrong slice values, not taking care
of although tbss segments file size does noy play role in other segment virtual
address placement, its size should still be considered.

Diff Detail

Event Timeline

zatrazz updated this revision to Diff 27771.Jun 16 2015, 10:41 AM
zatrazz retitled this revision from to [lld] [ELF] Fix wrong TBSS size.
zatrazz updated this object.
zatrazz edited the test plan for this revision. (Show Details)
zatrazz added reviewers: ruiu, • shankar.easwaran.
zatrazz added a project: lld.
zatrazz added subscribers: Unknown Object (MLST), lld.
Herald added a subscriber: aemerson. · View Herald TranscriptJun 16 2015, 10:41 AM
ruiu accepted this revision.Jun 16 2015, 3:10 PM
ruiu edited edge metadata.

LGTM

This revision is now accepted and ready to land.Jun 16 2015, 3:10 PM
• shankar.easwaran accepted this revision.Jun 16 2015, 5:32 PM
• shankar.easwaran edited edge metadata.

LGTM

zatrazz closed this revision.Jun 24 2015, 6:34 AM

Revision Contents

PathSize
lib/
ReaderWriter/
ELF/
23 lines
test/
elf/
Inputs/
60 lines
177 lines

Diff 27771

lib/ReaderWriter/ELF/SegmentChunks.cpp

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 Linestemplate <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
startSectionIter = _sections.begin(); startSectionIter = _sections.begin();
startSection = 0; startSection = 0;
bool isDataPageAlignedForNMagic = false; bool isDataPageAlignedForNMagic = false;
uint64_t startAddr = addr; uint64_t startAddr = addr;
SegmentSlice<ELFT> *slice = nullptr; SegmentSlice<ELFT> *slice = nullptr;
uint64_t tlsStartAddr = 0; uint64_t tlsStartAddr = 0;
bool alignSegments = this->_ctx.alignSegments(); bool alignSegments = this->_ctx.alignSegments();
StringRef prevOutputSectionName = StringRef(); StringRef prevOutputSectionName = StringRef();
uint64_t tbssMemsize = 0;
// If this is first section in the segment, page align the section start // If this is first section in the segment, page align the section start
// address. The linker needs to align the data section to a page boundary // address. The linker needs to align the data section to a page boundary
// only if NMAGIC is set. // only if NMAGIC is set.
auto si = _sections.begin(); auto si = _sections.begin();
if (si != _sections.end()) { if (si != _sections.end()) {
if (alignSegments && if (alignSegments &&
_outputMagic != ELFLinkingContext::OutputMagic::NMAGIC && _outputMagic != ELFLinkingContext::OutputMagic::NMAGIC &&
Show All 27 Lines if (auto section = dyn_cast<Section<ELFT>>(*si)) {
} else { } else {
section->assignVirtualAddress(newAddr); section->assignVirtualAddress(newAddr);
} }
} }
// TBSS section is special in that it doesn't contribute to memory of any // TBSS section is special in that it doesn't contribute to memory of any
// segment. If we see a tbss section, don't add memory size to addr The // segment. If we see a tbss section, don't add memory size to addr The
// fileOffset is automatically taken care of since TBSS section does not // fileOffset is automatically taken care of since TBSS section does not
// end up using file size // end up using file size
if ((*si)->order() != TargetLayout<ELFT>::ORDER_TBSS) if ((*si)->order() != TargetLayout<ELFT>::ORDER_TBSS) {
curSliceSize = (*si)->memSize(); curSliceSize = (*si)->memSize();
tbssMemsize = 0;
} else {
tbssMemsize = (*si)->memSize();
}
++currSection; ++currSection;
++si; ++si;
} }
for (auto e = _sections.end(); si != e; ++si) { for (auto e = _sections.end(); si != e; ++si) {
uint64_t curAddr = curSliceAddress + curSliceSize; uint64_t curAddr = curSliceAddress + curSliceSize;
if (!isDataPageAlignedForNMagic && needAlign(*si)) { if (!isDataPageAlignedForNMagic && needAlign(*si)) {
// If the linker outputmagic is set to OutputMagic::NMAGIC, align the // If the linker outputmagic is set to OutputMagic::NMAGIC, align the
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (autoCreateSlice && ((newAddr - curAddr) > this->_ctx.getPageSize()) &&
} }
slice->setStart(startSection); slice->setStart(startSection);
slice->setSections(make_range(startSectionIter, si)); slice->setSections(make_range(startSectionIter, si));
slice->setMemSize(curSliceSize); slice->setMemSize(curSliceSize);
slice->setAlign(sliceAlign); slice->setAlign(sliceAlign);
slice->setVirtualAddr(curSliceAddress); slice->setVirtualAddr(curSliceAddress);
// Start new slice // Start new slice
curSliceAddress = newAddr; curSliceAddress = newAddr;
if ((*si)->order() == TargetLayout<ELFT>::ORDER_TBSS)
curSliceAddress += tbssMemsize;
(*si)->setVirtualAddr(curSliceAddress); (*si)->setVirtualAddr(curSliceAddress);
startSectionIter = si; startSectionIter = si;
startSection = currSection; startSection = currSection;
if (auto section = dyn_cast<Section<ELFT>>(*si)) if (auto section = dyn_cast<Section<ELFT>>(*si))
section->assignVirtualAddress(newAddr); section->assignVirtualAddress(newAddr);
curSliceSize = newAddr - curSliceAddress + (*si)->memSize(); curSliceSize = newAddr - curSliceAddress + (*si)->memSize();
sliceAlign = (*si)->alignment(); sliceAlign = (*si)->alignment();
} else { } else {
if (sliceAlign < (*si)->alignment()) if (sliceAlign < (*si)->alignment())
sliceAlign = (*si)->alignment(); sliceAlign = (*si)->alignment();
if ((*si)->order() == TargetLayout<ELFT>::ORDER_TBSS)
newAddr += tbssMemsize;
(*si)->setVirtualAddr(newAddr); (*si)->setVirtualAddr(newAddr);
// Handle TLS. // Handle TLS.
if (auto section = dyn_cast<Section<ELFT>>(*si)) { if (auto section = dyn_cast<Section<ELFT>>(*si)) {
if (section->getSegmentType() == llvm::ELF::PT_TLS) { if (section->getSegmentType() == llvm::ELF::PT_TLS) {
tlsStartAddr = tlsStartAddr =
llvm::RoundUpToAlignment(tlsStartAddr, (*si)->alignment()); llvm::RoundUpToAlignment(tlsStartAddr, (*si)->alignment());
section->assignVirtualAddress(tlsStartAddr); section->assignVirtualAddress(tlsStartAddr);
tlsStartAddr += (*si)->memSize(); tlsStartAddr += (*si)->memSize();
} else { } else {
section->assignVirtualAddress(newAddr); section->assignVirtualAddress(newAddr);
} }
} }
// TBSS section is special in that it doesn't contribute to memory of // TBSS section is special in that it doesn't contribute to memory of
// any segment. If we see a tbss section, don't add memory size to addr // any segment. If we see a tbss section, don't add memory size to addr
// The fileOffset is automatically taken care of since TBSS section does // The fileOffset is automatically taken care of since TBSS section does
// not end up using file size. // not end up using file size.
if ((*si)->order() != TargetLayout<ELFT>::ORDER_TBSS) if ((*si)->order() != TargetLayout<ELFT>::ORDER_TBSS) {
curSliceSize = newAddr - curSliceAddress + (*si)->memSize(); curSliceSize = newAddr - curSliceAddress + (*si)->memSize();
else tbssMemsize = 0;
curSliceSize = newAddr - curSliceAddress; } else {
// Although TBSS section does not contribute to memory of any segment,
// we still need to keep track its total size to correct write it
// down. Since it is done based on curSliceAddress, we need to add
// add it to virtual address.
tbssMemsize = (*si)->memSize();
}
} }
prevOutputSectionName = curOutputSectionName; prevOutputSectionName = curOutputSectionName;
++currSection; ++currSection;
} }
auto sliceIter = std::find_if(_segmentSlices.begin(), _segmentSlices.end(), auto sliceIter = std::find_if(_segmentSlices.begin(), _segmentSlices.end(),
[startSection](SegmentSlice<ELFT> *s) -> bool { [startSection](SegmentSlice<ELFT> *s) -> bool {
return s->startSection() == startSection; return s->startSection() == startSection;
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

test/elf/Inputs/tls-tbss-size.yaml

  • This file was added.
---
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
OSABI: ELFOSABI_GNU
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .data
Type: SHT_PROGBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .bss
Type: SHT_NOBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .tbss
Type: SHT_NOBITS
Flags: [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
AddressAlign: 0x0000000000000004
Content: 00636C616E672076657273696F6E2033
- Name: .note.GNU-stack
Type: SHT_PROGBITS
AddressAlign: 0x0000000000000001
Content: ''
Symbols:
Local:
- Name: t1.c
Type: STT_FILE
- Name: .tbss
Type: STT_TLS
Section: .tbss
Global:
- Name: t0
Type: STT_TLS
Section: .tbss
Size: 0x0000000000000004
- Name: t1
Type: STT_TLS
Section: .tbss
Value: 0x0000000000000004
Size: 0x0000000000000004
- Name: t2
Type: STT_TLS
Section: .tbss
Value: 0x0000000000000008
Size: 0x0000000000000004
- Name: t3
Type: STT_TLS
Section: .tbss
Value: 0x000000000000000C
Size: 0x0000000000000004
...

test/elf/tls-tbss-size.test

  • This file was added.
# This test verify if external TLS non initialized variables (tbss) are
# accounted in TBSS segment size
# The input file 'test/elf/Inputs/tls-tbss-size.yaml' declares:
#
# __thread int t0;
# __thread int t1;
# __thread int t2;
# __thread int t3;
#
# And the 'test/elf/tls-tbss-size.test' defines:
#
# __thread int t4;
# __thread int t5;
# __thread int t6;
# __thread int t7;
#
# __thread int t8 = 3;
# __thread int t9 = 4;
# __thread int t10 = 5;
# __thread int t11 = 6;
#RUN: yaml2obj -format=elf -o=%t-t1.o %p/Inputs/tls-tbss-size.yaml
#RUN: yaml2obj -format=elf -o=%t-t0.o %s
#RUN: lld -flavor gnu -target x86_64-linux --noinhibit-exec -o %t.exe %t-t0.o %t-t1.o
#RUN: llvm-readobj --sections %t.exe | FileCheck %s
#CHECK: Sections [
#CHECK: Section {
#CHECK: Index: 9
#CHECK: Name: .tdata (71)
#CHECK: Size: 16
#CHECK: }
#CHECK: Section {
#CHECK: Index: 10
#CHECK: Name: .tbss (78)
#CHECK: Size: 32
#CHECK: }
---
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
OSABI: ELFOSABI_GNU
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
AddressAlign: 0x0000000000000010
Content: 488B050000000064C70001000000488B050000000064C70002000000488B050000000064C70003000000488B050000000064C7000400000064C70425000000000500000064C70425000000000600000064C70425000000000700000064C70425000000000800000031C0C3
- Name: .rela.text
Type: SHT_RELA
Link: .symtab
AddressAlign: 0x0000000000000008
Info: .text
Relocations:
- Offset: 0x0000000000000003
Symbol: t0
Type: R_X86_64_GOTTPOFF
Addend: -4
- Offset: 0x0000000000000011
Symbol: t1
Type: R_X86_64_GOTTPOFF
Addend: -4
- Offset: 0x000000000000001F
Symbol: t2
Type: R_X86_64_GOTTPOFF
Addend: -4
- Offset: 0x000000000000002D
Symbol: t3
Type: R_X86_64_GOTTPOFF
Addend: -4
- Offset: 0x000000000000003C
Symbol: t4
Type: R_X86_64_TPOFF32
- Offset: 0x0000000000000048
Symbol: t5
Type: R_X86_64_TPOFF32
- Offset: 0x0000000000000054
Symbol: t6
Type: R_X86_64_TPOFF32
- Offset: 0x0000000000000060
Symbol: t7
Type: R_X86_64_TPOFF32
- Name: .data
Type: SHT_PROGBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .bss
Type: SHT_NOBITS
Flags: [ SHF_WRITE, SHF_ALLOC ]
AddressAlign: 0x0000000000000004
Content: ''
- Name: .tdata
Type: SHT_PROGBITS
Flags: [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
AddressAlign: 0x0000000000000004
Content: '03000000040000000500000006000000'
- Name: .tbss
Type: SHT_NOBITS
Flags: [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
AddressAlign: 0x0000000000000004
Content: 00636C616E672076657273696F6E2033
- Name: .note.GNU-stack
Type: SHT_PROGBITS
AddressAlign: 0x0000000000000001
Content: ''
- Name: .eh_frame
Type: SHT_PROGBITS
Flags: [ SHF_ALLOC ]
AddressAlign: 0x0000000000000008
Content: 1400000000000000017A5200017810011B0C070890010000140000001C000000000000006B0000000000000000000000
Symbols:
Local:
- Name: .tbss
Type: STT_TLS
Section: .tbss
- Name: .tdata
Type: STT_TLS
Section: .tdata
- Type: STT_SECTION
Section: .text
Global:
- Name: main
Type: STT_FUNC
Section: .text
Size: 0x000000000000006B
- Name: t0
Type: STT_TLS
- Name: t1
Type: STT_TLS
- Name: t10
Type: STT_TLS
Section: .tdata
Value: 0x0000000000000008
Size: 0x0000000000000004
- Name: t11
Type: STT_TLS
Section: .tdata
Value: 0x000000000000000C
Size: 0x0000000000000004
- Name: t2
Type: STT_TLS
- Name: t3
Type: STT_TLS
- Name: t4
Type: STT_TLS
Section: .tbss
Size: 0x0000000000000004
- Name: t5
Type: STT_TLS
Section: .tbss
Value: 0x0000000000000004
Size: 0x0000000000000004
- Name: t6
Type: STT_TLS
Section: .tbss
Value: 0x0000000000000008
Size: 0x0000000000000004
- Name: t7
Type: STT_TLS
Section: .tbss
Value: 0x000000000000000C
Size: 0x0000000000000004
- Name: t8
Type: STT_TLS
Section: .tdata
Size: 0x0000000000000004
- Name: t9
Type: STT_TLS
Section: .tdata
Value: 0x0000000000000004
Size: 0x0000000000000004
...