[ELF] - Refactoring of the elf/program headers allocation code.

[grimar]

Summary

I suggest this refactoring for code that allocates
elf/program headers.

I believe it is a bit easier to read.

[grimar]

Ok, it seems it is not really better. Abandoning.

ELF/LinkerScript.cpp

 
 static OutputSection *findFirstSection(PhdrEntry *Load) {
   for (OutputSection *Sec : OutputSections)
     if (Sec->PtLoad == Load)
       return Sec;
   return nullptr;
 }
 
-static uint64_t computeBase(uint64_t Min, bool AllocateHeaders) {
+static bool hasExplicitHeaders(ArrayRef<PhdrsCommand> Phdrs) {
+  return llvm::any_of(Phdrs, [](const PhdrsCommand &Cmd) {
+    return Cmd.HasPhdrs || Cmd.HasFilehdr;
+  });
+}
+
+static Optional<uint64_t> getHeadersVA(uint64_t MinVA, uint64_t HeaderSize,
+                                       ArrayRef<PhdrsCommand> Phdrs) {
+  // Unable to allocate headers when their size is greater than minimal VA.
+  if (HeaderSize > MinVA)
+    return None;
+
   // If there is no SECTIONS or if the linkerscript is explicit about program
   // headers, do our best to allocate them.
-  if (!Script->HasSectionsCommand || AllocateHeaders)
-    return 0;
+  if (!Script->HasSectionsCommand || hasExplicitHeaders(Phdrs))
+    return alignDown(MinVA - HeaderSize, Config->MaxPageSize);
+
   // Otherwise only allocate program headers if that would not add a page.
-  return alignDown(Min, Config->MaxPageSize);
+  if (HeaderSize <= MinVA - alignDown(MinVA, Config->MaxPageSize))
+    return alignDown(MinVA - HeaderSize, Config->MaxPageSize);
+  return None;
 }
 
 // Try to find an address for the file and program headers output sections,
 // which were unconditionally added to the first PT_LOAD segment earlier.
 //
 // When using the default layout, we check if the headers fit below the first
 // allocated section. When using a linker script, we also check if the headers
 // are covered by the output section. This allows omitting the headers by not
 // leaving enough space for them in the linker script; this pattern is common
 // in embedded systems.
 //
 // If there isn't enough space for these sections, we'll remove them from the
 // PT_LOAD segment, and we'll also remove the PT_PHDR segment.
 void LinkerScript::allocateHeaders(std::vector<PhdrEntry *> &Phdrs) {
   uint64_t Min = std::numeric_limits<uint64_t>::max();
   for (OutputSection *Sec : OutputSections)
     if (Sec->Flags & SHF_ALLOC)
       Min = std::min<uint64_t>(Min, Sec->Addr);
 
   auto It = llvm::find_if(
       Phdrs, [](const PhdrEntry *E) { return E->p_type == PT_LOAD; });
   if (It == Phdrs.end())
     return;
-  PhdrEntry *FirstPTLoad = *It;
 
-  bool HasExplicitHeaders =
-      llvm::any_of(PhdrsCommands, [](const PhdrsCommand &Cmd) {
-        return Cmd.HasPhdrs || Cmd.HasFilehdr;
-      });
-  uint64_t HeaderSize = getHeaderSize();
-  if (HeaderSize <= Min - computeBase(Min, HasExplicitHeaders)) {
-    Min = alignDown(Min - HeaderSize, Config->MaxPageSize);
-    Out::ElfHeader->Addr = Min;
-    Out::ProgramHeaders->Addr = Min + Out::ElfHeader->Size;
+  if (Optional<uint64_t> VA =
+          getHeadersVA(Min, getHeaderSize(), PhdrsCommands)) {
+    Out::ElfHeader->Addr = *VA;
+    Out::ProgramHeaders->Addr = *VA + Out::ElfHeader->Size;
     return;
   }
 
   // Error if we were explicitly asked to allocate headers.
-  if (HasExplicitHeaders)
+  if (hasExplicitHeaders(PhdrsCommands))
     error("could not allocate headers");
 
+  PhdrEntry *FirstPTLoad = *It;
   Out::ElfHeader->PtLoad = nullptr;
   Out::ProgramHeaders->PtLoad = nullptr;
   FirstPTLoad->FirstSec = findFirstSection(FirstPTLoad);
 
   llvm::erase_if(Phdrs,
                  [](const PhdrEntry *E) { return E->p_type == PT_PHDR; });
 }