ELF: Template LinkerScript class.

[ruiu]

Summary

Originally, linker scripts were basically an alternative way to specify
options to the command line options. But as we add more features to hanlde
symbols and sections, many member functions needed to be templated.
Now most the members are templated. It is probably time to template the
entire class.

Previously, LinkerScript is an executor of the linker script as well as
a storage of linker script configurations. This is not suitable to template
the class because when we are reading linker script files, we don't know
the ELF type yet, so we can't instantiate ELF-templated classes.

In this patch, I defined a new class, ScriptConfiguration, to store
linker script configurations. ScriptParser writes parse results to it,
and LinkerScript uses them.

[grimar]

Thats looks as nice cleanup change. Have some suggestions,
thought not sure how much them are reasonable.

ELF/Driver.cpp

420 ↗

(On Diff #54297)

Is it intentional empty line ?

ELF/LinkerScript.h

99 ↗

(On Diff #54297)

Do you need that struct ?
LinkerScript itself can be holder for it:

// This is a runner of the linker script.
template <class ELFT> class LinkerScript {
public:
   LinkerScript() { X = this; }
 ...

   static LinkerScript<ELFT> *X;

private:
  ...
};

And we can declare global method to access script:

template <class ELFT> LinkerScript<ELFT> *getScript() {
  return LinkerScript<ELFT>::X;
}

For me using getScript<ELFT>() looks a bit better that
accesses through Script<ELFT>::X.

[ruiu]

ELF/Driver.cpp

420 ↗

(On Diff #54297)

Yes, as I added two more lines below, I wanted make room between the local variable and local-but-then-global variables.

ELF/LinkerScript.h

99 ↗

(On Diff #54297)

That's an interesting idea, but on the second thought, I decided to go with the shorter name. We'll remove the struct after we migrate to C++14.

lld/trunk/ELF/Driver.cpp

 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
 bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
+
   Configuration C;
   LinkerDriver D;
-  LinkerScript LS;
+  ScriptConfiguration SC;
   Config = &C;
   Driver = &D;
-  Script = &LS;
+  ScriptConfig = &SC;
+
   Driver->main(Args);
   return !HasError;
 }
 
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef S) {
   if (S.endswith("_fbsd"))
     S = S.drop_back(5);
   if (S == "elf32btsmip")
if (Config->Verbose)
     llvm::outs() << Path << "\n";
   Optional<MemoryBufferRef> Buffer = readFile(Path);
   if (!Buffer.hasValue())
     return;
   MemoryBufferRef MBRef = *Buffer;
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
-    Script->read(MBRef);
+    readLinkerScript(MBRef);
     return;
   case file_magic::archive:
     if (WholeArchive) {
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(MB, Path));
       return;
     }
     Files.push_back(make_unique<ArchiveFile>(MBRef));
void LinkerDriver::createFiles(opt::InputArgList &Args) {
   }
 
   if (Files.empty() && !HasError)
     error("no input files.");
 }
 
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
+
   std::unique_ptr<TargetInfo> TI(createTarget());
   Target = TI.get();
+  LinkerScript<ELFT> LS;
+  Script<ELFT>::X = &LS;
 
   Config->Rela = ELFT::Is64Bits;
 
   // Add entry symbol.
   // There is no entry symbol for AMDGPU binaries, so skip adding one to avoid
   // having and undefined symbol.
   if (Config->Entry.empty() && !Config->Shared && !Config->Relocatable &&
       Config->EMachine != EM_AMDGPU)

lld/trunk/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 {
 
+// Parses a linker script. Calling this function updates
+// Config and ScriptConfig.
+void readLinkerScript(MemoryBufferRef MB);
+
 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)

 enum SectionsCommandKind { ExprKind, SectionKind };
 
 struct SectionsCommand {
   SectionsCommandKind Kind;
   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 DoLayout = false;
-
-private:
-  template <class ELFT> SectionRule *find(InputSectionBase<ELFT> *S);
-
+// ScriptConfiguration holds linker script parse results.
+struct ScriptConfiguration {
   // 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<SectionsCommand> Commands;
 
+  bool DoLayout = false;
+
   llvm::BumpPtrAllocator Alloc;
 };
 
-extern LinkerScript *Script;
+extern ScriptConfiguration *ScriptConfig;
+
+// This is a runner of the linker script.
+template <class ELFT> class LinkerScript {
+public:
+  StringRef getOutputSection(InputSectionBase<ELFT> *S);
+  ArrayRef<uint8_t> getFiller(StringRef Name);
+  bool isDiscarded(InputSectionBase<ELFT> *S);
+  bool shouldKeep(InputSectionBase<ELFT> *S);
+  void assignAddresses(std::vector<OutputSectionBase<ELFT> *> &S);
+  int compareSections(StringRef A, StringRef B);
+
+private:
+  SectionRule *find(InputSectionBase<ELFT> *S);
+
+  ScriptConfiguration &Opt = *ScriptConfig;
+};
+
+// Variable template is a C++14 feature, so we can't template
+// a global variable. Use a struct to workaround.
+template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
+template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/LinkerScript.cpp

 #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;
+ScriptConfiguration *elf::ScriptConfig;
 
 static uint64_t getInteger(StringRef S) {
   uint64_t V;
   if (S.getAsInteger(0, V)) {
     error("malformed number: " + S);
     return 0;
   }
   return V;
static uint64_t evaluate(ArrayRef<StringRef> Tokens, uint64_t Dot) {
   uint64_t V = parsePrimary(Tokens, Dot);
   V = parseExpr(V, 0, Tokens, Dot);
   if (!Tokens.empty())
     error("stray token: " + Tokens[0]);
   return V;
 }
 
 template <class ELFT>
-SectionRule *LinkerScript::find(InputSectionBase<ELFT> *S) {
-  for (SectionRule &R : Sections)
+SectionRule *LinkerScript<ELFT>::find(InputSectionBase<ELFT> *S) {
+  for (SectionRule &R : Opt.Sections)
     if (R.match(S))
       return &R;
   return nullptr;
 }
 
 template <class ELFT>
-StringRef LinkerScript::getOutputSection(InputSectionBase<ELFT> *S) {
+StringRef LinkerScript<ELFT>::getOutputSection(InputSectionBase<ELFT> *S) {
   SectionRule *R = find(S);
   return R ? R->Dest : "";
 }
 
 template <class ELFT>
-bool LinkerScript::isDiscarded(InputSectionBase<ELFT> *S) {
+bool LinkerScript<ELFT>::isDiscarded(InputSectionBase<ELFT> *S) {
   return getOutputSection(S) == "/DISCARD/";
 }
 
-template <class ELFT> bool LinkerScript::shouldKeep(InputSectionBase<ELFT> *S) {
+template <class ELFT>
+bool LinkerScript<ELFT>::shouldKeep(InputSectionBase<ELFT> *S) {
   SectionRule *R = find(S);
   return R && R->Keep;
 }
 
 template <class ELFT>
 static OutputSectionBase<ELFT> *
 findSection(std::vector<OutputSectionBase<ELFT> *> &V, StringRef Name) {
   for (OutputSectionBase<ELFT> *Sec : V)
     if (Sec->getName() == Name)
       return Sec;
   return nullptr;
 }
 
 template <class ELFT>
-void LinkerScript::assignAddresses(
+void LinkerScript<ELFT>::assignAddresses(
     std::vector<OutputSectionBase<ELFT> *> &Sections) {
   typedef typename ELFT::uint uintX_t;
 
   // 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 : Sections) {
     StringRef Name = Sec->getName();
-    auto I = std::find(SectionOrder.begin(), SectionOrder.end(), Name);
-    if (I == SectionOrder.end())
-      Commands.push_back({SectionKind, {}, Name});
+    auto I = std::find(Opt.SectionOrder.begin(), Opt.SectionOrder.end(), Name);
+    if (I == Opt.SectionOrder.end())
+      Opt.Commands.push_back({SectionKind, {}, Name});
   }
 
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   uintX_t ThreadBssOffset = 0;
   uintX_t VA =
       Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
 
-  for (SectionsCommand &Cmd : Commands) {
+  for (SectionsCommand &Cmd : Opt.Commands) {
     if (Cmd.Kind == ExprKind) {
       VA = evaluate(Cmd.Expr, VA);
       continue;
     }
 
     OutputSectionBase<ELFT> *Sec = findSection(Sections, Cmd.SectionName);
     if (!Sec)
       continue;
if (Sec->getFlags() & SHF_ALLOC) {
       VA = alignTo(VA, Sec->getAlign());
       Sec->setVA(VA);
       VA += Sec->getSize();
       continue;
     }
   }
 }
 
-ArrayRef<uint8_t> LinkerScript::getFiller(StringRef Name) {
-  auto I = Filler.find(Name);
-  if (I == Filler.end())
+template <class ELFT>
+ArrayRef<uint8_t> LinkerScript<ELFT>::getFiller(StringRef Name) {
+  auto I = Opt.Filler.find(Name);
+  if (I == Opt.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);
+template <class ELFT>
+int LinkerScript<ELFT>::compareSections(StringRef A, StringRef B) {
+  auto E = Opt.SectionOrder.end();
+  auto I = std::find(Opt.SectionOrder.begin(), E, A);
+  auto J = std::find(Opt.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.
for (;;) {
     T = T.substr(1);
   }
 }
 
 template <class ELFT> bool SectionRule::match(InputSectionBase<ELFT> *S) {
   return matchStr(SectionPattern, S->getSectionName());
 }
 
-class elf::ScriptParser final : public elf::ScriptParserBase {
+class elf::ScriptParser : public ScriptParserBase {
   typedef void (ScriptParser::*Handler)();
 
 public:
-  ScriptParser(BumpPtrAllocator *A, StringRef S, bool B)
-      : ScriptParserBase(S), Saver(*A), IsUnderSysroot(B) {}
+  ScriptParser(StringRef S, bool B) : ScriptParserBase(S), IsUnderSysroot(B) {}
 
   void run() override;
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   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;
+  ScriptConfiguration &Opt = *ScriptConfig;
+  StringSaver Saver = {ScriptConfig->Alloc};
   bool IsUnderSysroot;
 };
 
 const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
     {"ENTRY", &ScriptParser::readEntry},
     {"EXTERN", &ScriptParser::readExtern},
     {"GROUP", &ScriptParser::readGroup},
     {"INCLUDE", &ScriptParser::readInclude},

 
 void ScriptParser::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 void ScriptParser::readSections() {
-  Script->DoLayout = true;
+  Opt.DoLayout = true;
   expect("{");
   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);
+    Opt.Sections.emplace_back(OutSec, next(), Keep);
 }
 
 void ScriptParser::readLocationCounterValue() {
   expect(".");
   expect("=");
-  Script->Commands.push_back({ExprKind, {}, ""});
-  SectionsCommand &Cmd = Script->Commands.back();
+  Opt.Commands.push_back({ExprKind, {}, ""});
+  SectionsCommand &Cmd = Opt.Commands.back();
   while (!Error) {
     StringRef Tok = next();
     if (Tok == ";")
       break;
     Cmd.Expr.push_back(Tok);
   }
   if (Cmd.Expr.empty())
     error("error in location counter expression");
 }
 
 void ScriptParser::readOutputSectionDescription() {
   StringRef OutSec = next();
-  Script->SectionOrder.push_back(OutSec);
-  Script->Commands.push_back({SectionKind, {}, OutSec});
+  Opt.SectionOrder.push_back(OutSec);
+  Opt.Commands.push_back({SectionKind, {}, OutSec});
   expect(":");
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       readSectionPatterns(OutSec, false);
     } else if (Tok == "KEEP") {
       expect("(");
       next(); // Skip *
       readSectionPatterns(OutSec, true);
       expect(")");
     } else {
       setError("unknown command " + Tok);
     }
   }
   StringRef Tok = peek();
   if (Tok.startswith("=")) {
     if (!Tok.startswith("=0x")) {
       setError("filler should be a hexadecimal value");
       return;
     }
     Tok = Tok.substr(3);
-    Script->Filler[OutSec] = parseHex(Tok);
+    Opt.Filler[OutSec] = parseHex(Tok);
     next();
   }
 }
 
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     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) {
+// Entry point.
+void elf::readLinkerScript(MemoryBufferRef MB) {
   StringRef Path = MB.getBufferIdentifier();
-  ScriptParser(&Alloc, MB.getBuffer(), isUnderSysroot(Path)).run();
+  ScriptParser(MB.getBuffer(), isUnderSysroot(Path)).run();
 }
 
-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> *> &);
+template class elf::LinkerScript<ELF32LE>;
+template class elf::LinkerScript<ELF32BE>;
+template class elf::LinkerScript<ELF64LE>;
+template class elf::LinkerScript<ELF64BE>;

lld/trunk/ELF/MarkLive.cpp

if (Config->Shared || Config->ExportDynamic) {
     }
   }
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab->getObjectFiles())
     for (InputSectionBase<ELFT> *Sec : F->getSections())
       if (Sec && Sec != &InputSection<ELFT>::Discarded)
-        if (isReserved(Sec) || Script->shouldKeep<ELFT>(Sec))
+        if (isReserved(Sec) || Script<ELFT>::X->shouldKeep(Sec))
           Enqueue(Sec);
 
   // Mark all reachable sections.
   while (!Q.empty())
     forEachSuccessor<ELFT>(Q.pop_back_val(), Enqueue);
 }
 
 template void elf::markLive<ELF32LE>(SymbolTable<ELF32LE> *);
 template void elf::markLive<ELF32BE>(SymbolTable<ELF32BE> *);
 template void elf::markLive<ELF64LE>(SymbolTable<ELF64LE> *);
 template void elf::markLive<ELF64BE>(SymbolTable<ELF64BE> *);

lld/trunk/ELF/OutputSections.cpp

 static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
   size_t I = 0;
   for (; I + A.size() < Size; I += A.size())
     memcpy(Buf + I, A.data(), A.size());
   memcpy(Buf + I, A.data(), Size - I);
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  ArrayRef<uint8_t> Filler = Script->getFiller(this->Name);
+  ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
   if (!Filler.empty())
     fill(Buf, this->getSize(), Filler);
   if (Config->Threads) {
     parallel_for_each(Sections.begin(), Sections.end(),
                       [=](InputSection<ELFT> *C) { C->writeTo(Buf); });
   } else {
     for (InputSection<ELFT> *C : Sections)
       C->writeTo(Buf);

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (HasError)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
     createPhdrs();
     fixHeaders();
-    if (Script->DoLayout) {
-      Script->assignAddresses(OutputSections);
+    if (ScriptConfig->DoLayout) {
+      Script<ELFT>::X->assignAddresses(OutputSections);
     } else {
       fixSectionAlignments();
       assignAddresses();
     }
     assignFileOffsets();
     setPhdrs();
     fixAbsoluteSymbols();
   }

 }
 
 // Output section ordering is determined by this function.
 template <class ELFT>
 static bool compareSections(OutputSectionBase<ELFT> *A,
                             OutputSectionBase<ELFT> *B) {
   typedef typename ELFT::uint uintX_t;
 
-  int Comp = Script->compareSections(A->getName(), B->getName());
+  int Comp = Script<ELFT>::X->compareSections(A->getName(), B->getName());
   if (Comp != 0)
     return Comp < 0;
 
   uintX_t AFlags = A->getFlags();
   uintX_t BFlags = B->getFlags();
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
for (SharedSymbol<ELFT> &S : SS->File->getSharedSymbols()) {
     S.MustBeInDynSym = true;
   }
   Out<ELFT>::RelaDyn->addReloc(
       {Target->CopyRel, Out<ELFT>::Bss, SS->OffsetInBss, false, SS, 0});
 }
 
 template <class ELFT>
 StringRef Writer<ELFT>::getOutputSectionName(InputSectionBase<ELFT> *S) const {
-  StringRef Dest = Script->getOutputSection<ELFT>(S);
+  StringRef Dest = Script<ELFT>::X->getOutputSection(S);
   if (!Dest.empty())
     return Dest;
 
   StringRef Name = S->getSectionName();
   for (StringRef V : {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.",
                       ".init_array.", ".fini_array.", ".ctors.", ".dtors.",
                       ".tbss.", ".gcc_except_table.", ".tdata."})
     if (Name.startswith(V))
       return V.drop_back();
   return Name;
 }
 
 template <class ELFT>
 void reportDiscarded(InputSectionBase<ELFT> *IS,
                      const std::unique_ptr<elf::ObjectFile<ELFT>> &File) {
   if (!Config->PrintGcSections || !IS || IS->Live)
     return;
   llvm::errs() << "removing unused section from '" << IS->getSectionName()
                << "' in file '" << File->getName() << "'\n";
 }
 
 template <class ELFT>
 bool Writer<ELFT>::isDiscarded(InputSectionBase<ELFT> *S) const {
   return !S || S == &InputSection<ELFT>::Discarded || !S->Live ||
-         Script->isDiscarded(S);
+         Script<ELFT>::X->isDiscarded(S);
 }
 
 template <class ELFT>
 static SymbolBody *
 addOptionalSynthetic(SymbolTable<ELFT> &Table, StringRef Name,
                      OutputSectionBase<ELFT> &Sec, typename ELFT::uint Val) {
   if (!Table.find(Name))
     return nullptr;
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() {
-  uintX_t BaseVA = Script->DoLayout ? 0 : Target->getVAStart();
+  uintX_t BaseVA = ScriptConfig->DoLayout ? 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 + BaseVA);
   Out<ELFT>::ProgramHeaders->setFileOffset(Off);
 }
 
 // Assign VAs (addresses at run-time) to output sections.