[ELF] Set the section size on the section start symbols

[arichardson]

Summary

Currently lld sets a size of zero on all the __start_foo and foo_start
symbols. This is fine for most architectures except for CHERI. On CHERI
pointers are capabilities that not only contain an address but also bounds
and access permissions. An expression like _DYNAMIC[0].d_tag will fail at
runtime if we don't set the ELF symbol size. When taking the address of a
global we set the length of that capability from the ELF symbol size and
if it is zero the CPU will trap when we load 8 bytes from a capability with
length zero.

[arichardson]

• rebased
• minor simplification
• updated all the tests

[peter.smith]

Can you share a bit more about how CHERI uses the symbol size? Is it only for known linker generated Sections like in your example above, or to support arbitrary user mysection_start symbols? Is the mysection_start symbol special cased within CHERI or is it just an arbitrary ELF Symbol. I'm just a bit curious about the implications of setting the symbol size, for example if this is for special sections like .dynamic we would only expect the _start and _end, and _DYNAMIC symbols to be defined, in an arbitrary mysection_start there could be multiple other symbols defined as well and having the symbol size set to the section size would mean its [0, size) range would overlap all other symbols in the section, this could potentially confuse other ELF processing tools that might skip over functions/data based on Symbol Size. I'm also curious as to how the symbol size is used? Does the OS/loader require the static symbol table to be present, what if it has been stripped?

On the assumption that there is a good reason for CHERI to use the symbol size I have some suggestions for the code.

• Given that addOptionalRegular is only used for start and end symbols and only uses the (now two) special cases of 0 and -1, I think we should rename the function to make it more specific to the purpose it is being used for.
• Would it be better to use a similar trick for Size as Value, for example if Size is -1 and symbol is defined with respect to an OutputSection then Size is Size of OutputSection? You'd then not need to track the state of the section symbols and have a potentially fragile one off update.

[arichardson]

In D39548#916728, @peter.smith wrote:

Can you share a bit more about how CHERI uses the symbol size? Is it only for known linker generated Sections like in your example above, or to support arbitrary user mysection_start symbols? Is the mysection_start symbol special cased within CHERI or is it just an arbitrary ELF Symbol.

We don't do any special casing based on symbol names, we only look at the information from the symbol table. I think having special cases based on the symbol name is very fragile so I'd rather set a size on all linker defined symbols that are used as dereferenceable pointers.

I'm just a bit curious about the implications of setting the symbol size, for example if this is for special sections like .dynamic we would only expect the _start and _end, and _DYNAMIC symbols to be defined, in an arbitrary mysection_start there could be multiple other symbols defined as well and having the symbol size set to the section size would mean its [0, size) range would overlap all other symbols in the section, this could potentially confuse other ELF processing tools that might skip over functions/data based on Symbol Size. I'm also curious as to how the symbol size is used? Does the OS/loader require the static symbol table to be present, what if it has been stripped?

I hadn't thought about the potential to confuse other ELF processing tools. However, wouldn't that also break on code like this?

.global foo_with_setup
.ent foo_with_setup
foo_with_setup:
  ....
  ....
foo_fast:
 ....
 ....
.end foo_with_setup

jal foo_with_setup
...
jal foo_fast

In CHERI each pointer (capability) is architecturally 256 bits (compressed to 128 in memory): 64 bit base address + 64 bit offset + 64 bit length and <64bits attributes (read data/store data/executable/load capability/store capability, etc.). During the initial startup we have to initialize all global capabilities using the information from the ELF symbols.
Currently we generate a special ELF section __cap_relocs containing a capability "relocations" for every global pointer. For historic reasons we don't use ELF relocations but an array of structs that is processed by crt_init_globals() in the initial startup code.
This separate section also has the advantage that we don't need any symbol tables at runtime but can just loop over this array containing addresses resolved at static link time.
We need sizes on every ELF symbol that can be used as a pointer in order to set the correct runtime-bounds on the resulting capability so that we can find all bounds violations.

Say we have the following code:

