[ELF] - Implemented basic location counter support.

[grimar]

Summary

This patch implements location counter support.
It also separates assign addresses for sections to assignAddressesScript() if it scipt exists.

Main testcase is test/ELF/linkerscript-locationcounter.s, It contains some work with location counter. It is basic now.
Implemented location counter assignment and '+' operations.

[ruiu]

Can you add a test to demonstrate what this patch will do? It doesn't have to be comprehensive at this moment though.

Also, please remove code to support all arithmetic operators but '+' and parentheses. You can start from supporting only '+' and add other operators later.

[grimar]

In D18499#384634, @ruiu wrote:

Can you add a test to demonstrate what this patch will do? It doesn't have to be comprehensive at this moment though.

Also, please remove code to support all arithmetic operators but '+' and parentheses. You can start from supporting only '+' and add other operators later.

Hi, test is already there actually, it is linkerscript-locationcounter.s - that is main demo for this patch.

[grimar]

In D18499#384634, @ruiu wrote:

Can you add a test to demonstrate what this patch will do? It doesn't have to be comprehensive at this moment though.

Also, please remove code to support all arithmetic operators but '+' and parentheses. You can start from supporting only '+' and add other operators later.

I can remove all operators except '!=', '?:', '/', '+' and parentheses because all of them are used in the test mentioned (linkerscript-locationcounter.s).
All cases except one that uses '*' I took from real bsd script, so it is important part of the test which demonstrates real live situations:

# 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

[ruiu]

I want you to remove all but '+' operator both from code and test so that we can focus on "core" part of this patch, which is a mechanism to set offsets to sections.

[grimar]

In D18499#385012, @ruiu wrote:

I want you to remove all but '+' operator both from code and test so that we can focus on "core" part of this patch, which is a mechanism to set offsets to sections.

Ok, I see. Will do.

[grimar]

Addressed Rui's request:

• Removed all operators except '+'.
• Removed testcase unrelated to core.

[ruiu]

ELF/LinkerScript.cpp

38–40

If there's an error, report that using error() and just return 0.

88–113

Since we don't have to handle operator precedence with '+', please remove this from this patch.

ELF/Writer.cpp

1315–1316

I don't understand this code. Why did you modify Load->H.p_flags?

1402–1404

Please do not add more code this function. Instead, I think you can split it for linker script and non-linker script, because if a linker script is present, all addresses are assigned according to the linker script.

[grimar]

• Addressed Rui's comments.

Notes: if D18591 be landed, huge amount of changes from here will gone.

[grimar]

ELF/LinkerScript.cpp

38–40

Done.

88–113

Done.

ELF/Writer.cpp

1315–1316

That was incorrect logic. I combined everything in one PT_LOAD, the logic I followed was described in D18317 summary but this desicion logic had issues and now I understood that.

We should just not do align first sections in loads to page boundaries if using script and can create as many PT_LOADs as requested.

1402–1404

Separated in D18591

[ruiu]

ELF/LinkerScript.cpp

39

Let's make Tokens const. I don't usually add const to every place which we can add const, but adding const improves readability in this case (to convey message that you are passing it as a reference just to avoid creating a copy of the vector.)

189

So, it looks like we need to call this function with section names in the same order as the section names appear in the linker script. Is this correct? If so, is that a good API?

It feel to me that this patch doesn't capture a correct abstraction of the writer and the linker script. Both LinkerScript and Writer have only partial knowledge of the section layout, and the interaction between them is not well defined. I'd like to see a different approach.

So, if a linker script has a SECTIONS command, the entire file layout is determined by the linker script, right? Can you pass the list of sections or the symbol table to LinkerScript and let it layout all the things?

[grimar]

ELF/LinkerScript.cpp

189

So, it looks like we need to call this function with section names in the same order as the section names appear in the linker script. Is this correct?

No, that not correct.

We are calling this when already have a list of Output sections and just need to assign addresses:

