[ELF] Print file:line for 'undefined section' error

[ruiu]

ELF/ScriptParser.cpp

44–45 ↗

(On Diff #79241)

This function seems odd because it returns two values as a pair but the third parameter is virtually the third return value.

48 ↗

(On Diff #79241)

Flip the condition and return eraly.

[evgeny777]

Addressed review comments

[ruiu]

LGTM

lld/trunk/ELF/LinkerScript.h

protected:
   ~LinkerScriptBase() = default;
 
 public:
   virtual uint64_t getHeaderSize() = 0;
   virtual uint64_t getSymbolValue(StringRef S) = 0;
   virtual bool isDefined(StringRef S) = 0;
   virtual bool isAbsolute(StringRef S) = 0;
   virtual const OutputSectionBase *getSymbolSection(StringRef S) = 0;
-  virtual const OutputSectionBase *getOutputSection(StringRef S) = 0;
+  virtual const OutputSectionBase *getOutputSection(const Twine &Loc,
+                                                    StringRef S) = 0;
   virtual uint64_t getOutputSectionSize(StringRef S) = 0;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // Used to assign addresses to sections.
   std::vector<std::unique_ptr<BaseCommand>> Commands;
 
public:
   void placeOrphanSections();
   void assignAddresses(std::vector<PhdrEntry<ELFT>> &Phdrs);
   bool hasPhdrsCommands();
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(StringRef S) override;
   bool isDefined(StringRef S) override;
   bool isAbsolute(StringRef S) override;
   const OutputSectionBase *getSymbolSection(StringRef S) override;
-  const OutputSectionBase *getOutputSection(StringRef S) override;
+  const OutputSectionBase *getOutputSection(const Twine &Loc,
+                                            StringRef S) override;
   uint64_t getOutputSectionSize(StringRef S) override;
 
   std::vector<OutputSectionBase *> *OutputSections;
 
   int getSectionIndex(StringRef Name);
 
 private:
   void computeInputSections(InputSectionDescription *);

lld/trunk/ELF/LinkerScript.cpp

template <class ELFT> int LinkerScript<ELFT>::getSectionIndex(StringRef Name) {
   return INT_MAX;
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::hasPhdrsCommands() {
   return !Opt.PhdrsCommands.empty();
 }
 
 template <class ELFT>
-const OutputSectionBase *LinkerScript<ELFT>::getOutputSection(StringRef Name) {
+const OutputSectionBase *LinkerScript<ELFT>::getOutputSection(const Twine &Loc,
+                                                              StringRef Name) {
   static OutputSectionBase FakeSec("", 0, 0);
 
   for (OutputSectionBase *Sec : *OutputSections)
     if (Sec->getName() == Name)
       return Sec;
-  error("undefined section " + Name);
+
+  error(Loc + ": undefined section " + Name);
   return &FakeSec;
 }
 
 // This function is essentially the same as getOutputSection(Name)->Size,
 // but it won't print out an error message if a given section is not found.
 //
 // Linker script does not create an output section if its content is empty.
 // We want to allow SIZEOF(.foo) where .foo is a section which happened to
StringRef ScriptParser::readParenLiteral() {
   return Tok;
 }
 
 Expr ScriptParser::readPrimary() {
   if (peek() == "(")
     return readParenExpr();
 
   StringRef Tok = next();
+  std::string Location = currentLocation();
 
   if (Tok == "~") {
     Expr E = readPrimary();
     return [=](uint64_t Dot) { return ~E(Dot); };
   }
   if (Tok == "-") {
     Expr E = readPrimary();
     return [=](uint64_t Dot) { return -E(Dot); };
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ADDR") {
     StringRef Name = readParenLiteral();
-    return {
-        [=](uint64_t Dot) { return ScriptBase->getOutputSection(Name)->Addr; },
+    return {[=](uint64_t Dot) {
+              return ScriptBase->getOutputSection(Location, Name)->Addr;
+            },
             [=] { return false; },
-        [=] { return ScriptBase->getOutputSection(Name); }};
+            [=] { return ScriptBase->getOutputSection(Location, Name); }};
   }
   if (Tok == "LOADADDR") {
     StringRef Name = readParenLiteral();
     return [=](uint64_t Dot) {
-      return ScriptBase->getOutputSection(Name)->getLMA();
+      return ScriptBase->getOutputSection(Location, Name)->getLMA();
     };
   }
   if (Tok == "ASSERT")
     return readAssert();
   if (Tok == "ALIGN") {
     Expr E = readParenExpr();
     return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
   }
Expr ScriptParser::readPrimary() {
   }
   if (Tok == "SIZEOF") {
     StringRef Name = readParenLiteral();
     return [=](uint64_t Dot) { return ScriptBase->getOutputSectionSize(Name); };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     return [=](uint64_t Dot) {
-      return ScriptBase->getOutputSection(Name)->Addralign;
+      return ScriptBase->getOutputSection(Location, Name)->Addralign;
     };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=](uint64_t Dot) { return ScriptBase->getHeaderSize(); };
 
   // Tok is a literal number.
   uint64_t V;
   if (readInteger(Tok, V))

lld/trunk/ELF/ScriptParser.h

public:
   void tokenize(MemoryBufferRef MB);
   static StringRef skipSpace(StringRef S);
   bool atEOF();
   StringRef next();
   StringRef peek();
   void skip();
   bool consume(StringRef Tok);
   void expect(StringRef Expect);
+  std::string currentLocation();
 
   std::vector<MemoryBufferRef> MBs;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
   bool Error = false;
 
 private:
   MemoryBufferRef currentBuffer();
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/ScriptParser.cpp

 void ScriptParserBase::expect(StringRef Expect) {
   if (Error)
     return;
   StringRef Tok = next();
   if (Tok != Expect)
     setError(Expect + " expected, but got " + Tok);
 }
 
+std::string ScriptParserBase::currentLocation() {
+  MemoryBufferRef MB = currentBuffer();
+  return (MB.getBufferIdentifier() + ":" +
+          Twine(getPos(MB.getBuffer(), Tokens[Pos - 1]).first))
+      .str();
+}
+
 // Returns true if string 'Bigger' contains string 'Shorter'.
 static bool containsString(StringRef Bigger, StringRef Shorter) {
   const char *BiggerEnd = Bigger.data() + Bigger.size();
   const char *ShorterEnd = Shorter.data() + Shorter.size();
 
   return Bigger.data() <= Shorter.data() && BiggerEnd >= ShorterEnd;
 }
 

lld/trunk/test/ELF/linkerscript/alignof.s

 
 ## Check that we error out if trying to get alignment of
 ## section that does not exist.
 # RUN: echo "SECTIONS { \
 # RUN:   _aaa = ALIGNOF(.foo); \
 # RUN: }" > %t.script
 # RUN: not ld.lld -o %t1 --script %t.script %t 2>&1 \
 # RUN:  | FileCheck -check-prefix=ERR %s
-# ERR: undefined section .foo
+# ERR: {{.*}}.script:1: undefined section .foo
 .global _start
 _start:
  nop
 
 .section .aaa,"a"
  .align 8
  .quad 0
 
 .section .bbb,"a"
  .align 16
  .quad 0
 
 .section .ccc,"a"
  .align 32
  .quad 0

lld/trunk/test/ELF/linkerscript/loadaddr.s

 # RUN: echo "SECTIONS { v = LOADADDR(.zzz); }" > %t.script
 # RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | FileCheck --check-prefix=ERROR %s
 
 # CHECK:      0000000000002000         *ABS*     00000000 aaa_lma
 # CHECK-NEXT: 0000000000002008         *ABS*     00000000 bbb_lma
 # CHECK-NEXT: 0000000000003000         *ABS*     00000000 ccc_lma
 # CHECK-NEXT: 0000000000004000         *ABS*     00000000 ddd_lma
 # CHECK-NEXT: 0000000000004008         *ABS*     00000000 txt_lma
-# ERROR: undefined section .zzz
+# ERROR: {{.*}}.script:1: undefined section .zzz
 
 .global _start
 _start:
  nop
 
 .section .aaa, "a"
 .quad 0
 
 .section .bbb, "a"
 .quad 0
 
 .section .ccc, "a"
 .quad 0
 
 .section .ddd, "a"
 .quad 0