Index: ELF/LinkerScript.h =================================================================== --- ELF/LinkerScript.h +++ ELF/LinkerScript.h @@ -19,6 +19,7 @@ namespace lld { namespace elf { +class LocCounterEvaluator; class ScriptParser; template class InputSectionBase; @@ -54,6 +55,9 @@ template bool isDiscarded(InputSectionBase *S); template bool shouldKeep(InputSectionBase *S); int compareSections(StringRef A, StringRef B); + uint64_t getSectionVA(StringRef Name, uint64_t VA); + + bool Exist = false; private: template SectionRule *find(InputSectionBase *S); @@ -67,6 +71,9 @@ // Section fill attribute for each section. llvm::StringMap> Filler; + // Contains the tokens for calculating VA of an output section. + llvm::StringMap> SecLoc; + llvm::BumpPtrAllocator Alloc; }; Index: ELF/LinkerScript.cpp =================================================================== --- ELF/LinkerScript.cpp +++ ELF/LinkerScript.cpp @@ -28,7 +28,226 @@ using namespace lld; using namespace lld::elf; +class elf::LocCounterEvaluator { +public: + void setLocationCounter(uint64_t VA) { Values["."] = VA; } + + // Evaluates the expression given by list of tokens. Fills the Out + // with value of expression if succeded. Returns false on error. + bool evaluate(std::vector &Tokens, uint64_t *Out) { + std::vector RPN = buildRPN(Tokens); + std::vector Stack; + std::vector Temps; + + // Pushes integer value to stack. + auto PushStackVal = [&](uint64_t Val) { + Temps.emplace_back(std::to_string(Val)); + Stack.push_back(Temps.back()); + }; + + // Tries to perform division operation. If returns true that means we + // have error result and do not need to continue. + auto DivOp = [this, PushStackVal](StringRef Arg1, StringRef Arg2) { + uint64_t Val = getValue(Arg2); + if (!Val) { + error("division by zero"); + return true; + } + PushStackVal(getValue(Arg1) / Val); + return false; + }; + + std::vector Conditions; + for (StringRef Op : RPN) { + bool IsFuncToken = isFuncToken(Op); + if (!isOperator(Op) && !isTernary(Op) && !IsFuncToken) { + Stack.push_back(Op); + continue; + } + + // Currently there is only one built in function implemented + // for counter, it is ALIGN. + StringRef Arg2 = *std::prev(Stack.end(), 1); + if (IsFuncToken) { + assert(Op == "ALIGN"); + Stack.pop_back(); + PushStackVal(alignTo(getValue("."), getValue(Arg2))); + continue; + } + + StringRef Arg1 = *std::prev(Stack.end(), 2); + Stack.erase(std::prev(Stack.end(), 2), Stack.end()); + + bool HaveResult = false; + if (Op == "+") + PushStackVal(getValue(Arg1) + getValue(Arg2)); + else if (Op == "-") + PushStackVal(getValue(Arg1) - getValue(Arg2)); + else if (Op == "*") + PushStackVal(getValue(Arg1) * getValue(Arg2)); + else if (Op == "/") + HaveResult = DivOp(Arg1, Arg2); + else if (Op == "!=") + Conditions.push_back(getValue(Arg1) != getValue(Arg2)); + else if (Op == ":?") { + if (Conditions.empty()) + fatal("error in location counter expression"); + PushStackVal(Conditions.back() ? getValue(Arg1) : getValue(Arg2)); + Conditions.pop_back(); + } else + fatal("unknown operator in location counter expression"); + + if (HaveResult) + return !HasError; + } + + if (Stack.size() == 1) { + if (Out) + *Out = getValue(Stack.back()); + return !HasError; + } + + return false; + } + + uint64_t getValue(StringRef V) { + uint64_t Val; + if (!V.getAsInteger(0, Val)) + return Val; + auto I = Values.find(V); + if (I != Values.end()) + return I->second; + error("undeclared variable " + V); + return 0; + } + +protected: + // Builds Reverse Polish Notation using + // shunting-yard algorithm by Edsger Dijkstra. + // https://en.wikipedia.org/wiki/Shunting-yard_algorithm + std::vector buildRPN(std::vector &Tokens) { + std::vector OutString; + std::list Stack; + int32_t OpenedBrackets = 0; + + for (StringRef Tok : Tokens) { + // If the token is a function token, then push it onto the stack. + if (isFuncToken(Tok)) { + Stack.push_back(Tok); + continue; + } + + // If the token is a number, then add it to the output queue. + if (!isOperator(Tok)) { + OutString.push_back(Tok); + continue; + } + + // Handle ternary operations. + if (Tok == ":") { + while (!Stack.empty()) { + StringRef StackTok = Stack.back(); + Stack.pop_back(); + if (StackTok != "?") { + OutString.push_back(StackTok); + continue; + } + Stack.push_back(":?"); + break; + } + continue; + } + + // If the token is a left parenthesis, then push it onto the stack. + if (Tok == "(") { + ++OpenedBrackets; + Stack.push_back(Tok); + continue; + } + + // If the token is a right parenthesis: + // Until the token at the top of the stack is a left parenthesis, pop + // operators off the stack onto the output queue. + // Pop the left parenthesis from the stack, but not onto the output + // queue. + if (Tok == ")") { + --OpenedBrackets; + if (OpenedBrackets < 0) + error("inconsistent opening/closing bracket"); + while (!Stack.empty()) { + StringRef StackTok = Stack.back(); + Stack.pop_back(); + + if (StackTok != "(") { + OutString.push_back(StackTok); + continue; + } + + // If the token is a right parenthesis (i.e. ")"): + // If the token at the top of the stack is a function token, pop it + // onto the output queue. + if (!Stack.empty()) { + StackTok = Stack.back(); + if (isFuncToken(StackTok)) { + OutString.push_back(StackTok); + Stack.pop_back(); + } + } + } + continue; + } + + // If the token is an operator, Tok, then: + // while there is an operator token St, at the top of the operator stack: + // if either + // 1) Tok is left associative and its precedence is less than or equal + // to that of St. + // 2) Tok is right associative, and has precedence less than that of St. + // Then pop StackTok off the operator stack, onto the output queue. + // At the end of iteration push Tok onto the operator stack. + auto ExtractStack = [this](StringRef Tok, StringRef StackTok) { + uint8_t Pr = getPriority(Tok); + bool LeftAssoc = isLeftAssoc(Tok); + uint8_t StackPr = getPriority(StackTok); + return (LeftAssoc && Pr <= StackPr) || (!LeftAssoc && Pr < StackPr); + }; + while (!Stack.empty()) { + StringRef St = Stack.back(); + if (ExtractStack(Tok, St)) { + OutString.push_back(St); + Stack.pop_back(); + continue; + } + break; + } + Stack.push_back(Tok); + } + + if (OpenedBrackets > 0) + error("inconsistent opening/closing bracket"); + + // Add the remaining stack content to output string. + OutString.insert(OutString.end(), Stack.rbegin(), Stack.rend()); + return OutString; + } + + bool isOperator(StringRef O) { return Operators.find(O) != Operators.end(); } + bool isLeftAssoc(StringRef O) { return Operators.find(O)->second.second; } + uint8_t getPriority(StringRef O) { return Operators.find(O)->second.first; } + bool isFuncToken(StringRef O) { return O == "ALIGN"; } + bool isTernary(StringRef O) { return O == ":?"; } + + // Operator Name->[Rank, IsLeftAssociative] pair. + std::map> Operators = { + {"!=", {110, true}}, {"*", {80, true}}, {"/", {80, true}}, + {"+", {50, true}}, {"-", {50, true}}, {"?", {30, false}}, + {":", {25, false}}, {"(", {20, true}}, {")", {20, true}}}; + + std::map Values; +}; + LinkerScript *elf::Script; +LocCounterEvaluator Eval; template SectionRule *LinkerScript::find(InputSectionBase *S) { @@ -73,6 +292,18 @@ return I < J ? -1 : 1; } +uint64_t LinkerScript::getSectionVA(StringRef Name, uint64_t VA) { + auto It = SecLoc.find(Name); + if (It == SecLoc.end()) + return VA; + + uint64_t Cond = 0; + Eval.setLocationCounter(VA); + if (!Eval.evaluate(It->second, &Cond)) + error("error in location counter expression"); + return Cond; +} + // Returns true if S matches T. S can contain glob meta-characters. // The asterisk ('*') matches zero or more characacters, and the question // mark ('?') matches one character. @@ -137,6 +368,8 @@ void readOutputSectionDescription(); void readSectionPatterns(StringRef OutSec, bool Keep); + std::vector readLocationCounterValue(); + std::vector parseHex(StringRef S); StringSaver Saver; @@ -145,6 +378,8 @@ size_t Pos = 0; bool IsUnderSysroot; bool Error = false; + + std::vector LocCounterTokens; }; const StringMap elf::ScriptParser::Cmd = { @@ -201,7 +436,7 @@ // Unquoted token size_t Pos = S.find_first_not_of( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" - "0123456789_.$/\\~=+[]*?-:"); + "0123456789_.$/\\~=+[]*?-:!"); // A character that cannot start a word (which is usually a // punctuation) forms a single character token. if (Pos == 0) @@ -427,7 +662,27 @@ return Hex; } +std::vector ScriptParser::readLocationCounterValue() { + expect("."); + expect("="); + + std::vector ExpList; + while (!Error) { + StringRef Tok = next(); + if (Tok == ";") + break; + ExpList.push_back(Tok); + } + return ExpList; +} + void ScriptParser::readOutputSectionDescription() { + StringRef Tok = peek(); + if (Tok == ".") { + LocCounterTokens = readLocationCounterValue(); + return; + } + StringRef OutSec = next(); Script->SectionOrder.push_back(OutSec); expect(":"); @@ -445,7 +700,7 @@ setError("unknown command " + Tok); } } - StringRef Tok = peek(); + Tok = peek(); if (Tok.startswith("=")) { if (!Tok.startswith("=0x")) { setError("filler should be a hexadecimal value"); @@ -455,6 +710,9 @@ Script->Filler[OutSec] = parseHex(Tok); next(); } + + if (!LocCounterTokens.empty()) + Script->SecLoc[OutSec] = std::move(LocCounterTokens); } static bool isUnderSysroot(StringRef Path) { @@ -470,6 +728,7 @@ void LinkerScript::read(MemoryBufferRef MB) { StringRef Path = MB.getBufferIdentifier(); ScriptParser(&Alloc, MB.getBuffer(), isUnderSysroot(Path)).run(); + Exist = true; } template StringRef LinkerScript::getOutputSection(InputSectionBase *); Index: ELF/Target.cpp =================================================================== --- ELF/Target.cpp +++ ELF/Target.cpp @@ -18,6 +18,7 @@ #include "Target.h" #include "Error.h" #include "OutputSections.h" +#include "LinkerScript.h" #include "Symbols.h" #include "llvm/ADT/ArrayRef.h" @@ -271,7 +272,9 @@ return false; } -uint64_t TargetInfo::getVAStart() const { return Config->Pic ? 0 : VAStart; } +uint64_t TargetInfo::getVAStart() const { + return (Config->Pic || Script->Exist) ? 0 : VAStart; +} bool TargetInfo::needsCopyRelImpl(uint32_t Type) const { return false; } Index: ELF/Writer.cpp =================================================================== --- ELF/Writer.cpp +++ ELF/Writer.cpp @@ -1264,10 +1264,16 @@ continue; // If flags changed then we want new load segment. + // If we have linker script then we don't do that, because + // it is script writer responsibility to assign VA's. uintX_t NewFlags = toPhdrFlags(Sec->getFlags()); if (Flags != NewFlags) { - Load = AddHdr(PT_LOAD, NewFlags); - Flags = NewFlags; + if (Script->Exist) { + Load->H.p_flags |= NewFlags; + } else { + Load = AddHdr(PT_LOAD, NewFlags); + Flags = NewFlags; + } } AddSec(*Load, Sec); @@ -1337,6 +1343,11 @@ // have to be page aligned so that the dynamic linker can set the permissions. SmallPtrSet *, 4> PageAlign; for (const Phdr &P : Phdrs) { + // Do not align anything if we have linker script, + // in that situation script writer is responsible to perform all operations + // on location counter value. + if (Script->Exist) + break; if (P.H.p_type == PT_GNU_RELRO) { // Find the first section after PT_GNU_RELRO. If it is in a PT_LOAD we // have to align it to a page. @@ -1365,6 +1376,9 @@ if (Sec->getType() != SHT_NOBITS) FileOff += Sec->getSize(); + if (Script->Exist) + VA = Script->getSectionVA(Sec->getName(), VA); + // We only assign VAs to allocated sections. if (needsPtLoad(Sec)) { VA = alignTo(VA, Align); Index: test/ELF/end.s =================================================================== --- test/ELF/end.s +++ test/ELF/end.s @@ -36,13 +36,13 @@ // NOBSS-NEXT: SHF_ALLOC // NOBSS-NEXT: SHF_WRITE // NOBSS-NEXT: ] -// NOBSS-NEXT: Address: 0x12000 +// NOBSS-NEXT: Address: 0xE9 // NOBSS-NEXT: Offset: // NOBSS-NEXT: Size: 2 // NOBSS: ] // NOBSS: Symbols [ // NOBSS: Name: _end -// NOBSS-NEXT: Value: 0x12002 +// NOBSS-NEXT: Value: 0xEB // NOBSS: ] // If the layout of the sections is changed, "_end" should point to the end of allocated address space. @@ -60,13 +60,13 @@ // TEXTATEND-NEXT: SHF_ALLOC // TEXTATEND-NEXT: SHF_EXECINSTR // TEXTATEND-NEXT: ] -// TEXTATEND-NEXT: Address: 0x12000 +// TEXTATEND-NEXT: Address: 0xF0 // TEXTATEND-NEXT: Offset: // TEXTATEND-NEXT: Size: 1 // TEXTATEND: ] // TEXTATEND: Symbols [ // TEXTATEND: Name: _end -// TEXTATEND-NEXT: Value: 0x12001 +// TEXTATEND-NEXT: Value: 0xF1 // TEXTATEND: ] .global _start,_end Index: test/ELF/linkerscript-locationcounter.s =================================================================== --- test/ELF/linkerscript-locationcounter.s +++ test/ELF/linkerscript-locationcounter.s @@ -0,0 +1,149 @@ +# REQUIRES: x86 +# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t +# RUN: echo "SECTIONS { \ +# RUN: . = 0x12341; \ +# RUN: .data : { *(.data) } \ +# RUN: . = ALIGN(. != 0 ? 64 / 8 : 1); \ +# RUN: .text : { *(.text) } \ +# RUN: . = ALIGN(64 / 2); \ +# RUN: .temp : { *(.temp) } \ +# RUN: . = (. + 0x100) * 2;\ +# RUN: .boo : { *(.boo) } \ +# RUN: }" > %t.script + +# RUN: ld.lld %t --script %t.script -o %t2 +# RUN: llvm-readobj -s %t2 | FileCheck %s + +# CHECK: Sections [ +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 0 +# CHECK-NEXT: Name: (0) +# CHECK-NEXT: Type: SHT_NULL +# CHECK-NEXT: Flags [ +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x0 +# CHECK-NEXT: Offset: 0x0 +# CHECK-NEXT: Size: 0 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 0 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 1 +# CHECK-NEXT: Name: .data +# CHECK-NEXT: Type: SHT_PROGBITS +# CHECK-NEXT: Flags [ +# CHECK-NEXT: SHF_ALLOC +# CHECK-NEXT: SHF_WRITE +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x12341 +# CHECK-NEXT: Offset: 0xE8 +# CHECK-NEXT: Size: 8 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 1 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 2 +# CHECK-NEXT: Name: .text +# CHECK-NEXT: Type: SHT_PROGBITS +# CHECK-NEXT: Flags [ +# CHECK-NEXT: SHF_ALLOC +# CHECK-NEXT: SHF_EXECINSTR +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x12350 +# CHECK-NEXT: Offset: 0xF0 +# CHECK-NEXT: Size: 1 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 4 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 3 +# CHECK-NEXT: Name: .temp +# CHECK-NEXT: Type: SHT_PROGBITS +# CHECK-NEXT: Flags [ +# CHECK-NEXT: SHF_ALLOC +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x12360 +# CHECK-NEXT: Offset: 0xF1 +# CHECK-NEXT: Size: 8 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 1 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 4 +# CHECK-NEXT: Name: .boo +# CHECK-NEXT: Type: SHT_PROGBITS +# CHECK-NEXT: Flags [ +# CHECK-NEXT: SHF_ALLOC +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x248D0 +# CHECK-NEXT: Offset: 0xF9 +# CHECK-NEXT: Size: 8 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 1 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 5 +# CHECK-NEXT: Name: .symtab +# CHECK-NEXT: Type: SHT_SYMTAB +# CHECK-NEXT: Flags [ +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x0 +# CHECK-NEXT: Offset: 0x108 +# CHECK-NEXT: Size: 48 +# CHECK-NEXT: Link: 7 +# CHECK-NEXT: Info: 1 +# CHECK-NEXT: AddressAlignment: 8 +# CHECK-NEXT: EntrySize: 24 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 6 +# CHECK-NEXT: Name: .shstrtab +# CHECK-NEXT: Type: SHT_STRTAB +# CHECK-NEXT: Flags [ +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x0 +# CHECK-NEXT: Offset: 0x138 +# CHECK-NEXT: Size: 50 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 1 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: Section { +# CHECK-NEXT: Index: 7 +# CHECK-NEXT: Name: .strtab +# CHECK-NEXT: Type: SHT_STRTAB +# CHECK-NEXT: Flags [ +# CHECK-NEXT: ] +# CHECK-NEXT: Address: 0x0 +# CHECK-NEXT: Offset: 0x16A +# CHECK-NEXT: Size: 8 +# CHECK-NEXT: Link: 0 +# CHECK-NEXT: Info: 0 +# CHECK-NEXT: AddressAlignment: 1 +# CHECK-NEXT: EntrySize: 0 +# CHECK-NEXT: } +# CHECK-NEXT: ] + +.globl _start; +_start: +nop + +.section .temp, "a" +.quad 0 + +.section .data +.quad 0 + +.section .boo, "a" +.quad 0 Index: test/ELF/linkerscript-oneload.s =================================================================== --- test/ELF/linkerscript-oneload.s +++ test/ELF/linkerscript-oneload.s @@ -0,0 +1,52 @@ +# REQUIRES: x86 + +# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t +# RUN: echo "" > %t.script +# RUN: ld.lld %t --script %t.script -o %t2 +# RUN: llvm-readobj -program-headers -symbols %t2 | FileCheck %s + +.globl _start; +_start: + nop + +## Check that only one PT_LOAD is created with empty linker script. +# CHECK: ProgramHeaders [ +# CHECK-NEXT: ProgramHeader { +# CHECK-NEXT: Type: PT_PHDR +# CHECK-NEXT: Offset: 0x40 +# CHECK-NEXT: VirtualAddress: 0x40 +# CHECK-NEXT: PhysicalAddress: 0x40 +# CHECK-NEXT: FileSize: 168 +# CHECK-NEXT: MemSize: 168 +# CHECK-NEXT: Flags [ +# CHECK-NEXT: PF_R +# CHECK-NEXT: ] +# CHECK-NEXT: Alignment: 8 +# CHECK-NEXT: } +# CHECK-NEXT: ProgramHeader { +# CHECK-NEXT: Type: PT_LOAD +# CHECK-NEXT: Offset: 0x0 +# CHECK-NEXT: VirtualAddress: 0x0 +# CHECK-NEXT: PhysicalAddress: 0x0 +# CHECK-NEXT: FileSize: 233 +# CHECK-NEXT: MemSize: 233 +# CHECK-NEXT: Flags [ +# CHECK-NEXT: PF_R +# CHECK-NEXT: PF_X +# CHECK-NEXT: ] +# CHECK-NEXT: Alignment: 4096 +# CHECK-NEXT: } +# CHECK-NEXT: ProgramHeader { +# CHECK-NEXT: Type: PT_GNU_STACK +# CHECK-NEXT: Offset: 0x0 +# CHECK-NEXT: VirtualAddress: 0x0 +# CHECK-NEXT: PhysicalAddress: 0x0 +# CHECK-NEXT: FileSize: 0 +# CHECK-NEXT: MemSize: 0 +# CHECK-NEXT: Flags [ +# CHECK-NEXT: PF_R +# CHECK-NEXT: PF_W +# CHECK-NEXT: ] +# CHECK-NEXT: Alignment: 0 +# CHECK-NEXT: } +# CHECK-NEXT: ] Index: test/ELF/linkerscript-sections-keep.s =================================================================== --- test/ELF/linkerscript-sections-keep.s +++ test/ELF/linkerscript-sections-keep.s @@ -12,8 +12,8 @@ # SECGC: Sections: # SECGC-NEXT: Idx Name Size Address Type # SECGC-NEXT: 0 00000000 0000000000000000 -# SECGC-NEXT: 1 .text 00000007 0000000000011000 TEXT DATA -# SECGC-NEXT: 2 .temp 00000004 0000000000012000 DATA +# SECGC-NEXT: 1 .text 00000007 00000000000000e8 TEXT DATA +# SECGC-NEXT: 2 .temp 00000004 00000000000000ef DATA ## Now apply KEEP command to preserve the section. # RUN: echo "SECTIONS { \ @@ -26,9 +26,9 @@ # SECNOGC: Sections: # SECNOGC-NEXT: Idx Name Size Address Type # SECNOGC-NEXT: 0 00000000 0000000000000000 -# SECNOGC-NEXT: 1 .text 00000007 0000000000011000 TEXT DATA -# SECNOGC-NEXT: 2 .keep 00000004 0000000000012000 DATA -# SECNOGC-NEXT: 3 .temp 00000004 0000000000012004 DATA +# SECNOGC-NEXT: 1 .text 00000007 00000000000000e8 TEXT DATA +# SECNOGC-NEXT: 2 .keep 00000004 00000000000000ef DATA +# SECNOGC-NEXT: 3 .temp 00000004 00000000000000f3 DATA ## A section name matches two entries in the SECTIONS directive. The ## first one doesn't have KEEP, the second one does. If section that have @@ -42,9 +42,9 @@ # KEEP-AT-FIRST: Sections: # KEEP-AT-FIRST-NEXT: Idx Name Size Address Type # KEEP-AT-FIRST-NEXT: 0 00000000 0000000000000000 -# KEEP-AT-FIRST-NEXT: 1 .keep 00000004 0000000000010120 DATA -# KEEP-AT-FIRST-NEXT: 2 .temp 00000004 0000000000010124 DATA -# KEEP-AT-FIRST-NEXT: 3 .text 00000007 0000000000011000 TEXT DATA +# KEEP-AT-FIRST-NEXT: 1 .keep 00000004 00000000000000e8 DATA +# KEEP-AT-FIRST-NEXT: 2 .temp 00000004 00000000000000ec DATA +# KEEP-AT-FIRST-NEXT: 3 .text 00000007 00000000000000f0 TEXT DATA # KEEP-AT-FIRST-NEXT: 4 .symtab 00000060 0000000000000000 # KEEP-AT-FIRST-NEXT: 5 .shstrtab 0000002d 0000000000000000 # KEEP-AT-FIRST-NEXT: 6 .strtab 00000012 0000000000000000 @@ -63,8 +63,8 @@ # KEEP-AT-SECOND: Sections: # KEEP-AT-SECOND-NEXT: Idx Name Size Address Type # KEEP-AT-SECOND-NEXT: 0 00000000 0000000000000000 -# KEEP-AT-SECOND-NEXT: 1 .temp 00000004 0000000000010120 DATA -# KEEP-AT-SECOND-NEXT: 2 .text 00000007 0000000000011000 TEXT DATA +# KEEP-AT-SECOND-NEXT: 1 .temp 00000004 00000000000000e8 DATA +# KEEP-AT-SECOND-NEXT: 2 .text 00000007 00000000000000ec TEXT DATA # KEEP-AT-SECOND-NEXT: 3 .symtab 00000048 0000000000000000 # KEEP-AT-SECOND-NEXT: 4 .shstrtab 00000027 0000000000000000 # KEEP-AT-SECOND-NEXT: 5 .strtab 0000000d 0000000000000000 Index: test/ELF/linkerscript-sections-padding.s =================================================================== --- test/ELF/linkerscript-sections-padding.s +++ test/ELF/linkerscript-sections-padding.s @@ -5,19 +5,19 @@ # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x112233445566778899 }" > %t.script # RUN: ld.lld -o %t.out --script %t.script %t # RUN: hexdump -C %t.out | FileCheck -check-prefix=YES %s -# YES: 00000120 66 22 33 44 55 66 77 88 99 11 22 33 44 55 66 77 +# YES: 000000f0 66 22 33 44 55 66 77 88 99 11 22 33 44 55 66 77 ## Confirming that address was correct: # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x998877665544332211 }" > %t.script # RUN: ld.lld -o %t.out --script %t.script %t # RUN: hexdump -C %t.out | FileCheck -check-prefix=YES2 %s -# YES2: 00000120 66 88 77 66 55 44 33 22 11 99 88 77 66 55 44 +# YES2: 000000f0 66 88 77 66 55 44 33 22 11 99 88 77 66 55 44 ## Default padding value is 0x00: # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } }" > %t.script # RUN: ld.lld -o %t.out --script %t.script %t # RUN: hexdump -C %t.out | FileCheck -check-prefix=NO %s -# NO: 00000120 66 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +# NO: 000000f0 66 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ## Filler should be a hex value (1): # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =99 }" > %t.script Index: test/ELF/wildcards.s =================================================================== --- test/ELF/wildcards.s +++ test/ELF/wildcards.s @@ -10,10 +10,10 @@ # SEC-DEFAULT: Sections: # SEC-DEFAULT-NEXT: Idx Name Size Address Type # SEC-DEFAULT-NEXT: 0 00000000 0000000000000000 -# SEC-DEFAULT-NEXT: 1 .text 00000008 0000000000011000 TEXT DATA -# SEC-DEFAULT-NEXT: 2 .abcd 00000004 0000000000011008 TEXT DATA -# SEC-DEFAULT-NEXT: 3 .ad 00000004 000000000001100c TEXT DATA -# SEC-DEFAULT-NEXT: 4 .ag 00000004 0000000000011010 TEXT DATA +# SEC-DEFAULT-NEXT: 1 .text 00000008 00000000000000e8 TEXT DATA +# SEC-DEFAULT-NEXT: 2 .abcd 00000004 00000000000000f0 TEXT DATA +# SEC-DEFAULT-NEXT: 3 .ad 00000004 00000000000000f4 TEXT DATA +# SEC-DEFAULT-NEXT: 4 .ag 00000004 00000000000000f8 TEXT DATA # SEC-DEFAULT-NEXT: 5 .symtab 00000030 0000000000000000 # SEC-DEFAULT-NEXT: 6 .shstrtab 0000002f 0000000000000000 # SEC-DEFAULT-NEXT: 7 .strtab 00000008 0000000000000000 @@ -34,9 +34,9 @@ # SEC-ALL: Sections: # SEC-ALL-NEXT: Idx Name Size Address Type # SEC-ALL-NEXT: 0 00000000 0000000000000000 -# SEC-ALL-NEXT: 1 .text 0000000c 0000000000011000 TEXT DATA -# SEC-ALL-NEXT: 2 .ad 00000004 000000000001100c TEXT DATA -# SEC-ALL-NEXT: 3 .ag 00000004 0000000000011010 TEXT DATA +# SEC-ALL-NEXT: 1 .text 0000000c 00000000000000e8 TEXT DATA +# SEC-ALL-NEXT: 2 .ad 00000004 00000000000000f4 TEXT DATA +# SEC-ALL-NEXT: 3 .ag 00000004 00000000000000f8 TEXT DATA # SEC-ALL-NEXT: 4 .symtab 00000030 0000000000000000 # SEC-ALL-NEXT: 5 .shstrtab 00000029 0000000000000000 # SEC-ALL-NEXT: 6 .strtab 00000008 0000000000000000 @@ -50,7 +50,7 @@ # SEC-NO: Sections: # SEC-NO-NEXT: Idx Name Size Address Type # SEC-NO-NEXT: 0 00000000 0000000000000000 -# SEC-NO-NEXT: 1 .text 00000014 0000000000011000 TEXT DATA +# SEC-NO-NEXT: 1 .text 00000014 00000000000000e8 TEXT DATA # SEC-NO-NEXT: 2 .symtab 00000030 0000000000000000 # SEC-NO-NEXT: 3 .shstrtab 00000021 0000000000000000 # SEC-NO-NEXT: 4 .strtab 00000008 0000000000000000