char x[20];
char* y = &x[20];

int foo(void) {
   char c = y[-1]; // okay
   c = y[0];  // trap at runtime
  return c;
}

__attribute__((weak)) extern Elf_Dyn* _DYNAMIC;
int parse_dynamic(void) {
  Elf_Dyn* dynp = _DYNAMIC;
  for (; dynp->d_tag != DT_NULL; dynp++) {
    // ...
  }
  return 0;
}

Currently we can generate a __cap_relocs section with the following contents (the load address will be added to these addresses before the globals are initialized):

CAPABILITY RELOCATION RECORDS:
0x0000000000020000	Base: x (0x0000000000040000)	Offset: 0x0000000000000014	Length: 0x0000000000000014	Permissions: 0x00000000
0x0000000000030000	Base: y (0x0000000000020000)	Offset: 0x0000000000000000	Length: 0x0000000000000010	Permissions: 0x00000000
0x0000000000030010	Base: _DYNAMIC (0x00000000000002b0)	Offset: 0x0000000000000000	Length: 0x0000000000000000	Permissions: 0x00000000
SYMBOL TABLE:
0000000000000000         *UND*		 00000000 
00000000000002b0         .dynamic		 00000000 .hidden _DYNAMIC
0000000000028010         .got		 00000000 .hidden _gp
0000000000030000 l    d  .cap_table		 00000000 .hidden .cap_table
0000000000030000 l       .cap_table		 00000010 .hidden y@CAPTABLE
0000000000030010 l       .cap_table		 00000010 .hidden _DYNAMIC@CAPTABLE
0000000000010000 g     F .text		 0000001c foo
0000000000010020 g     F .text		 00000024 parse_dynamic
0000000000040000 g       .bss		 00000014 x
0000000000020000 g       .data		 00000010 y

The problem here is because LLD says _DYNAMIC has size 0 we also create a capability at runtime that has a base of _DYNAMIC but with a length of zero so we will crash as soon as we load a single byte from this capability.
In order to not crash while iterating over _DYNAMIC we need the __cap_reloc for _DYNAMIC to be this instead:

CAPABILITY RELOCATION RECORDS:
0x0000000000030010	Base: _DYNAMIC (0x00000000000002b0)	Offset: 0x0000000000000000	Length: 0x0000000000000120	Permissions: 0x00000000
SYMBOL TABLE:
00000000000002b0         .dynamic		 00000120 .hidden _DYNAMIC

To generate those values we use Symbol->getSize<ELFT>() which currently returns zero for _DYNAMIC and __init_array_start, etc.
So far I have found this to be a problem with _DYNAMIC, the init+fini array start symbols as well as sections that have a c indentifier so code assumes it can simply dereference __start_foo.

On the assumption that there is a good reason for CHERI to use the symbol size I have some suggestions for the code.

• Given that addOptionalRegular is only used for start and end symbols and only uses the (now two) special cases of 0 and -1, I think we should rename the function to make it more specific to the purpose it is being used for.
• Would it be better to use a similar trick for Size as Value, for example if Size is -1 and symbol is defined with respect to an OutputSection then Size is Size of OutputSection? You'd then not need to track the state of the section symbols and have a potentially fragile one off update.

I like the idea of using Size == -1 as the output section size as this avoids the fragile state update. I will update the patch if you agree that it makes sense include this change in upstream LLD.

I hope my explanation made some sense. I know that compared to most architectures CHERI is rather exotic and therefore has some additional requirements. However, I feel like having sizes defined on symbols that are generally used as pointers would be a good patch to upstream.

[ruiu]

I think I understood your motivation to make this change, but it feels like this is still too specific to your target. Traditionally, these start/end symbols are NOTYPE symbols with size zero, and they are used as markers where their corresponding sections start/end. So, my understanding is that start symbols just point to where sections begin, and they do not "cover" sections, as the name implies. So, this change doesn't feel semantically correct to me.

