Allow SIZEOF() command on nonexistent section.

[ruiu]

Summary

Linker script doesn't create a section if it has no content. So the following
script doesn't create .norelocs section if it doesn't have any .rel* sections.

.norelocs : { *(.rel*) }

Later, if you assert that the size of .norelocs is 0, LLD printed out
an error message, because it didn't allow calling SIZEOF() on nonexistent
sections.

This patch allows SIZEOF() on nonexistent sections, so that you can do
something like this.

ASSERT(SIZEOF(.norelocs), "shouldn't contain .rel sections!")

Note that this behavior is compatible with GNU.

[phosek]

LGTM, thanks! Would it make sense to do the same for ALIGNOF of non-existent section for consistency?

[ruiu]

I don't know -- do you need it? It makes sense to me that nonexistent sections have size 0, but I'm not sure about their alignments.

[phosek]

In D26810#598929, @ruiu wrote:

I don't know -- do you need it? It makes sense to me that nonexistent sections have size 0, but I'm not sure about their alignments.

We don't and I've never seen it being used, so it's probably not necessary.

lld/trunk/ELF/LinkerScript.h

 
 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 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;
 
   // Used to assign sections to headers.
public:
   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;
+  uint64_t getOutputSectionSize(StringRef S) override;
 
   std::vector<OutputSectionBase *> *OutputSections;
 
   int getSectionIndex(StringRef Name);
 
 private:
   void computeInputSections(InputSectionDescription *);
 

lld/trunk/ELF/LinkerScript.cpp

const OutputSectionBase *LinkerScript<ELFT>::getOutputSection(StringRef Name) {
 
   for (OutputSectionBase *Sec : *OutputSections)
     if (Sec->getName() == Name)
       return Sec;
   error("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
+// be empty. That is why this function is different from getOutputSection().
+template <class ELFT>
+uint64_t LinkerScript<ELFT>::getOutputSectionSize(StringRef Name) {
+  for (OutputSectionBase *Sec : *OutputSections)
+    if (Sec->getName() == Name)
+      return Sec->Size;
+  return 0;
+}
+
 template <class ELFT> uint64_t LinkerScript<ELFT>::getHeaderSize() {
   return elf::getHeaderSize<ELFT>();
 }
 
 template <class ELFT> uint64_t LinkerScript<ELFT>::getSymbolValue(StringRef S) {
   if (SymbolBody *B = Symtab<ELFT>::X->find(S))
     return B->getVA<ELFT>();
   error("symbol not found: " + S);
if (Tok == "DATA_SEGMENT_RELRO_END") {
     readExpr();
     expect(",");
     readExpr();
     expect(")");
     return [](uint64_t Dot) { return alignTo(Dot, Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
     StringRef Name = readParenLiteral();
-    return
-        [=](uint64_t Dot) { return ScriptBase->getOutputSection(Name)->Size; };
+    return [=](uint64_t Dot) { return ScriptBase->getOutputSectionSize(Name); };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     return [=](uint64_t Dot) {
       return ScriptBase->getOutputSection(Name)->Addralign;
     };
   }
   if (Tok == "SIZEOF_HEADERS")

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

 # CHECK-NEXT:    3 .ccc          00000018
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT:  0000000000000000 *UND* 00000000
 # CHECK-NEXT:                   .text 00000000 _start
 # CHECK-NEXT:  0000000000000008 *ABS* 00000000 _aaa
 # CHECK-NEXT:  0000000000000010 *ABS* 00000000 _bbb
 # CHECK-NEXT:  0000000000000018 *ABS* 00000000 _ccc
 
-## Check that we error out if trying to get size of
-## section that does not exist.
+## SIZEOF(.nonexistent_section) should return 0.
 # RUN: echo "SECTIONS { \
 # RUN:   .aaa         : { *(.aaa) } \
 # RUN:   .bbb         : { *(.bbb) } \
 # RUN:   .ccc         : { *(.ccc) } \
 # RUN:   _aaa = SIZEOF(.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
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -t -section-headers %t1 | FileCheck -check-prefix=CHECK2 %s
+
+# CHECK2: 0000000000000000 *ABS* 00000000 _aaa
 
 .global _start
 _start:
  nop
 
 .section .aaa,"a"
  .quad 0
 
 .section .bbb,"a"
  .quad 0
  .quad 0
 
 .section .ccc,"a"
  .quad 0
  .quad 0
  .quad 0