[lld][elf2] Generate PT_TLS.

[ruiu]

ELF/Writer.cpp

671

ThreadBSSOffset -> TbssOffset since .tbss is a section name.

706–707

ThreadBSSOffset = TVA - VA + Sec->getSize();

725

Can you make TlsPhdr a Elf_Phdr (instead of Elf_Phdr *) and check if its validity using its members? If TlsPhdr.p_vaddr > 0, for example, it must have a valid value.

[Bigcheese]

Address review comments.

ELF/Writer.cpp

671

.tbss is not the only possible section name. And this variable exists because of that. It handles the case of multiple SHF_ALLOC | SHF_WRITE | SHF_TLS, SHT_NOBITS output sections.

[ruiu]

ELF/Writer.cpp

670

Do we need this? Isn't an Elf_Phdr zero-initialized?

[Bigcheese]

ELF/Writer.cpp

670

There's no explicit zero init, and I'm pretty sure default-initialization here does nothing.

[ruiu]

LGTM

ELF/Writer.cpp

670

I'd zero out all fields using memset.

[grimar]

ELF/Writer.cpp

670

What about next ?

Elf_Phdr TlsPhdr = {};

[ruiu]

ELF/Writer.cpp

670

Seems like a good idea. I was not completely sure if the empty initializer is allowed to initialize a struct, but it seems to be accepted.

ELF/Writer.cpp

static uint32_t toPhdrFlags(uint64_t Flags) {
   uint32_t Ret = PF_R;
   if (Flags & SHF_WRITE)
     Ret |= PF_W;
   if (Flags & SHF_EXECINSTR)
     Ret |= PF_X;
   return Ret;
 }
 
-template <class ELFT>
-static bool consumesVirtualAddressSpace(OutputSectionBase<ELFT> *Sec) {
-  return (Sec->getFlags() & SHF_ALLOC) &&
-         // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
-         // responsible for allocating space for them, not the PT_LOAD that
-         // contains the TLS initialization image.
-         !((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS);
-}
-
 // Visits all sections to create PHDRs and to assign incremental,
 // non-overlapping addresses to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = getVAStart() + sizeof(Elf_Ehdr);
   uintX_t FileOff = sizeof(Elf_Ehdr);
 
   // Calculate and reserve the space for the program header first so that
   // the first section can start right after the program header.
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   Elf_Phdr *Interp = nullptr;
   if (needsInterpSection())
     Interp = &Phdrs[++PhdrIdx];
 
   // Add the first PT_LOAD segment for regular output sections.
   setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, getVAStart(), FileOff,
           Target->getPageSize());
 
+  Elf_Phdr TlsPhdrStorage;
+  Elf_Phdr *TlsPhdr = nullptr;
+  uintX_t ThreadBSSOffset = 0;
   // Create phdrs as we assign VAs and file offsets to all output sections.
   SmallPtrSet<Elf_Phdr *, 8> Closed;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (Sec->getSize()) {
       uintX_t Flags = toPhdrFlags(Sec->getFlags());
       Elf_Phdr *Last = &Phdrs[PhdrIdx];
       if (Last->p_flags != Flags || !needsPhdr<ELFT>(Sec)) {
         // Flags changed. End current Phdr and potentially create a new one.
         if (Closed.insert(Last).second) {
           Last->p_filesz = FileOff - Last->p_offset;
           Last->p_memsz = VA - Last->p_vaddr;
         }
 
         if (needsPhdr<ELFT>(Sec)) {
           VA = RoundUpToAlignment(VA, Target->getPageSize());
           FileOff = RoundUpToAlignment(FileOff, Target->getPageSize());
           Elf_Phdr *PH = &Phdrs[++PhdrIdx];
           setPhdr(PH, PT_LOAD, Flags, FileOff, VA, 0, Target->getPageSize());
         }
       }
     }
 
