1 //===- LinkerScript.h -------------------------------------------*- C++ -*-===//
2 //
3 //                             The LLVM Linker
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLD_ELF_LINKER_SCRIPT_H
11 #define LLD_ELF_LINKER_SCRIPT_H
12 
13 #include "Config.h"
14 #include "Strings.h"
15 #include "Writer.h"
16 #include "lld/Core/LLVM.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DenseSet.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include <cstddef>
23 #include <cstdint>
24 #include <functional>
25 #include <memory>
26 #include <vector>
27 
28 namespace lld {
29 namespace elf {
30 
31 class DefinedCommon;
32 class SymbolBody;
33 class InputSectionBase;
34 class InputSection;
35 class OutputSection;
36 class OutputSectionFactory;
37 class InputSectionBase;
38 class SectionBase;
39 
40 struct ExprValue {
41   SectionBase *Sec;
42   uint64_t Val;
43   bool ForceAbsolute;
44 
45   ExprValue(SectionBase *Sec, bool ForceAbsolute, uint64_t Val)
46       : Sec(Sec), Val(Val), ForceAbsolute(ForceAbsolute) {}
47   ExprValue(SectionBase *Sec, uint64_t Val) : ExprValue(Sec, false, Val) {}
48   ExprValue(uint64_t Val) : ExprValue(nullptr, Val) {}
49   bool isAbsolute() const { return ForceAbsolute || Sec == nullptr; }
50   uint64_t getValue() const;
51   uint64_t getSecAddr() const;
52 };
53 
54 // This represents an expression in the linker script.
55 // ScriptParser::readExpr reads an expression and returns an Expr.
56 // Later, we evaluate the expression by calling the function.
57 typedef std::function<ExprValue()> Expr;
58 
59 // This enum is used to implement linker script SECTIONS command.
60 // https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS
61 enum SectionsCommandKind {
62   AssignmentKind, // . = expr or <sym> = expr
63   OutputSectionKind,
64   InputSectionKind,
65   AssertKind,   // ASSERT(expr)
66   BytesDataKind // BYTE(expr), SHORT(expr), LONG(expr) or QUAD(expr)
67 };
68 
69 struct BaseCommand {
70   BaseCommand(int K) : Kind(K) {}
71   int Kind;
72 };
73 
74 // This represents ". = <expr>" or "<symbol> = <expr>".
75 struct SymbolAssignment : BaseCommand {
76   SymbolAssignment(StringRef Name, Expr E, std::string Loc)
77       : BaseCommand(AssignmentKind), Name(Name), Expression(E), Location(Loc) {}
78 
79   static bool classof(const BaseCommand *C);
80 
81   // The LHS of an expression. Name is either a symbol name or ".".
82   StringRef Name;
83   SymbolBody *Sym = nullptr;
84 
85   // The RHS of an expression.
86   Expr Expression;
87 
88   // Command attributes for PROVIDE, HIDDEN and PROVIDE_HIDDEN.
89   bool Provide = false;
90   bool Hidden = false;
91 
92   // Holds file name and line number for error reporting.
93   std::string Location;
94 };
95 
96 // Linker scripts allow additional constraints to be put on ouput sections.
97 // If an output section is marked as ONLY_IF_RO, the section is created
98 // only if its input sections are read-only. Likewise, an output section
99 // with ONLY_IF_RW is created if all input sections are RW.
100 enum class ConstraintKind { NoConstraint, ReadOnly, ReadWrite };
101 
102 // This struct is used to represent the location and size of regions of
103 // target memory. Instances of the struct are created by parsing the
104 // MEMORY command.
105 struct MemoryRegion {
106   std::string Name;
107   uint64_t Origin;
108   uint64_t Length;
109   uint64_t Offset;
110   uint32_t Flags;
111   uint32_t NegFlags;
112 };
113 
114 struct OutputSectionCommand : BaseCommand {
115   OutputSectionCommand(StringRef Name)
116       : BaseCommand(OutputSectionKind), Name(Name) {}
117 
118   static bool classof(const BaseCommand *C);
119 
120   OutputSection *Sec = nullptr;
121   MemoryRegion *MemRegion = nullptr;
122   StringRef Name;
123   Expr AddrExpr;
124   Expr AlignExpr;
125   Expr LMAExpr;
126   Expr SubalignExpr;
127   std::vector<BaseCommand *> Commands;
128   std::vector<StringRef> Phdrs;
129   llvm::Optional<uint32_t> Filler;
130   ConstraintKind Constraint = ConstraintKind::NoConstraint;
131   std::string Location;
132   std::string MemoryRegionName;
133 };
134 
135 // This struct represents one section match pattern in SECTIONS() command.
136 // It can optionally have negative match pattern for EXCLUDED_FILE command.
137 // Also it may be surrounded with SORT() command, so contains sorting rules.
138 struct SectionPattern {
139   SectionPattern(StringMatcher &&Pat1, StringMatcher &&Pat2)
140       : ExcludedFilePat(Pat1), SectionPat(Pat2) {}
141 
142   StringMatcher ExcludedFilePat;
143   StringMatcher SectionPat;
144   SortSectionPolicy SortOuter;
145   SortSectionPolicy SortInner;
146 };
147 
148 struct InputSectionDescription : BaseCommand {
149   InputSectionDescription(StringRef FilePattern)
150       : BaseCommand(InputSectionKind), FilePat(FilePattern) {}
151 
152   static bool classof(const BaseCommand *C);
153 
154   StringMatcher FilePat;
155 
156   // Input sections that matches at least one of SectionPatterns
157   // will be associated with this InputSectionDescription.
158   std::vector<SectionPattern> SectionPatterns;
159 
160   std::vector<InputSectionBase *> Sections;
161 };
162 
163 // Represents an ASSERT().
164 struct AssertCommand : BaseCommand {
165   AssertCommand(Expr E) : BaseCommand(AssertKind), Expression(E) {}
166 
167   static bool classof(const BaseCommand *C);
168 
169   Expr Expression;
170 };
171 
172 // Represents BYTE(), SHORT(), LONG(), or QUAD().
173 struct BytesDataCommand : BaseCommand {
174   BytesDataCommand(Expr E, unsigned Size)
175       : BaseCommand(BytesDataKind), Expression(E), Size(Size) {}
176 
177   static bool classof(const BaseCommand *C);
178 
179   Expr Expression;
180   unsigned Offset;
181   unsigned Size;
182 };
183 
184 struct PhdrsCommand {
185   StringRef Name;
186   unsigned Type;
187   bool HasFilehdr;
188   bool HasPhdrs;
189   unsigned Flags;
190   Expr LMAExpr;
191 };
192 
193 // ScriptConfiguration holds linker script parse results.
194 struct ScriptConfiguration {
195   // Used to assign addresses to sections.
196   std::vector<BaseCommand *> Commands;
197 
198   // Used to assign sections to headers.
199   std::vector<PhdrsCommand> PhdrsCommands;
200 
201   bool HasSections = false;
202 
203   // List of section patterns specified with KEEP commands. They will
204   // be kept even if they are unused and --gc-sections is specified.
205   std::vector<InputSectionDescription *> KeptSections;
206 
207   // A map from memory region name to a memory region descriptor.
208   llvm::DenseMap<llvm::StringRef, MemoryRegion> MemoryRegions;
209 
210   // A list of symbols referenced by the script.
211   std::vector<llvm::StringRef> ReferencedSymbols;
212 };
213 
214 class LinkerScript {
215 protected:
216   void assignSymbol(SymbolAssignment *Cmd, bool InSec);
217   void setDot(Expr E, const Twine &Loc, bool InSec);
218 
219   std::vector<InputSectionBase *>
220   computeInputSections(const InputSectionDescription *);
221 
222   std::vector<InputSectionBase *>
223   createInputSectionList(OutputSectionCommand &Cmd);
224 
225   std::vector<size_t> getPhdrIndices(StringRef SectionName);
226   size_t getPhdrIndex(const Twine &Loc, StringRef PhdrName);
227 
228   MemoryRegion *findMemoryRegion(OutputSectionCommand *Cmd);
229 
230   void switchTo(OutputSection *Sec);
231   void flush();
232   void output(InputSection *Sec);
233   void process(BaseCommand &Base);
234 
235   OutputSection *Aether;
236   bool ErrorOnMissingSection = false;
237 
238   uint64_t Dot;
239   uint64_t ThreadBssOffset = 0;
240 
241   std::function<uint64_t()> LMAOffset;
242   OutputSection *CurOutSec = nullptr;
243   MemoryRegion *CurMemRegion = nullptr;
244 
245   llvm::DenseSet<OutputSection *> AlreadyOutputOS;
246   llvm::DenseSet<InputSectionBase *> AlreadyOutputIS;
247 
248 public:
249   bool hasPhdrsCommands() { return !Opt.PhdrsCommands.empty(); }
250   uint64_t getDot() { return Dot; }
251   OutputSection *getOutputSection(const Twine &Loc, StringRef S);
252   uint64_t getOutputSectionSize(StringRef S);
253   void discard(ArrayRef<InputSectionBase *> V);
254 
255   ExprValue getSymbolValue(const Twine &Loc, StringRef S);
256   bool isDefined(StringRef S);
257 
258   std::vector<OutputSection *> *OutputSections;
259   void fabricateDefaultCommands(bool AllocateHeader);
260   void addOrphanSections(OutputSectionFactory &Factory);
261   void removeEmptyCommands();
262   void adjustSectionsBeforeSorting();
263   void adjustSectionsAfterSorting();
264 
265   std::vector<PhdrEntry> createPhdrs();
266   bool ignoreInterpSection();
267 
268   llvm::Optional<uint32_t> getFiller(StringRef Name);
269   bool hasLMA(StringRef Name);
270   bool shouldKeep(InputSectionBase *S);
271   void assignOffsets(OutputSectionCommand *Cmd);
272   void placeOrphanSections();
273   void processNonSectionCommands();
274   void assignAddresses(std::vector<PhdrEntry> &Phdrs);
275   int getSectionIndex(StringRef Name);
276 
277   void writeDataBytes(StringRef Name, uint8_t *Buf);
278   void addSymbol(SymbolAssignment *Cmd);
279   void processCommands(OutputSectionFactory &Factory);
280 
281   // Parsed linker script configurations are set to this struct.
282   ScriptConfiguration Opt;
283 };
284 
285 extern LinkerScript *Script;
286 
287 } // end namespace elf
288 } // end namespace lld
289 
290 #endif // LLD_ELF_LINKER_SCRIPT_H
291