In addition to that, because these symbols are being used in the wild since (I believe) the early Unix era, there's a chance that compatibility issues would arise if you change the symbol values. It seems a bit too risky. It's probably an unavoidable consequence that if you choose ELF as a file format, you'll have start/end symbols with size zero.

I wonder if you have thought about doing this in your loader. Your loader could identify start/end symbols and fix their values, couldn't it?

[peter.smith]

Currently we generate a special ELF section __cap_relocs containing a capability "relocations" for every global pointer. For historic reasons we don't use ELF relocations but an array of structs that is processed by crt_init_globals() in the initial startup code.
This separate section also has the advantage that we don't need any symbol tables at runtime but can just loop over this array containing addresses resolved at static link time.
We need sizes on every ELF symbol that can be used as a pointer in order to set the correct runtime-bounds on the resulting capability so that we can find all bounds violations.

Thanks for the detailed answer. Does the static linker create the cap_relocs section, or is it some standalone tool? If it is the static linker itself, then presumably there could be alternative ways of obtaining the size for the capability that would not involve propagating the change into the symbol table. For example set a flag on the symbol definition so that when you are writing out the cap_relocs and encounter a flagged symbol with size 0, you can calculate it from the OutputSection. Not as elegant for the __cap_relocs section but it might be ok to upstream the flagging mechanism?

[arichardson]

In D39548#917753, @peter.smith wrote:

Thanks for the detailed answer. Does the static linker create the cap_relocs section, or is it some standalone tool? If it is the static linker itself, then presumably there could be alternative ways of obtaining the size for the capability that would not involve propagating the change into the symbol table. For example set a flag on the symbol definition so that when you are writing out the cap_relocs and encounter a flagged symbol with size 0, you can calculate it from the OutputSection. Not as elegant for the __cap_relocs section but it might be ok to upstream the flagging mechanism?

Originally we used a standalone tool that extracted the information from the symbol table because we had to use BFD for linking. Now we can use LLD (as long as we apply the multi-GOT patch D31528) for building all of FreeBSD (CheriBSD) so I have integrated the __cap_relocs generation into our fork of LLD. For some build we still use the standalone tool but we are now migrating towards using the integrated one for everything.

Setting a flag on the symbol so that we can calculate the real size when we fill in the __cap_relocs sections would be a great solution. @ruiu would adding such a flag to Symbol be acceptable?

[arichardson]

In D39548#917330, @ruiu wrote:

I wonder if you have thought about doing this in your loader. Your loader could identify start/end symbols and fix their values, couldn't it?

We could do it in the load however we would then have to hardcode a list of all special symbol names there. Also this will not work for static linking because we don't have a loader there and need LLD to fill in that information.

I feel like having this information in Symbol but not adding it to the symbol table would be ideal for us.

[ruiu]

We could do it in the load however we would then have to hardcode a list of all special symbol names there. Also this will not work for static linking because we don't have a loader there and need LLD to fill in that information.

I think hardcoding a list of all special symbol names is not necessarily bad because the number of such symbols is small. Also, that's what lld does after all.

You still have a loader even for statically-linked executables, no? You don't need a dynamic linker to load a statically-linked executable, but either it is in a kernel or not, you still need a loader to map an executable to memory.

[arichardson]

Will keep this as a CHERI specific patch in our fork instead

ELF/Writer.cpp

private:
   void sortInputSections();
   void finalizeSections();
   void addPredefinedSections();
   void setReservedSymbolSections();
 
   std::vector<PhdrEntry *> createPhdrs();
   void removeEmptyPTLoad();
   void addPtArmExid(std::vector<PhdrEntry *> &Phdrs);
+  DefinedRegular *addOptionalRegular(StringRef Name, SectionBase *Sec,
+                                     uint64_t Val, uint8_t StOther = STV_HIDDEN,
+                                     uint8_t Binding = STB_GLOBAL);
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs();
   void fixSectionAlignments();
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   OutputSectionFactory Factory;
 
   void addRelIpltSymbols();
   void addStartEndSymbols();
   void addStartStopSymbols(OutputSection *Sec);
   uint64_t getEntryAddr();
   OutputSection *findSection(StringRef Name);
 
   std::vector<PhdrEntry *> Phdrs;
