[ELF] - Implement INSERT BEFORE.

[grimar]

Summary

This finishes PR35877.

INSERT BEFORE used similar to INSERT AFTER,
it inserts sections before the given target section.

[• rafael]

George Rimar via Phabricator via llvm-commits
<[e-mail]> writes:

• for (std::pair<StringRef, std::vector<BaseCommand *>> &P :
• InsertAfterCommands)
• if (!P.second.empty())
• error("unable to INSERT AFTER " + P.first + ": section not defined");

+
+ auto Check = [](llvm::DenseMap<StringRef, std::vector<BaseCommand *>> &Map) {
+ for (std::pair<StringRef, std::vector<BaseCommand *>> &P : Map)
+ if (!P.second.empty())
+ error("unable to INSERT AFTER/BEFORE " + P.first +
+ ": section not defined");
+ };
+ Check(InsertBeforeCommands);
+ Check(InsertAfterCommands);

It might be simpler to do

for (auto &Cmds : {InsertBeforeCommands, InsertAfterCommands}) {

...

}

LGTM with that.

Cheers,
Rafael

[ruiu]

LGTM

lld/trunk/ELF/LinkerScript.h

public:
   std::vector<InputSectionDescription *> KeptSections;
 
   // A map from memory region name to a memory region descriptor.
   llvm::MapVector<llvm::StringRef, MemoryRegion *> MemoryRegions;
 
   // A list of symbols referenced by the script.
   std::vector<llvm::StringRef> ReferencedSymbols;
 
-  // Used to implement INSERT AFTER. Contains commands that need
+  // Used to implement INSERT [AFTER|BEFORE]. Contains commands that need
   // to be inserted into SECTIONS commands list.
   llvm::DenseMap<StringRef, std::vector<BaseCommand *>> InsertAfterCommands;
+  llvm::DenseMap<StringRef, std::vector<BaseCommand *>> InsertBeforeCommands;
 };
 
 extern LinkerScript *Script;
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_ELF_LINKER_SCRIPT_H

lld/trunk/ELF/LinkerScript.cpp

static void declareSymbol(SymbolAssignment *Cmd) {
   Cmd->Sym = cast<Defined>(Sym);
   Cmd->Provide = false;
 }
 
 // This method is used to handle INSERT AFTER statement. Here we rebuild
 // the list of script commands to mix sections inserted into.
 void LinkerScript::processInsertCommands() {
   std::vector<BaseCommand *> V;
+  auto Insert = [&](std::vector<BaseCommand *> &From) {
+    V.insert(V.end(), From.begin(), From.end());
+    From.clear();
+  };
+
   for (BaseCommand *Base : SectionCommands) {
+    if (auto *OS = dyn_cast<OutputSection>(Base)) {
+      Insert(InsertBeforeCommands[OS->Name]);
       V.push_back(Base);
-    if (auto *Cmd = dyn_cast<OutputSection>(Base)) {
-      std::vector<BaseCommand *> &W = InsertAfterCommands[Cmd->Name];
-      V.insert(V.end(), W.begin(), W.end());
-      W.clear();
+      Insert(InsertAfterCommands[OS->Name]);
+      continue;
     }
+    V.push_back(Base);
   }
-  for (std::pair<StringRef, std::vector<BaseCommand *>> &P :
-       InsertAfterCommands)
+
+  for (auto &Cmds : {InsertBeforeCommands, InsertAfterCommands})
+    for (const std::pair<StringRef, std::vector<BaseCommand *>> &P : Cmds)
       if (!P.second.empty())
-      error("unable to INSERT AFTER " + P.first + ": section not defined");
+        error("unable to INSERT AFTER/BEFORE " + P.first +
+              ": section not defined");
 
   SectionCommands = std::move(V);
 }
 
 // Symbols defined in script should not be inlined by LTO. At the same time
 // we don't know their final values until late stages of link. Here we scan
 // over symbol assignment commands and create placeholder symbols if needed.
 void LinkerScript::declareSymbols() {

lld/trunk/ELF/ScriptParser.cpp

if (!Cmd) {
         Cmd = readAssert();
       else
         Cmd = readOutputSectionDescription(Tok);
     }
     V.push_back(Cmd);
   }
 
   if (!atEOF() && consume("INSERT")) {
-    expect("AFTER");
-    std::vector<BaseCommand *> &Dest = Script->InsertAfterCommands[next()];
-    Dest.insert(Dest.end(), V.begin(), V.end());
+    std::vector<BaseCommand *> *Dest = nullptr;
+    if (consume("AFTER"))
+      Dest = &Script->InsertAfterCommands[next()];
+    else if (consume("BEFORE"))
+      Dest = &Script->InsertBeforeCommands[next()];
+    else
+      setError("expected AFTER/BEFORE, but got '" + next() + "'");
+    if (Dest)
+      Dest->insert(Dest->end(), V.begin(), V.end());
     return;
   }
 
   Script->SectionCommands.insert(Script->SectionCommands.end(), V.begin(),
                                  V.end());
 }
 
 static int precedence(StringRef Op) {

lld/trunk/test/ELF/linkerscript/insert-after.test

 # CHECK-NEXT:   0               00000000 0000000000000000
 # CHECK-NEXT:   1 .text         00000008 0000000000000000 TEXT DATA
 # CHECK-NEXT:   2 .foo.text     00000008 0000000000000008 TEXT DATA
 # CHECK-NEXT:   3 .data         00000008 0000000000000010 DATA
 # CHECK-NEXT:   4 .foo.data     00000008 0000000000000018 DATA
 
 # RUN: not ld.lld %t1.o -o %t1 --script %s 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=ERR
-# ERR-DAG: error: unable to INSERT AFTER .text: section not defined
-# ERR-DAG: error: unable to INSERT AFTER .data: section not defined
+# ERR-DAG: error: unable to INSERT AFTER/BEFORE .text: section not defined
+# ERR-DAG: error: unable to INSERT AFTER/BEFORE .data: section not defined

lld/trunk/test/ELF/linkerscript/insert-before.test

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/insert-after.s -o %t1.o
+
+## Main linker script contains .text and .data sections. Here
+## we check that can use INSERT BEFORE to insert sections .foo.data
+## and .foo.text at the right places.
+
+SECTIONS {
+  .foo.data : { *(.foo.data) }
+} INSERT BEFORE .data;
+
+SECTIONS {
+  .foo.text : { *(.foo.text) }
+} INSERT BEFORE .text;
+
+# RUN: ld.lld %t1.o -o %t1 --script %p/Inputs/insert-after.script --script %s
+# 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 .foo.text     00000008 0000000000000000 TEXT DATA
+# CHECK-NEXT:   2 .text         00000008 0000000000000008 TEXT DATA
+# CHECK-NEXT:   3 .foo.data     00000008 0000000000000010 DATA
+# CHECK-NEXT:   4 .data         00000008 0000000000000018 DATA
+
+# RUN: not ld.lld %t1.o -o %t1 --script %s 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERR
+# ERR-DAG: error: unable to INSERT AFTER/BEFORE .text: section not defined
+# ERR-DAG: error: unable to INSERT AFTER/BEFORE .data: section not defined

lld/trunk/test/ELF/linkerscript/insert-broken.test

 SECTIONS {
   .foo : { *(.bar) }
 } INSERT .data;
 
 # RUN: not ld.lld -o %t1 --script %s 2>&1 | FileCheck %s
-# CHECK: {{.*}}:3: AFTER expected, but got .data
+# CHECK: {{.*}}:3: expected AFTER/BEFORE, but got '.data'