for (OutputSectionBase<ELFT> *Sec : OutputSections) {
...
    VA = Script->getSectionVA(Sec->getName(), VA);

It does not matter what is the order of sections in script at that time, because we already have a list of outputsections and just iterating over it.
Location counter can not be moved backward, so it can be moved only forward.
We push the VA to script because it uses is to calculate "." variable. It returns back updated location.

[ruiu]

ELF/LinkerScript.cpp

189

So you cannot call this function with a random order, right?

Let's say you have a linker script with this command.

SECTIONS {
  .data : { *(.data) }
  .text : { *(.text) }
}

And if you call getSectionVA(".text", VA) and then getSectionVA(".data", VA), they wouldn't return correct values, no?

[grimar]

ELF/LinkerScript.cpp

189

That is very wierd usecase of this patch. Why would you want to call it in that order ? How can this happen now ? It's just not what this patch intended to handle.

So your idea to have something like:

Script->getSectionVA(Sec->getName());

(without current VA, which we know only during actual assigninAddress() now).
Which will always return the VA no matter from where you are calling it. So we will not need assignAddressScript() at all then, almost, as we will already have all sections layouted.

[ruiu]

ELF/LinkerScript.cpp

189

Yes, it is weird, but that is what I meant.

This function has a hidden state and rely on the caller to call it in some "correct" order. In that sense the caller and the callee are coupled fairly tightly. That is not necessarily be NG, but as an interface between the linker script and the writer, that is probably too tight. I want a simpler API.

[grimar]

ELF/LinkerScript.cpp

189

I meant it is wierd for this patch, in general that is just absolutely different approach, which is also ok.
Ok, I understood your point, will try to look closer how to do what you want tomorrow. Have a good day.

[grimar]

• Addressed Rui's implementation suggestions.

[grimar]

ELF/LinkerScript.cpp

189

I rewrote the logic and now it seems it works like you wanted (at least it has Script->getSectionVA(StringRef Name) method now).

So this is a new prototype, not well polished, but shows the consept. I don't like separate dummies sections processing, but have not good idea now. Will think about it.

[grimar]

ELF/LinkerScript.cpp

176

This will not be here (ends), I am going to prepare patch to move that like was suggested.

ELF/Writer.cpp

1445

This also probably can be moved out for all 3 assign*() methods.

[grimar]

ELF/LinkerScript.h

71

And also not sure about that place. I did not use reference because I need vector to be copied. Is it ok or better to do copy manually inside ?

[ruiu]

This is I think better, although it needs brush-ups in terms of coding style.

ELF/Writer.cpp

1449–1464

This is very similar to the code in assignAddresses.

[grimar]

• Cleaned up the code.
• Addressed review comment.

[grimar]

ELF/Writer.cpp

1442

This will gone if D18691 be landed.

1449–1464

Fixed.

[grimar]

ELF/LinkerScript.cpp

574

I will put

if (Node.Args.empty())
  error(...)

here in next iteration. We cannot have something like:

. =;

And it is also assumed in code that Args not empty.

[grimar]

• Rebased.

[ruiu]

ELF/Writer.cpp

1448

Why do we still have to call setVA from the Writer although I think the point of this patch is to do it in the linker script?

1452–1456

Do you still need this?

[ruiu]

ELF/LinkerScript.h

71

Why do you need this function? If the linker script directly assign VAs to sections, we don't need this.

[grimar]

• Addressed review comments.

ELF/LinkerScript.h

71

If so - yes.

ELF/Writer.cpp

1448

Misunderstanding :) I thought you want to have Script->getSecVA() method.
Without that all life is easier of course.
Removed whole method.

1452–1456

Nope. Removed.

[ruiu]

ELF/LinkerScript.cpp

36

It seems that we don't need this class because this class has only one member, LocCounter and you always reset LocCounter before calling evaluate. This class can just be a function that takes the current VA and an expression and returns a new VA.

72

It is better to move this variable inside LinkerScript.

109

Does this have to be a lambda?

125

Why do you have to remove the element here?

280–283

The concept of dummy sections seems a bit confusing. Could you improve it?

ELF/LinkerScript.h

52–54

I wouldn't use the same variable for completely different purposes. I'd define two fields, Expr and SectionName, instead.

[grimar]

ELF/LinkerScript.cpp

109

Please see answer in below comment.

125

I need to visit all output sections to assign addresses for each.
Script can mention only some of them.
There were 2 choices I saw:

1. Make this lambda and do 2 iterations. First iteration visits everything that was directly mentioned in script. During that it removes the sections if found from global list. After that we will have all unvisited sections in this global list. Then second iteration visits them all.

That gives 2 iterations, but complexity is O(n) in total.

2. In this variant it is possible to insert all sections that were not mentioned in script to Locations list at the begining of method and avoid using lambda. That would be one loop. Problem here that is that if we have OutputSectionBase list and have Locations lists then how to find those sections for which LocationNode was not created to vizit ?

That would be something like (pseudocode):

for (OutputSectionBase<ELFT> *Sec : S) {
  if (S NOT IN Locations) {
    Locations.push_back(create location for S);
  }
}

That is O(N^2) part of code that can be inserted at the begining of this method, that can help to get rid of labmda and do all in one iteration.

[ruiu]

ELF/LinkerScript.cpp

125

This is a bit too convoluted. It'd need a few trial-and-errors, but it should be able to be written in a straightforward way. I'd probably start making this lambda a separate function.

621

Exist -> Exists

640

Remove S.

ELF/LinkerScript.h

48

I'd make this a enum class and rename members as shown below.

LocNodeType -> Command
LocSet -> Expr
LocOutSet -> Section

ELF/Writer.cpp

223

