DRAFT patch for PR35877.

[grimar]

Summary

For demonstration purposes only. Its unpolished dumb PoC.

More details will be provided at https://bugs.llvm.org//show_bug.cgi?id=35877 page.

[grimar]

• Significantly simplified.

[grimar]

Abandoning this DRAFT, as D42482 is looks better IMO (though it's status is also unclear, but anyways).

ELF/OutputSections.h

public:
   std::vector<BaseCommand *> SectionCommands;
   std::vector<StringRef> Phdrs;
   llvm::Optional<uint32_t> Filler;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
   std::string Location;
   std::string MemoryRegionName;
   std::string LMARegionName;
   bool Noload = false;
+  StringRef InsertAfter;
 
   template <class ELFT> void finalize();
   template <class ELFT> void writeTo(uint8_t *Buf);
   template <class ELFT> void maybeCompress();
 
   void sort(std::function<int(InputSectionBase *S)> Order);
   void sortInitFini();
   void sortCtorsDtors();

ELF/ScriptParser.cpp

while (!errorCount() && !consume("}")) {
     if (!Cmd) {
       if (Tok == "ASSERT")
         Cmd = readAssert();
       else
         Cmd = readOutputSectionDescription(Tok);
     }
     Script->SectionCommands.push_back(Cmd);
   }
+
+  if (consume("INSERT")) {
+    expect("AFTER");
+    StringRef After = next();
+    for (BaseCommand *Base : Script->SectionCommands) {
+      auto *Sec = cast<OutputSection>(Base);
+      Sec->InsertAfter = After;
+    }
+  }
 }
 
 static int precedence(StringRef Op) {
   return StringSwitch<int>(Op)
       .Cases("*", "/", 5)
       .Cases("+", "-", 4)
       .Cases("<<", ">>", 3)
       .Cases("<", "<=", ">", ">=", "==", "!=", 2)

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::sortSections() {
   // inserted, because Commands contains not only output section
   // commands but also other types of commands such as symbol assignment
   // expressions. There's no correct answer here due to the lack of the
   // formal specification of the linker script. We use heuristics to
   // determine whether a new output command should be added before or
   // after another commands. For the details, look at shouldSkip
   // function.
 
+  // For handling "INSERT AFTER" we make all inserted sections to be orphans,
+  // because according to specification insertion point is as for oprhan
+  // sections.
+  for (BaseCommand *&Base : Script->SectionCommands)
+    if (auto *Sec = dyn_cast<OutputSection>(Base))
+      if (!Sec->InsertAfter.empty())
+        Sec->SectionIndex = INT_MAX;
+
+  // We assuming that sections inserted with "INSERT AFTER" are not referencing
+  // each other for simplivity, so just placing them to the end and let orphans
+  // heuristic code do all job about placing them after already created
+  // sections.
+  std::stable_sort(Script->SectionCommands.begin(),
+                   Script->SectionCommands.end(),
+                   [](const BaseCommand *ACmd, const BaseCommand *BCmd) {
+                     auto *SecA = dyn_cast<OutputSection>(ACmd);
+                     auto *SecB = dyn_cast<OutputSection>(BCmd);
+                     if (!SecA || !SecB)
+                       return false;
+                     if (SecA->InsertAfter.empty() == SecB->InsertAfter.empty())
+                       return false;
+                     return SecA->InsertAfter.empty();
+                   });
+
   auto I = Script->SectionCommands.begin();
   auto E = Script->SectionCommands.end();
   auto NonScriptI = std::find_if(I, E, [](BaseCommand *Base) {
     if (auto *Sec = dyn_cast<OutputSection>(Base))
       return Sec->Live && Sec->SectionIndex == INT_MAX;
     return false;
   });
 
while (NonScriptI != E) {
     // As an optimization, find all sections with the same sort rank
     // and insert them with one rotate.
     unsigned Rank = Orphan->SortRank;
     auto End = std::find_if(NonScriptI + 1, E, [=](BaseCommand *Cmd) {
       return cast<OutputSection>(Cmd)->SortRank != Rank;
     });
     std::rotate(Pos, NonScriptI, End);
     NonScriptI = End;
     }
 
     Script->adjustSectionsAfterSorting();
 }
 
 static bool compareByFilePosition(InputSection *A, InputSection *B) {
   // Synthetic, i. e. a sentinel section, should go last.
   if (A->kind() == InputSectionBase::Synthetic ||
       B->kind() == InputSectionBase::Synthetic)
     return A->kind() != InputSectionBase::Synthetic;
   InputSection *LA = A->getLinkOrderDep();

test/ELF/linkerscript/insert-after.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: echo "SECTIONS {                                         \
+# RUN:   .bar1 : { __start_bar1 = .; *(.foo1) __end_bar1 = .; } \
+# RUN:  } INSERT AFTER .data;                                   \
+# RUN:  SECTIONS {                                              \
+# RUN:   .bar2 : { __start_bar2 = .; *(.foo2) __end_bar2 = .; } \
+# RUN:  } INSERT AFTER .text;" > %t.script
+
+# RUN: ld.lld %t1.o -o %t1 --script %t.script
+# RUN: llvm-objdump -section-headers %t1 | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT:   0               00000000 0000000000000000
+# CHECK-NEXT:   1 .text         00000001 0000000000000000 TEXT DATA
+# CHECK-NEXT:   2 .bar2         00000008 0000000000000001 TEXT DATA
+# CHECK-NEXT:   3 .data         00000008 0000000000000009 DATA
+# CHECK-NEXT:   4 .bar1         00000008 0000000000000011 DATA
+# CHECK-NEXT:   5 .comment      00000008 0000000000000000
+# CHECK-NEXT:   6 .symtab       00000090 0000000000000000
+# CHECK-NEXT:   7 .shstrtab     0000003c 0000000000000000
+# CHECK-NEXT:   8 .strtab       00000038 0000000000000000
+
+.global _start
+_start:
+ nop
+
+.section .data,"aw"
+.quad 0
+
+.section .foo1,"aw"
+.quad 1
+
+.section .foo2,"ax"
+.quad 1