+  std::vector<DefinedRegular *> SectionStartSymbols;
 
   uint64_t FileSize;
   uint64_t SectionHeaderOff;
 
   bool HasGotBaseSym = false;
 };
 } // anonymous namespace
 
void PhdrEntry::add(OutputSection *Sec) {
   if (!FirstSec)
     FirstSec = Sec;
   p_align = std::max(p_align, Sec->Alignment);
   if (p_type == PT_LOAD)
     Sec->PtLoad = this;
 }
 
 template <class ELFT>
-static DefinedRegular *
-addOptionalRegular(StringRef Name, SectionBase *Sec, uint64_t Val,
-                   uint8_t StOther = STV_HIDDEN, uint8_t Binding = STB_GLOBAL) {
+DefinedRegular *
+Writer<ELFT>::addOptionalRegular(StringRef Name, SectionBase *Sec, uint64_t Val,
+                                 uint8_t StOther, uint8_t Binding) {
   Symbol *S = Symtab->find(Name);
   if (!S || S->isInCurrentOutput())
     return nullptr;
-  Symbol *Sym = Symtab->addRegular<ELFT>(Name, StOther, STT_NOTYPE, Val,
-                                         /*Size=*/0, Binding, Sec,
-                                         /*File=*/nullptr);
-  return cast<DefinedRegular>(Sym);
+  DefinedRegular *Sym = cast<DefinedRegular>(
+      Symtab->addRegular<ELFT>(Name, StOther, STT_NOTYPE, Val, /*Size=*/0,
+                               Binding, Sec, /*File=*/nullptr));
+  // If the value is zero this is a section start symbol. We should set the
+  // size of that symbol to be the size of the section but we don't know the
+  // section size yet. Therefore we save the symbol and the section now and
+  // update the size once we know the final size of the output section
+  if (Sec && Val == 0)
+    SectionStartSymbols.push_back(Sym);
+  return Sym;
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
   if (!Config->Static)
     return;
   StringRef S = Config->IsRela ? "__rela_iplt_start" : "__rel_iplt_start";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, 0, STV_HIDDEN, STB_WEAK);
+  addOptionalRegular(S, In<ELFT>::RelaIplt, 0, STV_HIDDEN, STB_WEAK);
 
   S = Config->IsRela ? "__rela_iplt_end" : "__rel_iplt_end";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, -1, STV_HIDDEN, STB_WEAK);
+  addOptionalRegular(S, In<ELFT>::RelaIplt, -1, STV_HIDDEN, STB_WEAK);
 }
 
 // The linker is expected to define some symbols depending on
 // the linking result. This function defines such symbols.
 template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   if (Config->EMachine == EM_MIPS) {
     // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
     // so that it points to an absolute address which by default is relative
if (Symtab->find("__gnu_local_gp"))
           Symtab->addAbsolute<ELFT>("__gnu_local_gp", STV_HIDDEN, STB_LOCAL);
   }
 
   // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention to
   // be at some offset from the base of the .got section, usually 0 or the end
   // of the .got
   InputSection *GotSection = InX::MipsGot ? cast<InputSection>(InX::MipsGot)
                                           : cast<InputSection>(InX::Got);