Let's name this assignAddresses for consistency with the Writer.

[grimar]

Ok, thank you for review, I`ll address this all later today/tomorrow I think (except dummies).

ELF/LinkerScript.cpp

280–283

I guess you mean not only for this patch but whole dummies approach, right ?
We can probably just get rid of them, like we had before ?

[ruiu]

ELF/LinkerScript.cpp

280–283

Yes, I'm talking about the approach itself. I'm not sure what you mean by "just get rid of them" (can we do that? I think we need some replacements for them,) but the point is that the code here for the dummy sections seem a bit too complex, so it needs to be improved.

[grimar]

ELF/LinkerScript.cpp

280–283

Ok. When I say "get rid" I mean that some time ago they were not sections. So we definetely can do that and just the question "how to do this better now ?" left. I`ll try to suggest some patch to change that.

[grimar]

ELF/LinkerScript.cpp

280–283

So, my suggestion patch about dummies sections is D18743.

[grimar]

I`ll update/rebase this as soon as D18743 be landed (If will). The last one can help to simplify the code of this I think.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

36

Done.

72

Since that class not exist, variable also not exist anymore.

125

Done. Made lambda as separate function + refactored code to have only one iteration.

621

Done.

640

Done.

ELF/LinkerScript.h

48

Done.

52–54

Done.

ELF/Writer.cpp

223

Done.

[grimar]

• Rebased

[ruiu]

ELF/LinkerScript.cpp

544

I think you should remove addLocation function and directly add new elements to Locations vector since you intentionally merge two different control flow into one function and dispatch again using the first argument. That's just confusing.

ELF/LinkerScript.h

48

Let's make this an enum class because it currently adds "Section" and "Expr" to lld::elf namespace.

49

Add blank line before this struct definition.

78

Arg -> Args

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

544

Removed.

ELF/LinkerScript.h

48

Done.

49

Done.

78

There is no such method anymore.

[ruiu]

ELF/LinkerScript.cpp

93–107

Define this method

uint64_t getInteger(StringRef S) {
  uint64_t V;
  if (S.getAsInteger(0, V)) {
    setError("malformed number: " + V);
    return 0;
 }
  retrurn V;
}

Then you can simplify this to

StringRef Tok = Tokens[I];
if (Tok == ".")
  Result += LocCounter;
else
  Result += getInteger(Tok);

105

Are you aware of the fact that StringMap copies keys? Maybe DenseMap is more efficient because it doesn't copy StringRefs?

124

Needs () around &.

142

This function seems a bit too complicated. This function construct temporary data to feed to setSectionsAddresses. Do we really need to do that? Isn't there any way to make it simpler?

165

Flip the condition and use early continue.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

93–107

Done.
Btw, few iterations ago I had code like this.
http://reviews.llvm.org/D18499?id=52399#inline-156527
Looks when you requested to make a single function from whole class I understood this too straightforward (combined exactly into one function) :)

105

I missed that fact. Thanks for pointing on that.
There is no such method and variable anymore.

124

Done.

142

Reimplemented in much more straighforward way.

165

There is no such code anymore.

[grimar]

ELF/LinkerScript.cpp

105

At the same time if we talk about perfomance then I think most narrow place is lookup and not creation of container.
So I can guess StringMap still was faster since it does not recompute hash during lookup.
I didn't check since code was cut off.

[ruiu]

ELF/LinkerScript.cpp

108–109

Although it is technically correct that what we are doing here is different from the doc, I don't think it necessarily mean it needs to be marked as "FIXME". My impression is that if you control section layout using linker scripts, you need to give complete layout. So please remove "FIXME" label from this comment and just state the fact:

Orphan sections are sections present in the input files which are not explicitly placed into the output file by the linker script. We place orphan sections at end of file. Other linkers places them using some heuristics as described in https://sourceware.org/binutils/docs/ld/Orphan-Sections.html#Orphan-Sections.

ELF/LinkerScript.h

71

fixUp -> fixup

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

108–109

My impression is that if you control section layout using linker scripts, you need to give complete layout.

Perfect, done ! I was thinking about the same often. For me it was always a bit wierd that linker do something on his own when script is given. That complicates the whole things at the same time privides no strict rules, but only heuristics, what can be confusing.
I was not sure that is acceptable to change that behavior though.

ELF/LinkerScript.h

71

Done.

[ruiu]

Please update the commit message. This is not a prototype even though its feature is limited. This is a patch that will be committed as part of the linker.

ELF/LinkerScript.cpp

82

You probably have to do this

error("malformed number: " + Twine(V))

125

Call fixupLocations here instead of exporting it and call it from the Writer.

139–140

This shouldn't happen now, no?

648–655

Remove.

ELF/LinkerScript.h

70–71

Make it private.

[grimar]

• Addressed review comment.

ELF/LinkerScript.cpp

82

I think what I want is:

error("malformed number: " + S);

Updated testcase.

125

Done.

139–140

This can happen. Imagine asm code:

.global _start
_start:
 nop

and script that contains section description, but this section is absent in code above:

SECTIONS {
 .stub : { *(.stub) }
}

Since there is no such section, OutputSections list will not contain it, but location node will still be created and needs to be skipped then.

648–655

Done.

ELF/LinkerScript.h

70–71

Done.

[grimar]

About D19107 and SectionOrder vector.
What about landing this and eliminating the SectionOrder at all ?

At fact when we have Locations structure, SectionOrder is just a subset. We can use
Locations instead to sort sections in compareSections.

The only problem then - that fixupLocations() should be called much earlier then.
I think previous iteration was better for such purposes.

[grimar]

• Fixed clang warning.

[ruiu]

LGTM

[grimar]

In D18499#402693, @ruiu wrote:

LGTM

Thank you for all these reviews of that !

ELF/LinkerScript.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
+class LocCounterEvaluator;
 class ScriptParser;
 template <class ELFT> class InputSectionBase;
+template <class ELFT> class OutputSectionBase;
 
 // This class represents each rule in SECTIONS command.
 class SectionRule {
 public:
   SectionRule(StringRef D, StringRef S, bool Keep)
       : Dest(D), Keep(Keep), SectionPattern(S) {}
 
   // Returns true if S should be in Dest section.
   template <class ELFT> bool match(InputSectionBase<ELFT> *S);
 
   StringRef Dest;
 
   // KEEP command saves unused sections even if --gc-sections is specified.
   bool Keep = false;
 
 private:
   StringRef SectionPattern;
 };
 
+// This enum represents what we can observe in SECTIONS tag of script:
+// LocSet is a location counter change, like ". = . + 0x1000"
+// LocOutSec is a description of output section, like ".data :..."
+enum LocNodeType { LocSet, LocOutSec };
+struct LocationNode {
+  LocNodeType Type;
+
+  // For LocSet this keeps list of tokens to evaluate location.
+  // For LocOutSec first element is a output section name.
+  std::vector<StringRef> Args;
+};
+
 // This is a runner of the linker script.
 class LinkerScript {
   friend class ScriptParser;
 
 public:
   // Parses a linker script. Calling this function may update
   // this object and Config.
   void read(MemoryBufferRef MB);
 
   template <class ELFT> StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   template <class ELFT> bool isDiscarded(InputSectionBase<ELFT> *S);
   template <class ELFT> bool shouldKeep(InputSectionBase<ELFT> *S);
+  template <class ELFT> void doLayout(std::vector<OutputSectionBase<ELFT> *> S);
+  uint64_t getSecVA(StringRef Name);
+  uint64_t getDummySecVA(size_t Ndx);
   int compareSections(StringRef A, StringRef B);
 
+  bool Exist = false;
+
 private:
+  LocationNode &addLocation(LocNodeType Type, std::vector<StringRef> Arg);
   template <class ELFT> SectionRule *find(InputSectionBase<ELFT> *S);
 
   // SECTIONS commands.
   std::vector<SectionRule> Sections;
 
   // Output sections are sorted by this order.
   std::vector<StringRef> SectionOrder;
 
   // Section fill attribute for each section.
   llvm::StringMap<std::vector<uint8_t>> Filler;
 
+  // Used to assign addresses to sections.
+  std::vector<LocationNode> Locations;
+
+  // Output section name -> VA.
+  std::vector<std::pair<StringRef, uint64_t>> SecVA;
+
   llvm::BumpPtrAllocator Alloc;
 };
 
 extern LinkerScript *Script;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

 // Results are written to Driver or Config object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LinkerScript.h"
 #include "Config.h"
 #include "Driver.h"
 #include "InputSection.h"
+#include "OutputSections.h"
 #include "SymbolTable.h"
+#include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
+using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::elf;
 
+unsigned dummySectionsNum();
+
+class elf::LocCounterEvaluator {
+public:
+  void setLocationCounter(uint64_t VA) { LocCounter = VA; }
+
+  // Evaluates the expression given by list of tokens.
+  uint64_t evaluate(std::vector<StringRef> &Tokens) {
+    uint64_t Result = 0;
+    for (size_t I = 0, E = Tokens.size(); I < E; ++I) {
+      // Each second token should be '+' as this is the
+      // only operator we support now.
+      if (I % 2 == 1) {
+        if (Tokens[I] == "+")
+          continue;
+        error("error in location counter expression");
+        return 0;
+      }
+      Result += getValue(Tokens[I]);
+    }
+    return Result;
+  }
+
+  uint64_t getValue(StringRef V) {
+    if (V == ".")
+      return LocCounter;
+    uint64_t Val;
+    if (!V.getAsInteger(0, Val))
+      return Val;
+    error("undeclared variable " + V);
+    return 0;
+  }
+
+protected:
+  uint64_t LocCounter = 0;
+};
+
 LinkerScript *elf::Script;
+LocCounterEvaluator Eval;
+
+LocationNode &LinkerScript::addLocation(LocNodeType Type,
+                                        std::vector<StringRef> Arg) {
+  return *Locations.insert(Locations.end(), {Type, Arg});
+}
 
 template <class ELFT>
 SectionRule *LinkerScript::find(InputSectionBase<ELFT> *S) {
   for (SectionRule &R : Sections)
     if (R.match(S))
       return &R;
   return nullptr;
 }
 
 template <class ELFT>
 StringRef LinkerScript::getOutputSection(InputSectionBase<ELFT> *S) {
   SectionRule *R = find(S);
   return R ? R->Dest : "";
 }
 
 template <class ELFT>
 bool LinkerScript::isDiscarded(InputSectionBase<ELFT> *S) {
   return getOutputSection(S) == "/DISCARD/";
 }
 
 template <class ELFT> bool LinkerScript::shouldKeep(InputSectionBase<ELFT> *S) {
   SectionRule *R = find(S);
   return R && R->Keep;
 }
 
+uint64_t LinkerScript::getSecVA(StringRef Name) {
+  auto I = std::find_if(
+      SecVA.begin(), SecVA.end(),
+      [&](std::pair<StringRef, uint64_t> &P) { return P.first == Name; });
+  return I->second;
+}
+
+// Dummies has empty name and therefore requires special handling.
+uint64_t LinkerScript::getDummySecVA(size_t Ndx) { return SecVA[Ndx].second; }
+
+template <class ELFT>
+void LinkerScript::doLayout(std::vector<OutputSectionBase<ELFT> *> S) {
+  typedef typename ELFT::uint uintX_t;
+
+  uintX_t ThreadBssOffset = 0;
+  uintX_t VA = 0;
+  auto VisitLocations = [&](std::vector<LocationNode> &Loc) {
+    for (LocationNode &Node : Loc) {
+      if (Node.Type == LocSet) {
+        Eval.setLocationCounter(VA);
+        VA = Eval.evaluate(Node.Args);
+        continue;
+      }
+
+      StringRef Name = Node.Args[0];
+      auto I =
+          std::find_if(S.begin(), S.end(), [&](OutputSectionBase<ELFT> *Sec) {
+            return Sec->getName() == Name;
+          });
+      if (I == S.end())
+        continue;
+
+      OutputSectionBase<ELFT> *Sec = *I;
+      S.erase(I);
+
+      uintX_t Align = Sec->getAlign();
+      if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS) {
+        uintX_t TVA = VA + ThreadBssOffset;
+        TVA = alignTo(TVA, Align);
+        SecVA.push_back({Name, TVA});
+        ThreadBssOffset = TVA - VA + Sec->getSize();
+        continue;
+      }
+
+      if (Sec->getFlags() & SHF_ALLOC) {
+        VA = alignTo(VA, Align);
+        SecVA.push_back({Name, VA});
+        VA += Sec->getSize();
+        continue;
+      }
+
+      SecVA.push_back({Name, 0});
+    }
+  };
+
+  // At first assign addresses to sections directly specified in linkerscript.
+  VisitLocations(Locations);
+
+  // Now create list of unvisited sections, that were not mentioned in script,
+  // but exist in output sections list. They will be put after all others,
+  // visit them to assign VA's.
+  std::vector<LocationNode> Left;
+  for (OutputSectionBase<ELFT> *Sec : S)
+    Left.push_back({LocOutSec, {Sec->getName()}});
+  VisitLocations(Left);
+}
+
 ArrayRef<uint8_t> LinkerScript::getFiller(StringRef Name) {
   auto I = Filler.find(Name);
   if (I == Filler.end())
     return {};
   return I->second;
 }
 
 // A compartor to sort output sections. Returns -1 or 1 if both
 // A and B are mentioned in linker scripts. Otherwise, returns 0
 // to use the default rule which is implemented in Writer.cpp.
 int LinkerScript::compareSections(StringRef A, StringRef B) {
   auto E = SectionOrder.end();
   auto I = std::find(SectionOrder.begin(), E, A);
   auto J = std::find(SectionOrder.begin(), E, B);
   if (I == E || J == E)
     return 0;
   return I < J ? -1 : 1;
 }
 
 // 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.
 static bool matchStr(StringRef S, StringRef T) {
   for (;;) {
     if (S.empty())
       return T.empty();
     if (S[0] == '*') {
       S = S.substr(1);
private:
   void readInclude();
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readSearchDir();
   void readSections();
 
+  void readLocationCounterValue();
   void readOutputSectionDescription();
   void readSectionPatterns(StringRef OutSec, bool Keep);
 
   size_t getPos();
   std::vector<uint8_t> parseHex(StringRef S);
 
   StringSaver Saver;
   StringRef Input;
const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
     {"OUTPUT", &ScriptParser::readOutput},
     {"OUTPUT_ARCH", &ScriptParser::readOutputArch},
     {"OUTPUT_FORMAT", &ScriptParser::readOutputFormat},
     {"SEARCH_DIR", &ScriptParser::readSearchDir},
     {"SECTIONS", &ScriptParser::readSections},
     {";", &ScriptParser::readNothing}};
 
 void ScriptParser::run() {
+  // Dummies sections has empty name, but we still should add
+  // and theat them as normal ouput sections.
+  for (unsigned I = 0; I < dummySectionsNum(); ++I)
+    Script->addLocation(LocOutSec, {""});
+
   while (!atEOF()) {
     StringRef Tok = next();
     if (Handler Fn = Cmd.lookup(Tok))
       (this->*Fn)();
     else
       setError("unknown directive: " + Tok);
   }
 }

 void ScriptParser::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 void ScriptParser::readSections() {
   expect("{");
-  while (!Error && !skip("}"))
+  while (!Error && !skip("}")) {
+    StringRef Tok = peek();
+    if (Tok == ".")
+      readLocationCounterValue();
+    else
       readOutputSectionDescription();
   }
+}
 
 void ScriptParser::readSectionPatterns(StringRef OutSec, bool Keep) {
   expect("(");
   while (!Error && !skip(")"))
     Script->Sections.emplace_back(OutSec, next(), Keep);
 }
 
 // Returns the current line number.
 size_t ScriptParser::getPos() {
   if (Pos == 0)
     return 1;
   const char *Begin = Input.data();
   const char *Tok = Tokens[Pos - 1].data();
   return StringRef(Begin, Tok - Begin).count('\n') + 1;
 }
 
 std::vector<uint8_t> ScriptParser::parseHex(StringRef S) {
   std::vector<uint8_t> Hex;
   while (!S.empty()) {
     StringRef B = S.substr(0, 2);
     S = S.substr(2);
     uint8_t H;
     if (B.getAsInteger(16, H)) {
       setError("not a hexadecimal value: " + B);
       return {};
     }
     Hex.push_back(H);
   }
   return Hex;
 }
 
+void ScriptParser::readLocationCounterValue() {
+  expect(".");
+  expect("=");
+  LocationNode &Node = Script->addLocation(LocSet, {});
+  while (!Error) {
+    StringRef Tok = next();
+    if (Tok == ";")
+      break;
+    Node.Args.push_back(Tok);
+  }
+}
+
 void ScriptParser::readOutputSectionDescription() {
   StringRef OutSec = next();
   Script->SectionOrder.push_back(OutSec);
+  Script->addLocation(LocOutSec, {OutSec});
   expect(":");
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       readSectionPatterns(OutSec, false);
     } else if (Tok == "KEEP") {
       expect("(");
if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }
 
 // Entry point. The other functions or classes are private to this file.
 void LinkerScript::read(MemoryBufferRef MB) {
   StringRef Path = MB.getBufferIdentifier();
   ScriptParser(&Alloc, MB.getBuffer(), isUnderSysroot(Path)).run();
+  Exist = true;
 }
 
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF32LE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF32BE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF64LE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF64BE> *);
 
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF32LE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF32BE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF64LE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF64BE> *);
 
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF32LE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF32BE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF64LE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF64BE> *);
+
+template void
+LinkerScript::doLayout(std::vector<OutputSectionBase<ELF32LE> *> S);
+template void
+LinkerScript::doLayout(std::vector<OutputSectionBase<ELF32BE> *> S);
+template void
+LinkerScript::doLayout(std::vector<OutputSectionBase<ELF64LE> *> S);
+template void
+LinkerScript::doLayout(std::vector<OutputSectionBase<ELF64BE> *> S);

ELF/Writer.cpp

private:
   void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const RelTy *> Rels);
 
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void createPhdrs();
   void assignAddresses();
   void assignAddressesRelocatable();
+  void assignAddressesScript();
   void assignPhdrs();
   void fixSectionAlignments();
   void fixAbsoluteSymbols();
   bool openFile();
   void writeHeader();
   void writeSections();
   void writeBuildId();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
   if (!createSections())
     return;
   if (!Config->Relocatable) {
     createPhdrs();
     fixSectionAlignments();
-    assignAddresses();
-  } else {
-    assignAddressesRelocatable();
   }
+
+  if (Script->Exist)
+    assignAddressesScript();
+  else if (Config->Relocatable)
+    assignAddressesRelocatable();
+  else
+    assignAddresses();
+
   fixAbsoluteSymbols();
   if (!openFile())
     return;
   writeHeader();
   writeSections();
   writeBuildId();
   if (HasError)
     return;
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
 
     if (!needsPtLoad<ELFT>(Sec))
       continue;
 
     // If flags changed then we want new load segment.
     uintX_t NewFlags = toPhdrFlags(Sec->getFlags());
     if (Flags != NewFlags) {
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
     }
 
     AddSec(*Load, Sec);
 
     if (isRelroSection(Sec))
       AddSec(RelRo, Sec);
     if (Sec->getType() == SHT_NOTE)
       AddSec(Note, Sec);
   }
template <class ELFT> void Writer<ELFT>::assignAddressesRelocatable() {
   Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
   uintX_t FileOff = 0;
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     FileOff = fixFileOff(FileOff, Sec->getAlign(), Sec);
   SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 }
 
 // Visits all headers in PhdrTable and assigns the adresses to
 // the output sections. Also creates common and special headers.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
   size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
   Out<ELFT>::ProgramHeaders->setSize(PhdrSize);
 
   uintX_t ThreadBssOffset = 0;
   uintX_t VA = Target->getVAStart();
   uintX_t FileOff = 0;
 
template <class ELFT> void Writer<ELFT>::assignAddresses() {
 
   // Add space for section headers.
   SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
   assignPhdrs();
 }
 
+template <class ELFT> void Writer<ELFT>::assignAddressesScript() {
+  Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
+  size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
+  Out<ELFT>::ProgramHeaders->setSize(PhdrSize);
+
+  Script->doLayout(OutputSections);
+
+  uintX_t FileOff = 0;
+  size_t I = 0;
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    FileOff = fixFileOff(FileOff, Sec->getAlign(), Sec);
+    StringRef Name = Sec->getName();
+    uintX_t VA = (I < dummySectionsNum()) ? (uintX_t)Script->getDummySecVA(I)
+                                          : (uintX_t)Script->getSecVA(Name);
+    Sec->setVA(VA);
+    ++I;
+  }
+
+  // Add space for section headers.
+  SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
+  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+
+  assignPhdrs();
+}
+
 template <class ELFT> void Writer<ELFT>::assignPhdrs() {
   for (Phdr &PHdr : Phdrs) {
     Elf_Phdr &H = PHdr.H;
     if (PHdr.First) {
       OutputSectionBase<ELFT> *Last = PHdr.Last;
       H.p_filesz = Last->getFileOff() - PHdr.First->getFileOff();
       if (Last->getType() != SHT_NOBITS)
         H.p_filesz += Last->getSize();
       H.p_memsz = Last->getVA() + Last->getSize() - PHdr.First->getVA();

test/ELF/end.s

 
 // NOBSS: Sections [
 // NOBSS:     Name: .data
 // NOBSS-NEXT:     Type:
 // NOBSS-NEXT:     Flags [
 // NOBSS-NEXT:       SHF_ALLOC
 // NOBSS-NEXT:       SHF_WRITE
 // NOBSS-NEXT:     ]
-// NOBSS-NEXT:     Address: 0x12000
+// NOBSS-NEXT:     Address: 0x159
 // NOBSS-NEXT:     Offset:
 // NOBSS-NEXT:     Size: 2
 // NOBSS: ]
 // NOBSS: Symbols [
 // NOBSS:     Name: _end
-// NOBSS-NEXT:     Value: 0x12002
+// NOBSS-NEXT:     Value: 0x15B
 // NOBSS: ]
 
 // If the layout of the sections is changed, "_end" should point to the end of allocated address space.
 // RUN: echo "SECTIONS { \
 // RUN:          .bss : { *(.bss) } \
 // RUN:          .data : { *(.data) } \
 // RUN:          .text : { *(.text) } }" > %t.script
 // RUN: ld.lld %t.o --script %t.script -o %t
 // RUN: llvm-readobj -sections -symbols %t | FileCheck %s --check-prefix=TEXTATEND
 
 // TEXTATEND: Sections [
 // TEXTATEND:     Name: .text
 // TEXTATEND-NEXT:     Type:
 // TEXTATEND-NEXT:     Flags [
 // TEXTATEND-NEXT:       SHF_ALLOC
 // TEXTATEND-NEXT:       SHF_EXECINSTR
 // TEXTATEND-NEXT:     ]
-// TEXTATEND-NEXT:     Address: 0x12000
+// TEXTATEND-NEXT:     Address: 0x160
 // TEXTATEND-NEXT:     Offset:
 // TEXTATEND-NEXT:     Size: 1
 // TEXTATEND: ]
 // TEXTATEND: Symbols [
 // TEXTATEND:     Name: _end
-// TEXTATEND-NEXT:     Value: 0x12001
+// TEXTATEND-NEXT:     Value: 0x161
 // TEXTATEND: ]
 
 .global _start,_end
 .text
 _start:
     nop
 .data
     .word 1
 .bss
     .space 6

test/ELF/linkerscript-locationcounter.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { \
+# RUN:  . = 0x12341; \
+# RUN:  .data : { *(.data) } \
+# RUN:  . = . + 0x10000; \
+# RUN:  .text : { *(.text) } \
+# 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: 0x158
+# 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: 0x2234C
+# CHECK-NEXT:     Offset: 0x160
+# CHECK-NEXT:     Size: 1
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 4
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+
+.globl _start;
+_start:
+nop
+
+.section .data
+.quad 0
+

test/ELF/linkerscript-sections-keep.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## First check that section "keep" is garbage collected without using KEEP
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { *(.keep) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECGC %s
 # 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 0000000000000158 TEXT DATA
+# SECGC-NEXT:   2 .temp         00000004 000000000000015f DATA
 
 ## Now apply KEEP command to preserve the section.
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECNOGC %s
 # 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 0000000000000158 TEXT DATA
+# SECNOGC-NEXT:   2 .keep         00000004 000000000000015f DATA
+# SECNOGC-NEXT:   3 .temp         00000004 0000000000000163 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
 ## KEEP is the first in order then section is NOT collected.
 # RUN: echo "SECTIONS { \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .nokeep : { *(.keep) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=KEEP-AT-FIRST %s
 # 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 0000000000000120 DATA
+# KEEP-AT-FIRST-NEXT:   2 .temp         00000004 0000000000000124 DATA
+# KEEP-AT-FIRST-NEXT:   3 .text         00000007 0000000000000128 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
 
 ## The same, but now section without KEEP is at first place.
 ## It will be collected then.
 ## This test checks that lld behavior is equal to gold linker.
 ## ld.bfd has different behavior, it prevents the section .keep
 ## from collecting in this case either.
 # RUN: echo "SECTIONS { \
 # RUN:  .nokeep : { *(.keep) } \
 # RUN:  .keep : { KEEP(*(.keep)) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=KEEP-AT-SECOND %s
 # 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 0000000000000120 DATA
+# KEEP-AT-SECOND-NEXT:   2 .text         00000007 0000000000000124 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
 
 .global _start
 _start:
  mov temp, %eax
 
 .section .keep, "a"
 keep:
  .long 1
 
 .section .temp, "a"
 temp:
  .long 2

test/ELF/linkerscript-va.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | FileCheck %s
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT:   0               00000000 0000000000000000
+# CHECK-NEXT:   1 .foo          00000004 0000000000000120 DATA
+# CHECK-NEXT:   2 .boo          00000004 0000000000000124 DATA
+# CHECK-NEXT:   3 .text         00000001 0000000000000128 TEXT DATA
+
+.global _start
+_start:
+ nop
+
+.section .foo, "a"
+foo:
+ .long 0
+
+.section .boo, "a"
+boo:
+ .long 0

test/ELF/wildcards.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Default case: abc and abx included in text.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .abx) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 # 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 0000000000000120 TEXT DATA
+# SEC-DEFAULT-NEXT:   2 .abcd         00000004 0000000000000128 TEXT DATA
+# SEC-DEFAULT-NEXT:   3 .ad           00000004 000000000000012c TEXT DATA
+# SEC-DEFAULT-NEXT:   4 .ag           00000004 0000000000000130 TEXT DATA
 # SEC-DEFAULT-NEXT:   5 .symtab       00000030 0000000000000000
 # SEC-DEFAULT-NEXT:   6 .shstrtab     0000002f 0000000000000000
 # SEC-DEFAULT-NEXT:   7 .strtab       00000008 0000000000000000
 
 ## Now replace the symbol with '?' and check that results are the same.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab?) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 ## Now see how replacing '?' with '*' will consume whole abcd.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-ALL %s
 # 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 0000000000000120 TEXT DATA
+# SEC-ALL-NEXT:   2 .ad           00000004 000000000000012c TEXT DATA
+# SEC-ALL-NEXT:   3 .ag           00000004 0000000000000130 TEXT DATA
 # SEC-ALL-NEXT:   4 .symtab       00000030 0000000000000000
 # SEC-ALL-NEXT:   5 .shstrtab     00000029 0000000000000000
 # SEC-ALL-NEXT:   6 .strtab       00000008 0000000000000000
 
 ## All sections started with .a are merged.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.a*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-NO %s
 # 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 0000000000000120 TEXT DATA
 # SEC-NO-NEXT:   2 .symtab       00000030 0000000000000000
 # SEC-NO-NEXT:   3 .shstrtab     00000021 0000000000000000
 # SEC-NO-NEXT:   4 .strtab       00000008 0000000000000000
 
 .text
 .section .abc,"ax",@progbits
 .long 0