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;
+  bool InsertAfter = false;
 
   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);
   }
+
+  // This is used to implement INSERT AFTER .section sequence.
+  // In this case we let out orphans placement algorithm to find
+  // room for output sections specified. It does it after placing
+  // all other sections at first.
+  if (!atEOF() && consume("INSERT")) {
+    expect("AFTER");
+    skip();
+    for (BaseCommand *Base : Script->SectionCommands)
+      if (auto *Sec = dyn_cast<OutputSection>(Base))
+        Sec->InsertAfter = true;
+  }
 }
 
 static int precedence(StringRef Op) {
   return StringSwitch<int>(Op)
       .Cases("*", "/", 5)
       .Cases("+", "-", 4)
       .Cases("<<", ">>", 3)
       .Cases("<", "<=", ">", ">=", "==", "!=", 2)

ELF/Writer.cpp

static unsigned getSectionRank(const OutputSection *Sec) {
   }
 
   return Rank;
 }
 
 static bool compareSections(const BaseCommand *ACmd, const BaseCommand *BCmd) {
   const OutputSection *A = cast<OutputSection>(ACmd);
   const OutputSection *B = cast<OutputSection>(BCmd);
+  if (A->InsertAfter != B->InsertAfter)
+    return B->InsertAfter;
   if (A->SortRank != B->SortRank)
     return A->SortRank < B->SortRank;
   if (!(A->SortRank & RF_NOT_ADDR_SET))
     return Config->SectionStartMap.lookup(A->Name) <
            Config->SectionStartMap.lookup(B->Name);
   return false;
 }
 
template <class ELFT> void Writer<ELFT>::sortSections() {
   // 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.
 
   auto I = Script->SectionCommands.begin();
   auto E = Script->SectionCommands.end();
-  auto NonScriptI = std::find_if(I, E, [](BaseCommand *Base) {
+  auto NonScriptI = std::stable_partition(I, E, [](BaseCommand *Base) {
     if (auto *Sec = dyn_cast<OutputSection>(Base))
-      return Sec->Live && Sec->SectionIndex == INT_MAX;
-    return false;
+      return Sec->SectionIndex != INT_MAX && !Sec->InsertAfter;
+    return true;
   });
 
   // Sort the orphan sections.
   std::stable_sort(NonScriptI, E, compareSections);
 
   // As a horrible special case, skip the first . assignment if it is before any
   // section. We do this because it is common to set a load address by starting
   // the script with ". = 0xabcd" and the expectation is that every section is

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