-  ElfSym::GlobalOffsetTable = addOptionalRegular<ELFT>(
+  ElfSym::GlobalOffsetTable = addOptionalRegular(
       "_GLOBAL_OFFSET_TABLE_", GotSection, Target->GotBaseSymOff);
 
   // __ehdr_start is the location of ELF file headers. Note that we define
   // this symbol unconditionally even when using a linker script, which
   // differs from the behavior implemented by GNU linker which only define
   // this symbol if ELF headers are in the memory mapped segment.
   // __executable_start is not documented, but the expectation of at
   // least the android libc is that it points to the elf header too.
   // __dso_handle symbol is passed to cxa_finalize as a marker to identify
   // each DSO. The address of the symbol doesn't matter as long as they are
   // different in different DSOs, so we chose the start address of the DSO.
   for (const char *Name :
        {"__ehdr_start", "__executable_start", "__dso_handle"})
-    addOptionalRegular<ELFT>(Name, Out::ElfHeader, 0, STV_HIDDEN);
+    addOptionalRegular(Name, Out::ElfHeader, 0, STV_HIDDEN);
 
   // If linker script do layout we do not need to create any standart symbols.
   if (Script->HasSectionsCommand)
     return;
 
-  auto Add = [](StringRef S, int64_t Pos) {
-    return addOptionalRegular<ELFT>(S, Out::ElfHeader, Pos, STV_DEFAULT);
+  auto Add = [this](StringRef S, int64_t Pos) {
+    return addOptionalRegular(S, Out::ElfHeader, Pos, STV_DEFAULT);
   };
 
   ElfSym::Bss = Add("__bss_start", 0);
   ElfSym::End1 = Add("end", -1);
   ElfSym::End2 = Add("_end", -1);
   ElfSym::Etext1 = Add("etext", -1);
   ElfSym::Etext2 = Add("_etext", -1);
   ElfSym::Edata1 = Add("edata", -1);
for (BaseCommand *Base : Script->SectionCommands)
       if (auto *Sec = dyn_cast<OutputSection>(Base))
         addStartStopSymbols(Sec);
   }
 
   // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
-  if (InX::DynSymTab)
-    Symtab->addRegular<ELFT>("_DYNAMIC", STV_HIDDEN, STT_NOTYPE, 0 /*Value*/,
-                             /*Size=*/0, STB_WEAK, InX::Dynamic,
-                             /*File=*/nullptr);
+  if (InX::DynSymTab) {
+    Symbol *Sym = Symtab->addRegular<ELFT>("_DYNAMIC", STV_HIDDEN, STT_NOTYPE,
+                                           0 /*Value*/, /*Size=*/0, STB_WEAK,
+                                           InX::Dynamic, /*File=*/nullptr);
+    // We don't know the final size of the dynamic section yet so defer setting
+    // the size of the output section
+    SectionStartSymbols.push_back(cast<DefinedRegular>(Sym));
+  }
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // This responsible for splitting up .eh_frame section into
   // pieces. The relocation scan uses those pieces, so this has to be
   // earlier.
   applySynthetic({InX::EhFrame},
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
   for (OutputSection *Sec : OutputSections)
     Sec->finalize<ELFT>();
 
   // createThunks may have added local symbols to the static symbol table
   applySynthetic({InX::SymTab},
                  [](SyntheticSection *SS) { SS->postThunkContents(); });
+
+  // Now that we know the size of all output sections we can update the size
+  // of the section start symbols.
+  for (DefinedRegular* Sym : SectionStartSymbols)
+    if (Sym->Section)
+      if (OutputSection* OS = Sym->Section->getOutputSection())
+        Sym->Size = OS->Size;
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   // ARM ABI requires .ARM.exidx to be terminated by some piece of data.
   // We have the terminater synthetic section class. Add that at the end.
   OutputSection *Cmd = findSection(".ARM.exidx");
   if (!Cmd || !Cmd->Live || Config->Relocatable)
     return;
 
   auto *Sentinel = make<ARMExidxSentinelSection>();
   Cmd->addSection(Sentinel);
 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End, OutputSection *OS) {
     // These symbols resolve to the image base if the section does not exist.
     // A special value -1 indicates end of the section.
     if (OS) {
-      addOptionalRegular<ELFT>(Start, OS, 0);
-      addOptionalRegular<ELFT>(End, OS, -1);
+      addOptionalRegular(Start, OS, 0);
+      addOptionalRegular(End, OS, -1);
     } else {
       if (Config->Pic)
         OS = Out::ElfHeader;
-      addOptionalRegular<ELFT>(Start, OS, 0);
-      addOptionalRegular<ELFT>(End, OS, 0);
+      addOptionalRegular(Start, OS, 0);
+      addOptionalRegular(End, OS, 0);
     }
   };
 
   Define("__preinit_array_start", "__preinit_array_end", Out::PreinitArray);
   Define("__init_array_start", "__init_array_end", Out::InitArray);
   Define("__fini_array_start", "__fini_array_end", Out::FiniArray);
 
   if (OutputSection *Sec = findSection(".ARM.exidx"))
     Define("__exidx_start", "__exidx_end", Sec);
 }
 
 // If a section name is valid as a C identifier (which is rare because of
 // the leading '.'), linkers are expected to define __start_<secname> and
 // __stop_<secname> symbols. They are at beginning and end of the section,
 // respectively. This is not requested by the ELF standard, but GNU ld and
 // gold provide the feature, and used by many programs.
 template <class ELFT>
 void Writer<ELFT>::addStartStopSymbols(OutputSection *Sec) {
   StringRef S = Sec->Name;
   if (!isValidCIdentifier(S))
     return;
-  addOptionalRegular<ELFT>(Saver.save("__start_" + S), Sec, 0, STV_DEFAULT);
-  addOptionalRegular<ELFT>(Saver.save("__stop_" + S), Sec, -1, STV_DEFAULT);
+  addOptionalRegular(Saver.save("__start_" + S), Sec, 0, STV_DEFAULT);
+  addOptionalRegular(Saver.save("__stop_" + S), Sec, -1, STV_DEFAULT);
 }
 
 template <class ELFT> OutputSection *Writer<ELFT>::findSection(StringRef Name) {
   for (BaseCommand *Base : Script->SectionCommands)
     if (auto *Sec = dyn_cast<OutputSection>(Base))
       if (Sec->Name == Name)
         return Sec;
   return nullptr;

test/ELF/arm-gnu-ifunc.s

 // CHECK-NEXT:     Other [
 // CHECK-NEXT:       STV_HIDDEN
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .rel.dyn
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: __rel_iplt_start
 // CHECK-NEXT:     Value: 0x100F4
-// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Size: 16
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other [
 // CHECK-NEXT:       STV_HIDDEN
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .rel.dyn
 // CHECK-NEXT:   }
 // CHECK-NEXT:  Symbol {

test/ELF/arm-static-defines.s

 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other [
 // CHECK-NEXT:       STV_HIDDEN
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .ARM.exidx
 // CHECK:          Name: __exidx_start
 // CHECK-NEXT:     Value: 0x100D4
-// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Size: 16
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other [
 // CHECK-NEXT:       STV_HIDDEN
 // CHECK-NEXT:     ]
 // CHECK-NEXT:   Section: .ARM.exidx
 // CHECK:          Symbol {
 // CHECK-NEXT:     Name: __tls_get_addr

test/ELF/bss-start-common.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-objdump -t -section-headers %t2 | FileCheck %s
 
 # CHECK: Sections:
 # CHECK: Idx Name          Size      Address          Type
 # CHECK:   2 .bss          00000004 0000000000201000 BSS
 # CHECK: SYMBOL TABLE:
-# CHECK: 0000000000201000  .bss 00000000 __bss_start
+# CHECK: 0000000000201000  .bss 00000004 __bss_start
 
 .global __bss_start
 .text
 _start:
 .comm sym1,4,4

test/ELF/dso_handle.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck %s
 # CHECK:    Name: __dso_handle
 # CHECK-NEXT:    Value: 0x0
-# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Size: 64
 # CHECK-NEXT:    Binding: Local
 # CHECK-NEXT:    Type: None
 # CHECK-NEXT:    Other [
 # CHECK-NEXT:      STV_HIDDEN
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Section: .dynsym
 
 .text
 .global foo, __dso_handle
 foo:
   lea __dso_handle(%rip),%rax

test/ELF/ehdr_start.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck %s
 # CHECK:    Name: __ehdr_start (1)
 # CHECK-NEXT:    Value: 0x200000
-# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Size: 64
 # CHECK-NEXT:    Binding: Local (0x0)
 # CHECK-NEXT:    Type: None (0x0)
 # CHECK-NEXT:    Other [ (0x2)
 # CHECK-NEXT:      STV_HIDDEN (0x2)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Section: .text (0x1)
 
 # CHECK:    Name: __executable_start
 # CHECK-NEXT:    Value: 0x200000
-# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Size: 64
 # CHECK-NEXT:    Binding: Local
 # CHECK-NEXT:    Type: None
 # CHECK-NEXT:    Other [
 # CHECK-NEXT:      STV_HIDDEN
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Section: .text
 
 .text

test/ELF/gc-sections-metadata-startstop.s

 # LINK_ORDER cnamed sections are not kept alive by the __start_* reference.
 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --gc-sections %t.o -o %t
 # RUN: llvm-objdump -section-headers -t %t | FileCheck  %s
 
 # CHECK: Sections:
 # CHECK-NOT: yy
 # CHECK: xx {{.*}} DATA
 # CHECK-NOT: yy
 
 # CHECK: SYMBOL TABLE:
-# CHECK: xx 00000000 __start_xx
+# CHECK: xx 00000008 __start_xx
 # CHECK: w *UND* 00000000 __start_yy
 
 .weak __start_xx
 .weak __start_yy
 
 .global _start
 _start:
 .quad __start_xx

test/ELF/global-offset-table-position-arm.s

 .global _start
 .type _start,%function
 _start:
  bl f
 .data
 
 // CHECK:     Name: _GLOBAL_OFFSET_TABLE_
 // CHECK-NEXT:     Value: 0x3068
-// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Size: 4
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got

test/ELF/global-offset-table-position-mips.s

 
 .global _start
 .type _start,@function
 _start:
  lw      $t0,%call16(f)($gp)
  .word _GLOBAL_OFFSET_TABLE_ - .
 // CHECK:     Name: _GLOBAL_OFFSET_TABLE_ (1)
 // CHECK-NEXT:     Value: 0x20000
-// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Size: 40
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got (0x9)

test/ELF/linkerscript/ehdr_start.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: ld.lld %t.o -script %t.script -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck %s
 # CHECK:    Name: __ehdr_start (1)
 # CHECK-NEXT:    Value: 0x0
-# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Size: 64
 # CHECK-NEXT:    Binding: Local (0x0)
 # CHECK-NEXT:    Type: None (0x0)
 # CHECK-NEXT:    Other [ (0x2)
 # CHECK-NEXT:      STV_HIDDEN (0x2)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Section: .text (0x1)
 
 .text
 .global _start, __ehdr_start
 _start:
   .quad __ehdr_start

test/ELF/pre_init_fini_array.s

 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .fini_array
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __fini_array_start
 // CHECK-NEXT:   Value: [[FINI_ADDR]]
-// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Size: 10
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .fini_array
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __init_array_end
 // CHECK-NEXT:   Value: 0x202008
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .init_array
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __init_array_start
 // CHECK-NEXT:   Value: [[INIT_ADDR]]
-// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Size: 8
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .init_array
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __preinit_array_end
 // CHECK-NEXT:   Value: 0x202011
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .preinit_array
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __preinit_array_start
 // CHECK-NEXT:   Value: [[PREINIT_ADDR]]
-// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Size: 9
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .preinit_array
 // CHECK-NEXT: }
 

test/ELF/section-start-symbols.s

+# RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi \
+# RUN:    -defsym=ARRAYS_EXIST=1 %s -o %t-with-arrays.o
+# RUN: ld.lld --static %t.o -o %t.exe
+# RUN: ld.lld --static %t-with-arrays.o -o %t-with-arrays.exe
+# RUN: llvm-objdump -t %t.exe | FileCheck %s -check-prefixes STATIC,BOTH,EMPTY-ARRAYS
+# RUN: llvm-objdump -t %t-with-arrays.exe | FileCheck %s -check-prefixes STATIC,BOTH,WITH-ARRAYS
+# RUN: ld.lld -pie %t.o -o %t-pie.exe -z notext
+# RUN: ld.lld -pie %t-with-arrays.o -o %t-with-arrays-pie.exe -z notext
+# RUN: llvm-objdump -t %t-pie.exe | FileCheck -check-prefixes PIE-EMPTY,BOTH,EMPTY-ARRAYS %s
+# RUN: llvm-objdump -t %t-with-arrays-pie.exe | FileCheck -check-prefixes PIE-WITH-ARRAYS,BOTH,WITH-ARRAYS %s
+# REQUIRES: arm
+
+ .syntax unified
+.section .text
+
+  .weak _DYNAMIC
+  .global _start
+  .global _start
+_start:
+  .fnstart
+  bx lr
+  .word __exidx_start
+  .word __exidx_end
+  .word __preinit_array_start
+  .word __preinit_array_end
+  .word __init_array_start
+  .word __init_array_end
+  .word __fini_array_start
+  .word __fini_array_end
+  .word _DYNAMIC
+  .word __start_foo
+  .word __stop_foo
+  .word __bss_start
+  .word __ehdr_start
+  .word __executable_start
+  .word __dso_handle
+.ifdef NOTYET
+  # FIXME: if I try to reference __rel_iplt_start here, llvm-objdump
+  # fails with the error: index past the end of the symbol table
+  # this also happens without my patch setting the sizes so there seems to be
+  # some corruption happening with a zero size .rel.iplt?
+  .weak __rel_iplt_start
+  .word __rel_iplt_start
+  .weak __rel_iplt_end
+  .word __rel_iplt_end
+.endif
+
+  .cantunwind
+  .fnend
+
+.section foo,"aw"
+  .quad 0
+  .quad 1
+
+.comm bss_sym,4,4
+
+.ifdef ARRAYS_EXIST
+
+.section .init_array,"aw",%init_array
+  .quad 0
+
+.section .preinit_array,"aw",%preinit_array
+  .quad 0
+  .byte 0
+
+.section .fini_array,"aw",%fini_array
+  .quad 0
+  .short 0
+
+.endif
+# PIE-EMPTY:       .dynamic     00000068 .hidden _DYNAMIC
+# PIE-WITH-ARRAYS: .dynamic     00000098 .hidden _DYNAMIC
+# BOTH:           .ARM.exidx   00000034 .hidden __dso_handle
+# BOTH:           .ARM.exidx   00000034 .hidden __ehdr_start
+# BOTH:           .ARM.exidx   00000034 .hidden __executable_start
+# BOTH:           .ARM.exidx   00000000 .hidden __exidx_end
+# BOTH:           .ARM.exidx   00000010 .hidden __exidx_start
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __fini_array_end
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __fini_array_start
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __init_array_end
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __init_array_start
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __preinit_array_end
+# STATIC-EMPTY:   *ABS*        00000000 .hidden __preinit_array_start
+# In PIE executables the __init/__fini symbols point to the ELF header
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __fini_array_end
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __fini_array_start
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __init_array_end
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __init_array_start
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __preinit_array_end
+# PIE-EMPTY:      .ARM.exidx        00000034 .hidden __preinit_array_start
+# WITH-ARRAYS:   .fini_array    00000000 .hidden __fini_array_end
+# WITH-ARRAYS:   .fini_array    0000000a .hidden __fini_array_start
+# WITH-ARRAYS:   .init_array    00000000 .hidden __init_array_end
+# WITH-ARRAYS:   .init_array    00000008 .hidden __init_array_start
+# WITH-ARRAYS:   .preinit_array 00000000 .hidden __preinit_array_end
+# WITH-ARRAYS:   .preinit_array 00000009 .hidden __preinit_array_start
+# STATIC:      w *UND*        00000000 _DYNAMIC
+# BOTH:          .bss         00000004 __bss_start
+# BOTH:          foo          00000010 __start_foo
+# BOTH:          foo          00000000 __stop_foo