-    if (consumesVirtualAddressSpace<ELFT>(Sec)) {
+    if (Sec->getSize() && (Sec->getFlags() & SHF_ALLOC) &&
+        (Sec->getFlags() & SHF_TLS)) {
+      if (!TlsPhdr) {
+        TlsPhdr = &TlsPhdrStorage;
+        setPhdr(TlsPhdr, PT_TLS, PF_R, FileOff, VA, 0, Sec->getAlign());
+      }
+      if (Sec->getType() != SHT_NOBITS)
+        VA = RoundUpToAlignment(VA, Sec->getAlign());
+      uintX_t TVA = RoundUpToAlignment(VA + ThreadBSSOffset, Sec->getAlign());
+      Sec->setVA(TVA);
+      TlsPhdr->p_memsz += Sec->getSize();
+      if (Sec->getType() == SHT_NOBITS) {
+        ThreadBSSOffset = TVA - VA;
+        ThreadBSSOffset += Sec->getSize();
+      } else {
+        TlsPhdr->p_filesz += Sec->getSize();
+        VA += Sec->getSize();
+      }
+      TlsPhdr->p_align = std::max<uintX_t>(TlsPhdr->p_align, Sec->getAlign());
+    } else if (Sec->getFlags() & SHF_ALLOC) {
       VA = RoundUpToAlignment(VA, Sec->getAlign());
       Sec->setVA(VA);
       VA += Sec->getSize();
     }
+
     FileOff = RoundUpToAlignment(FileOff, Sec->getAlign());
     Sec->setFileOffset(FileOff);
     if (Sec->getType() != SHT_NOBITS)
       FileOff += Sec->getSize();
   }
 
+  if (TlsPhdr)
+    Phdrs[++PhdrIdx] = TlsPhdrStorage;
+
   // Add an entry for .dynamic.
   if (isOutputDynamic()) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     PH->p_type = PT_DYNAMIC;
     copyPhdr(PH, Out<ELFT>::Dynamic);
   }
 
   // Fix up PT_INTERP as we now know the address of .interp section.
   if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 }
 
 // Returns the number of PHDR entries.
 template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
+  bool Tls = false;
   int I = 2; // 2 for PT_PHDR and the first PT_LOAD
   if (needsInterpSection())
     ++I;
   if (isOutputDynamic())
     ++I;
   uintX_t Last = PF_R;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!Sec->getSize() || !needsPhdr<ELFT>(Sec))
       continue;
+    if (Sec->getFlags() & SHF_TLS)
+      Tls = true;
     uintX_t Flags = toPhdrFlags(Sec->getFlags());
     if (Last != Flags) {
       Last = Flags;
       ++I;
     }
   }
+  if (Tls)
+    ++I;
   return I;
 }
 
 template <class ELFT> void Writer<ELFT>::writeHeader() {
   uint8_t *Buf = Buffer->getBufferStart();
   memcpy(Buf, "\177ELF", 4);
 
   // Write the ELF header.

test/elf2/tls.s

 
 // CHECK:          Name: .tdata
 // CHECK-NEXT:     Type: SHT_PROGBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address:
+// CHECK-NEXT:     Address: [[TDATA_ADDR:0x.*]]
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 4
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info:
 // CHECK-NEXT:     AddressAlignment:
 // CHECK-NEXT:     EntrySize:
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {

 // CHECK-NEXT:     Index:
 // CHECK-NEXT:     Name: .tbss
 // CHECK-NEXT:     Type: SHT_NOBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address:
+// CHECK-NEXT:     Address: [[TBSS_ADDR:0x.*]]
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 4
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info:
 // CHECK-NEXT:     AddressAlignment:
 // CHECK-NEXT:     EntrySize:
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index:
 // CHECK-NEXT:     Name: .thread_bss
 // CHECK-NEXT:     Type: SHT_NOBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address:
+
+// 0x1100C = TBSS_ADDR + 4
+
+// CHECK-NEXT:     Address: 0x1100C
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 4
+// CHECK-NEXT:     Link:
+// CHECK-NEXT:     Info:
+// CHECK-NEXT:     AddressAlignment:
+// CHECK-NEXT:     EntrySize:
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section {
+// CHECK-NEXT:     Index:
+// CHECK-NEXT:     Name:
+// CHECK-NEXT:     Type:
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_ALLOC
+// CHECK-NEXT:       SHF_WRITE
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: [[TBSS_ADDR]]
 
 // Check that the TLS NOBITS sections weren't added to the R/W PT_LOAD's size.
 
 // CHECK:      ProgramHeaders [
 // CHECK:          Type: PT_LOAD
 // CHECK:          Type: PT_LOAD
 // CHECK:          FileSize: 8
 // CHECK-NEXT:     MemSize: 8
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       PF_R
 // CHECK-NEXT:       PF_W
 // CHECK-NEXT:     ]
+// CHECK:          Type: PT_TLS
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     VirtualAddress: [[TDATA_ADDR]]
+// CHECK-NEXT:     PhysicalAddress: [[TDATA_ADDR]]
+// CHECK-NEXT:     FileSize: 8
+// CHECK-NEXT:     MemSize: 16
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       PF_R
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Alignment:
+// CHECK-NEXT:   }