[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

35–37 ↗

(On Diff #51880)

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

85–110 ↗

(On Diff #51880)

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

ELF/Writer.cpp

1271–1273 ↗

(On Diff #51880)

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

1335–1337 ↗

(On Diff #51880)

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

35–37 ↗

(On Diff #51880)

Done.

85–110 ↗

(On Diff #51880)

Done.

ELF/Writer.cpp

1271–1273 ↗

(On Diff #51880)

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.

1335–1337 ↗

(On Diff #51880)

Separated in D18591

[ruiu]

ELF/LinkerScript.cpp

36 ↗

(On Diff #52045)

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.)

113 ↗

(On Diff #52045)

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

113 ↗

(On Diff #52045)

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

113 ↗

(On Diff #52045)

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

113 ↗

(On Diff #52045)

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

113 ↗

(On Diff #52045)

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

113 ↗

(On Diff #52045)

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

193 ↗

(On Diff #52217)

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

172 ↗

(On Diff #52217)

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

ELF/Writer.cpp

1417 ↗

(On Diff #52217)

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

[grimar]

ELF/LinkerScript.h

71 ↗

(On Diff #52217)

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

1421–1436 ↗

(On Diff #52217)

This is very similar to the code in assignAddresses.

[grimar]

• Cleaned up the code.
• Addressed review comment.

[grimar]

ELF/Writer.cpp

1442 ↗

(On Diff #52364)

This will gone if D18691 be landed.

1421–1436 ↗

(On Diff #52217)

Fixed.

[grimar]

ELF/LinkerScript.cpp

574 ↗

(On Diff #52364)

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

1417 ↗

(On Diff #52394)

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?

1421–1425 ↗

(On Diff #52394)

Do you still need this?

[ruiu]

ELF/LinkerScript.h

71 ↗

(On Diff #52364)

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 ↗

(On Diff #52394)

If so - yes.

ELF/Writer.cpp

1417 ↗

(On Diff #52394)

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

1421–1425 ↗

(On Diff #52394)

Nope. Removed.

[ruiu]

ELF/LinkerScript.cpp

36 ↗

(On Diff #52399)

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 ↗

(On Diff #52399)

It is better to move this variable inside LinkerScript.

109 ↗

(On Diff #52399)

Does this have to be a lambda?

125 ↗

(On Diff #52399)

Why do you have to remove the element here?

267–270 ↗

(On Diff #52399)

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

ELF/LinkerScript.h

52–54 ↗

(On Diff #52399)

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 ↗

(On Diff #52399)

Please see answer in below comment.

125 ↗

(On Diff #52399)

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 ↗

(On Diff #52399)

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.

610 ↗

(On Diff #52399)

Exist -> Exists

629 ↗

(On Diff #52399)

Remove S.

ELF/LinkerScript.h

48 ↗

(On Diff #52399)

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

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

ELF/Writer.cpp

228 ↗

(On Diff #52399)

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

267–270 ↗

(On Diff #52399)

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

267–270 ↗

(On Diff #52399)

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

267–270 ↗

(On Diff #52399)

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

267–270 ↗

(On Diff #52399)

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 ↗

(On Diff #52399)

Done.

72 ↗

(On Diff #52399)

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

125 ↗

(On Diff #52399)

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

610 ↗

(On Diff #52399)

Done.

629 ↗

(On Diff #52399)

Done.

ELF/LinkerScript.h

48 ↗

(On Diff #52399)

Done.

52–54 ↗

(On Diff #52399)

Done.

ELF/Writer.cpp

228 ↗

(On Diff #52399)

Done.

[grimar]

• Rebased

[ruiu]

ELF/LinkerScript.cpp

424 ↗

(On Diff #53242)

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

47 ↗

(On Diff #53242)

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

48 ↗

(On Diff #53242)

Add blank line before this struct definition.

74 ↗

(On Diff #53242)

Arg -> Args

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

424 ↗

(On Diff #53242)

Removed.

ELF/LinkerScript.h

47 ↗

(On Diff #53242)

Done.

48 ↗

(On Diff #53242)

Done.

74 ↗

(On Diff #53242)

There is no such method anymore.

[ruiu]

ELF/LinkerScript.cpp

51–65 ↗

(On Diff #53374)

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);

94 ↗

(On Diff #53374)

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

113 ↗

(On Diff #53374)

Needs () around &.

131 ↗

(On Diff #53374)

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?

154 ↗

(On Diff #53374)

Flip the condition and use early continue.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

51–65 ↗

(On Diff #53374)

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) :)

94 ↗

(On Diff #53374)

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

113 ↗

(On Diff #53374)

Done.

131 ↗

(On Diff #53374)

Reimplemented in much more straighforward way.

154 ↗

(On Diff #53374)

There is no such code anymore.

[grimar]

ELF/LinkerScript.cpp

95 ↗

(On Diff #53563)

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

98–99 ↗

(On Diff #53563)

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

69 ↗

(On Diff #53563)

fixUp -> fixup

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

98–99 ↗

(On Diff #53563)

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

69 ↗

(On Diff #53563)

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

40 ↗

(On Diff #53682)

You probably have to do this

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

115 ↗

(On Diff #53682)

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

129–130 ↗

(On Diff #53682)

This shouldn't happen now, no?

485–492 ↗

(On Diff #53682)

Remove.

ELF/LinkerScript.h

68–69 ↗

(On Diff #53682)

Make it private.

[grimar]

• Addressed review comment.

ELF/LinkerScript.cpp

40 ↗

(On Diff #53682)

I think what I want is:

error("malformed number: " + S);

Updated testcase.

115 ↗

(On Diff #53682)

Done.

129–130 ↗

(On Diff #53682)

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.

485–492 ↗

(On Diff #53682)

Done.

ELF/LinkerScript.h

68–69 ↗

(On Diff #53682)

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 !

lld/trunk/ELF/LinkerScript.h

 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
 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:
+// Expr is a location counter change, like ". = . + 0x1000"
+// Section is a description of output section, like ".data :..."
+enum class Command { Expr, Section };
+
+struct LocationNode {
+  Command Type;
+  std::vector<StringRef> Expr;
+  StringRef SectionName;
+};
+
 // 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 assignAddresses(std::vector<OutputSectionBase<ELFT> *> &S);
   int compareSections(StringRef A, StringRef B);
 
+  bool Exists = false;
+
 private:
+  template <class ELFT>
+  void fixupLocations(std::vector<OutputSectionBase<ELFT> *> &);
+  uint64_t evaluate(std::vector<StringRef> &Tokens, uint64_t LocCounter);
   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;
+
   llvm::BumpPtrAllocator Alloc;
 };
 
 extern LinkerScript *Script;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/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 "ScriptParser.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;
 
 LinkerScript *elf::Script;
 
+static uint64_t getInteger(StringRef S) {
+  uint64_t V;
+  if (S.getAsInteger(0, V)) {
+    error("malformed number: " + S);
+    return 0;
+  }
+  return V;
+}
+
+// Evaluates the expression given by list of tokens.
+uint64_t LinkerScript::evaluate(std::vector<StringRef> &Tokens,
+                                uint64_t LocCounter) {
+  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;
+    }
+
+    StringRef Tok = Tokens[I];
+    if (Tok == ".")
+      Result += LocCounter;
+    else
+      Result += getInteger(Tok);
+  }
+  return Result;
+}
+
 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;
 }
 
+// This method finalizes the Locations list. Adds neccesary locations for
+// orphan sections, what prepares it for futher use without
+// changes in LinkerScript::assignAddresses().
+template <class ELFT>
+void LinkerScript::fixupLocations(std::vector<OutputSectionBase<ELFT> *> &S) {
+  // 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.
+  for (OutputSectionBase<ELFT> *Sec : S) {
+    StringRef Name = Sec->getName();
+    auto I = std::find(SectionOrder.begin(), SectionOrder.end(), Name);
+    if (I == SectionOrder.end())
+      Locations.push_back({Command::Section, {}, {Name}});
+  }
+}
+
+template <class ELFT>
+void LinkerScript::assignAddresses(std::vector<OutputSectionBase<ELFT> *> &S) {
+  typedef typename ELFT::uint uintX_t;
+
+  Script->fixupLocations(S);
+
+  uintX_t ThreadBssOffset = 0;
+  uintX_t VA =
+      Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
+
+  for (LocationNode &Node : Locations) {
+    if (Node.Type == Command::Expr) {
+      VA = evaluate(Node.Expr, VA);
+      continue;
+    }
+
+    auto I =
+        std::find_if(S.begin(), S.end(), [&](OutputSectionBase<ELFT> *Sec) {
+          return Sec->getName() == Node.SectionName;
+        });
+    if (I == S.end())
+      continue;
+
+    OutputSectionBase<ELFT> *Sec = *I;
+    uintX_t Align = Sec->getAlign();
+    if ((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS) {
+      uintX_t TVA = VA + ThreadBssOffset;
+      TVA = alignTo(TVA, Align);
+      Sec->setVA(TVA);
+      ThreadBssOffset = TVA - VA + Sec->getSize();
+      continue;
+    }
+
+    if (Sec->getFlags() & SHF_ALLOC) {
+      VA = alignTo(VA, Align);
+      Sec->setVA(VA);
+      VA += Sec->getSize();
+      continue;
+    }
+  }
+}
+
 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
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);
 
   StringSaver Saver;
   const static StringMap<Handler> Cmd;
   bool IsUnderSysroot;
 };
 

 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);
 }
 
+void ScriptParser::readLocationCounterValue() {
+  expect(".");
+  expect("=");
+  Script->Locations.push_back({Command::Expr, {}, {}});
+  LocationNode &Node = Script->Locations.back();
+  while (!Error) {
+    StringRef Tok = next();
+    if (Tok == ";")
+      break;
+    Node.Expr.push_back(Tok);
+  }
+  if (Node.Expr.empty())
+    error("error in location counter expression");
+}
+
 void ScriptParser::readOutputSectionDescription() {
   StringRef OutSec = next();
   Script->SectionOrder.push_back(OutSec);
+  Script->Locations.push_back({Command::Section, {}, {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();
+  Exists = 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::assignAddresses(std::vector<OutputSectionBase<ELF32LE> *> &);
+template void
+LinkerScript::assignAddresses(std::vector<OutputSectionBase<ELF32BE> *> &);
+template void
+LinkerScript::assignAddresses(std::vector<OutputSectionBase<ELF64LE> *> &);
+template void
+LinkerScript::assignAddresses(std::vector<OutputSectionBase<ELF64BE> *> &);

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (HasError)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
     createPhdrs();
     fixHeaders();
+    if (Script->Exists) {
+      Script->assignAddresses(OutputSections);
+    } else {
       fixSectionAlignments();
       assignAddresses();
+    }
     assignFileOffsets();
     setPhdrs();
     fixAbsoluteSymbols();
   }
 
   openFile();
   if (HasError)
     return;
if (needsPtLoad(Sec))
       Sec->PageAlign = true;
   }
 }
 
 // We should set file offsets and VAs for elf header and program headers
 // sections. These are special, we do not include them into output sections
 // list, but have them to simplify the code.
 template <class ELFT> void Writer<ELFT>::fixHeaders() {
-  Out<ELFT>::ElfHeader->setVA(Target->getVAStart());
+  uintX_t BaseVA = Script->Exists ? 0 : Target->getVAStart();
+  Out<ELFT>::ElfHeader->setVA(BaseVA);
   Out<ELFT>::ElfHeader->setFileOffset(0);
   uintX_t Off = Out<ELFT>::ElfHeader->getSize();
-  Out<ELFT>::ProgramHeaders->setVA(Off + Target->getVAStart());
+  Out<ELFT>::ProgramHeaders->setVA(Off + BaseVA);
   Out<ELFT>::ProgramHeaders->setFileOffset(Off);
 }
 
 // Assign VAs (addresses at run-time) to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = Target->getVAStart() + Out<ELFT>::ElfHeader->getSize() +
                Out<ELFT>::ProgramHeaders->getSize();
 

lld/trunk/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

lld/trunk/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:   }
+
+# RUN: echo "SECTIONS { \
+# RUN:  . = 0x12Q41; \
+# RUN: }" > %t.script
+# RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | \
+# RUN:  FileCheck --check-prefix=NUMERR %s
+# NUMERR: malformed number: 0x12Q41
+
+.globl _start;
+_start:
+nop
+
+.section .data
+.quad 0
+

lld/trunk/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

lld/trunk/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

lld/trunk/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