[ELF] Do not ICF two sections with different output sections (by SECTIONS commands)

[MaskRay]

Summary

Fixes PR39418. Complements D47241 (the non-linker-script case).

processSectionCommands() assigns input sections to output sections.
ICF is called before it, so .text.foo and .text.bar may be folded even if
their output sections are made different by SECTIONS commands.

markLive<ELFT>()
doIcf<ELFT>()                      // During ICF, we don't know the output sections
writeResult()
  combineEhSections<ELFT>()
  script->processSectionCommands() // InputSection -> OutputSection assignment

This patch splits processSectionCommands() into processSectionCommands() and
processSymbolAssignments(), and moves processSectionCommands() before ICF:

markLive<ELFT>()
combineEhSections<ELFT>()
script->processSectionCommands()
doIcf<ELFT>()                      // should remove folded input sections
writeResult()
  script->processSymbolAssignments()

An alternative approach is to unfold a section sec in
processSectionCommands() when we find sec and sec->repl belong to
different output sections. I feel this patch is superior because this
can fold more sections and the decouple of
SectionCommand/SymbolAssignment gives flexibility:

• An ExprValue can't be evaluated before its section is assigned to an output section -> we can delete getOutputSectionVA and simplify another place where we had to check if the output section is null. Moreover, a case in linkerscript/early-assign-symbol.s can be handled now.
• processSectionCommands/processSymbolAssignments can be freely moved around.

[MaskRay]

Add subscribed people in an previous approach D54422

Delete a stale comment
Fix deletion of dead input section members
Improve linkerscript/icf-different-output-sections.s to catch the case

[MaskRay]

Fix the call tree in the description

Simplify processSymbolAssignments

[MaskRay]

I realized EhInputSection and .ARM.exidx* filtering is tricky.
Created D66727 as a prerequisite. This shall make overall diff smaller

[MaskRay]

Delete a stale .ARM.exidx* check.

I think the new processSymbolAssignments() gives us a simple workaround for https://bugs.llvm.org/show_bug.cgi?id=42506

% ld.lld -shared a.o -T a.x -Bsymbolic
ld.lld: error: can't create dynamic relocation R_AARCH64_ABS32 against symbol: __efistub_stext_offset in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
>>> defined in a.x:1
>>> referenced by a.o:(.text+0x4)

If we call script->processSymbolAssignments() the second time, __efistub_stext_offset will be changed to an absolute value.

   // Change values of linker-script-defined symbols from placeholders (assigned
   // by declareSymbols) to actual definitions.
   script->processSymbolAssignments();
+  script->processSymbolAssignments();

% ld.lld -shared a.o -T a.x -Bsymbolic # works

If we say D66279 solves the the value convergence problem, then adding another processSymbolAssignments() can be said to solve the type (absolute or non-absolute) convergence problem.

[grimar]

Given the direction of how linkerscript support is going forward in LLD last time, this approach looks generally good to me.

test/ELF/linkerscript/early-assign-symbol.s

11 ↗

(On Diff #217083)

Since with this patch we can handle the case above, this comment needs either to be moved/removed and/or updated.

test/ELF/linkerscript/icf-different-output-sections.s

45 ↗

(On Diff #217083)

Seems you only need to have a 2 .rodata sections for this test?

I'd suggest testing/demonstrating the output from the 2 scripts here probably:

1. .rodata.foo : { *(.rodata.foo*) } .rodata.bar : { *(.rodata.bar*) }

2. .rodata: { *(.rodata.*) }

I.e. idea is to show in the test that we can put sections in a single or a multiple sections and
that in the case (2) input sections will be folded and in case (1) they will not.

[ruiu]

I like this new approach because it seems more modular than before.

ELF/ICF.cpp

503 ↗

(On Diff #217083)

This comment is perhaps a bit too terse. Can you explain in the comment why we are doing this?

ELF/Writer.cpp

155 ↗

(On Diff #217083)

Maybe this and createSynethticSections should be moved to a new file if they are no longer a part of the writer?

[MaskRay]

ELF/Writer.cpp

155 ↗

(On Diff #217083)

Do you have a recommendation what the new file should be called? While this is under review, I am experimenting other reordering this change will enable (e.g. moving addOrphanSections from Writer.cpp to between processSectionCommands/ICF). The definition of "Writer" is indeed unclear to me now...

[MaskRay]

Delete a redundant dyn_cast<OutputSection>
Add more comments to ICF<ELFT>::run()

[peter.smith]

I agree that this is going in the right direction. I'm particularly happy about splitting out the symbol assignments.

ELF/LinkerScript.cpp

53 ↗

(On Diff #217113)

If we end up calling this with sec->getOutputSection() == nullptr we'll get a segfault that could be hard to track down. It may be worth preserving getOutputSectionVA with an assert non nullptr. Alternatively if we can guarantee that getOutputSection() is non nullptr then we could put an assert into getOutputSection().

ELF/Writer.cpp

155 ↗

(On Diff #217083)

I've not got a good answer right now, will try and have a think. May be worth going through the overall control flow and seeing what comes out. My high-level view of a linker control flow is:

• Load all content from files into an address independent representation.
• Do address independent transformation such as GC and ICF.
• Create synthetic InputSections.
• Layout the output file (InputSections -> OutputSections), although not necessarily assign addresses yet.
• Populate synthetic content such as the .plt and .got. It helps to have removed as much as possible prior to this point.
• Assign addresses.
• Perfom address dependent transformations.
• Finalize addresses (We now have a logical final ELF file).
• Write ELF file.

At each stage we are adding information, permitting more transformations, but also restricting our freedom as making changes invalidates the information. That is a control flow view of the linker, rather than a structural view of the components though.

I think our Writer.cpp combines everything from create synthetic InputSections down. If I were hazarding a guess at a new name for the moved functions I'd recommend something like layout.cpp. In any case it may be worth taking a step back to see what the options are.

[MaskRay]

Restore static uint64_t getOutputSectionVA(SectionBase *sec) { with an assert

[MaskRay]

ELF/LinkerScript.cpp

53 ↗

(On Diff #217113)

We cannot guarantee getOutputSection() returns non nullptr.

merge-gc-piece2.s and gc-sections-non-alloc-to-merge.s are tests where a MergeInputSection may have a null InputSection parent.

I tried adding more asserts to SectionBase::getOutputSection but that seems hard. We probably should do some other layout changes before enforcing nonnullness in getOutputSection.

Restored with an assert.

test/ELF/linkerscript/icf-different-output-sections.s

45 ↗

(On Diff #217083)

I think .rodata* are redundant. I will delete them.

Will add another script for your point (1), and add another script for orphans.

[MaskRay]

Shall we move forward with this change? 🤡

(BTW, Peter's comment at https://reviews.llvm.org/D66717#1646703 is great.)

[grimar]

I have no more comments/objections, I think it is good to go.

[peter.smith]

I'm happy to move forward with the change as well.

[ruiu]

LGTM

I'm happy about this change too.

lld/trunk/ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   replaceCommonSymbols();
 
   // Do size optimizations: garbage collection, merging of SHF_MERGE sections
   // and identical code folding.
   splitSections<ELFT>();
   markLive<ELFT>();
   demoteSharedSymbols();
   mergeSections();
+
+  // Make copies of any input sections that need to be copied into each
+  // partition.
+  copySectionsIntoPartitions();
+
+  // Create synthesized sections such as .got and .plt. This is called before
+  // processSectionCommands() so that they can be placed by SECTIONS commands.
+  createSyntheticSections<ELFT>();
+
+  // Some input sections that are used for exception handling need to be moved
+  // into synthetic sections. Do that now so that they aren't assigned to
+  // output sections in the usual way.
+  if (!config->relocatable)
+    combineEhSections();
+
+  // Create output sections described by SECTIONS commands.
+  script->processSectionCommands();
+
+  // Two input sections with different output sections should not be folded.
+  // ICF runs after processSectionCommands() so that we know the output sections.
   if (config->icf != ICFLevel::None) {
     findKeepUniqueSections<ELFT>(args);
     doIcf<ELFT>();
   }
 
   // Read the callgraph now that we know what was gced or icfed
   if (config->callGraphProfileSort) {
     if (auto *arg = args.getLastArg(OPT_call_graph_ordering_file))
       if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
         readCallGraph(*buffer);
     readCallGraphsFromObjectFiles<ELFT>();
   }
 
   // Write the result to the file.
   writeResult<ELFT>();
 }

lld/trunk/ELF/ICF.cpp

 // [1] Safe ICF: Pointer Safe and Unwinding aware Identical Code Folding
 // in the Gold Linker
 // http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36912.pdf
 //
 //===----------------------------------------------------------------------===//
 
 #include "ICF.h"
 #include "Config.h"
+#include "LinkerScript.h"
+#include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Writer.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ELF.h"

 // except relocation targets.
 template <class ELFT>
 bool ICF<ELFT>::equalsConstant(const InputSection *a, const InputSection *b) {
   if (a->numRelocations != b->numRelocations || a->flags != b->flags ||
       a->getSize() != b->getSize() || a->data() != b->data())
     return false;
 
   // If two sections have different output sections, we cannot merge them.
-  // FIXME: This doesn't do the right thing in the case where there is a linker
-  // script. We probably need to move output section assignment before ICF to
-  // get the correct behaviour here.
-  if (getOutputSectionName(a) != getOutputSectionName(b))
+  if (getOutputSectionName(a) != getOutputSectionName(b) ||
+      a->getParent() != b->getParent())
     return false;
 
   if (a->areRelocsRela)
     return constantEq(a, a->template relas<ELFT>(), b,
                       b->template relas<ELFT>());
   return constantEq(a, a->template rels<ELFT>(), b, b->template rels<ELFT>());
 }
 
for (size_t i = begin + 1; i < end; ++i) {
 
       // At this point we know sections merged are fully identical and hence
       // we want to remove duplicate implicit dependencies such as link order
       // and relocation sections.
       for (InputSection *isec : sections[i]->dependentSections)
         isec->markDead();
     }
   });
+
+  // InputSectionDescription::sections is populated by processSectionCommands().
+  // ICF may fold some input sections assigned to output sections. Remove them.
+  for (BaseCommand *base : script->sectionCommands)
+    if (auto *sec = dyn_cast<OutputSection>(base))
+      for (BaseCommand *sub_base : sec->sectionCommands)
+        if (auto *isd = dyn_cast<InputSectionDescription>(sub_base))
+          llvm::erase_if(isd->sections,
+                         [](InputSection *isec) { return !isec->isLive(); });
 }
 
 // ICF entry point function.
 template <class ELFT> void elf::doIcf() { ICF<ELFT>().run(); }
 
 template void elf::doIcf<ELF32LE>();
 template void elf::doIcf<ELF32BE>();
 template void elf::doIcf<ELF64LE>();
 template void elf::doIcf<ELF64BE>();

lld/trunk/ELF/LinkerScript.h

public:
 
   std::vector<PhdrEntry *> createPhdrs();
   bool needsInterpSection();
 
   bool shouldKeep(InputSectionBase *s);
   const Defined *assignAddresses();
   void allocateHeaders(std::vector<PhdrEntry *> &phdrs);
   void processSectionCommands();
+  void processSymbolAssignments();
   void declareSymbols();
 
   // Used to handle INSERT AFTER statements.
   void processInsertCommands();
 
   // SECTIONS command list.
   std::vector<BaseCommand *> sectionCommands;
 

lld/trunk/ELF/LinkerScript.cpp

 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
 LinkerScript *elf::script;
 
-static uint64_t getOutputSectionVA(SectionBase *inputSec, StringRef loc) {
-  if (OutputSection *os = inputSec->getOutputSection())
-    return os->addr;
-  error(loc + ": unable to evaluate expression: input section " +
-        inputSec->name + " has no output section assigned");
-  return 0;
+static uint64_t getOutputSectionVA(SectionBase *sec) {
+  OutputSection *os = sec->getOutputSection();
+  assert(os && "input section has no output section assigned");
+  return os ? os->addr : 0;
 }
 
 uint64_t ExprValue::getValue() const {
   if (sec)
-    return alignTo(sec->getOffset(val) + getOutputSectionVA(sec, loc),
+    return alignTo(sec->getOffset(val) + getOutputSectionVA(sec),
                    alignment);
   return alignTo(val, alignment);
 }
 
 uint64_t ExprValue::getSecAddr() const {
   if (sec)
-    return sec->getOffset(0) + getOutputSectionVA(sec, loc);
+    return sec->getOffset(0) + getOutputSectionVA(sec);
   return 0;
 }
 
 uint64_t ExprValue::getSectionOffset() const {
   // If the alignment is trivial, we don't have to compute the full
   // value to know the offset. This allows this function to succeed in
   // cases where the output section is not yet known.
-  if (alignment == 1 && (!sec || !sec->getOutputSection()))
+  if (alignment == 1 && !sec)
     return val;
   return getValue() - getSecAddr();
 }
 
 OutputSection *LinkerScript::createOutputSection(StringRef name,
                                                  StringRef location) {
   OutputSection *&secRef = nameToOutputSection[name];
   OutputSection *sec;
static bool shouldDefineSym(SymbolAssignment *cmd) {
   // If a symbol was in PROVIDE(), we need to define it only
   // when it is a referenced undefined symbol.
   Symbol *b = symtab->find(cmd->name);
   if (b && !b->isDefined())
     return true;
   return false;
 }
 
-// This function is called from processSectionCommands,
-// while we are fixing the output section layout.
+// Called by processSymbolAssignments() to assign definitions to
+// linker-script-defined symbols.
 void LinkerScript::addSymbol(SymbolAssignment *cmd) {
   if (!shouldDefineSym(cmd))
     return;
 
   // Define a symbol.
   ExprValue value = cmd->expression();
   SectionBase *sec = value.isAbsolute() ? nullptr : value.sec;
   uint8_t visibility = cmd->hidden ? STV_HIDDEN : STV_DEFAULT;
for (BaseCommand *base : outCmd.sectionCommands) {
     if (auto *cmd = dyn_cast<InputSectionDescription>(base)) {
       cmd->sections = computeInputSections(cmd);
       ret.insert(ret.end(), cmd->sections.begin(), cmd->sections.end());
     }
   }
   return ret;
 }
 
+// Create output sections described by SECTIONS commands.
 void LinkerScript::processSectionCommands() {
-  // A symbol can be assigned before any section is mentioned in the linker
-  // script. In an DSO, the symbol values are addresses, so the only important
-  // section values are:
-  // * SHN_UNDEF
-  // * SHN_ABS
-  // * Any value meaning a regular section.
-  // To handle that, create a dummy aether section that fills the void before
-  // the linker scripts switches to another section. It has an index of one
-  // which will map to whatever the first actual section is.
-  aether = make<OutputSection>("", 0, SHF_ALLOC);
-  aether->sectionIndex = 1;
-
-  // Ctx captures the local AddressState and makes it accessible deliberately.
-  // This is needed as there are some cases where we cannot just
-  // thread the current state through to a lambda function created by the
-  // script parser.
-  auto deleter = std::make_unique<AddressState>();
-  ctx = deleter.get();
-  ctx->outSec = aether;
-
   size_t i = 0;
-  // Add input sections to output sections.
   for (BaseCommand *base : sectionCommands) {
-    // Handle symbol assignments outside of any output section.
-    if (auto *cmd = dyn_cast<SymbolAssignment>(base)) {
-      addSymbol(cmd);
-      continue;
-    }
-
     if (auto *sec = dyn_cast<OutputSection>(base)) {
       std::vector<InputSection *> v = createInputSectionList(*sec);
 
       // The output section name `/DISCARD/' is special.
       // Any input section assigned to it is discarded.
       if (sec->name == "/DISCARD/") {
         discard(v);
         sec->sectionCommands.clear();
if (auto *sec = dyn_cast<OutputSection>(base)) {
       // way to "make it as if it wasn't present" is to make it empty.
       if (!matchConstraints(v, sec->constraint)) {
         for (InputSectionBase *s : v)
           s->assigned = false;
         sec->sectionCommands.clear();
         continue;
       }
 
-      // A directive may contain symbol definitions like this:
-      // ".foo : { ...; bar = .; }". Handle them.
-      for (BaseCommand *base : sec->sectionCommands)
-        if (auto *outCmd = dyn_cast<SymbolAssignment>(base))
-          addSymbol(outCmd);
-
       // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
       // is given, input sections are aligned to that value, whether the
       // given value is larger or smaller than the original section alignment.
       if (sec->subalignExpr) {
         uint32_t subalign = sec->subalignExpr().getValue();
         for (InputSectionBase *s : v)
           s->alignment = subalign;
       }
 
-      // Add input sections to an output section.
+      // Some input sections may be removed from the list after ICF.
       for (InputSection *s : v)
         sec->addSection(s);
 
       sec->sectionIndex = i++;
       if (sec->noload)
         sec->type = SHT_NOBITS;
       if (sec->nonAlloc)
         sec->flags &= ~(uint64_t)SHF_ALLOC;
     }
   }
+}
+
+void LinkerScript::processSymbolAssignments() {
+  // Dot outside an output section still represents a relative address, whose
+  // sh_shndx should not be SHN_UNDEF or SHN_ABS. Create a dummy aether section
+  // that fills the void outside a section. It has an index of one, which is
+  // indistinguishable from any other regular section index.
+  aether = make<OutputSection>("", 0, SHF_ALLOC);
+  aether->sectionIndex = 1;
+
+  // ctx captures the local AddressState and makes it accessible deliberately.
+  // This is needed as there are some cases where we cannot just thread the
+  // current state through to a lambda function created by the script parser.
+  AddressState state;
+  ctx = &state;
+  ctx->outSec = aether;
+
+  for (BaseCommand *base : sectionCommands) {
+    if (auto *cmd = dyn_cast<SymbolAssignment>(base))
+      addSymbol(cmd);
+    else
+      for (BaseCommand *sub_base : cast<OutputSection>(base)->sectionCommands)
+        if (auto *cmd = dyn_cast<SymbolAssignment>(sub_base))
+          addSymbol(cmd);
+  }
+
   ctx = nullptr;
 }
 
 static OutputSection *findByName(ArrayRef<BaseCommand *> vec,
                                  StringRef name) {
   for (BaseCommand *base : vec)
     if (auto *sec = dyn_cast<OutputSection>(base))
       if (sec->name == name)

lld/trunk/ELF/Writer.h

 #include <cstdint>
 #include <memory>
 
 namespace lld {
 namespace elf {
 class InputFile;
 class OutputSection;
 class InputSectionBase;
+void copySectionsIntoPartitions();
+template <class ELFT> void createSyntheticSections();
 void combineEhSections();
 template <class ELFT> void writeResult();
 
 // This describes a program header entry.
 // Each contains type, access flags and range of output sections that will be
 // placed in it.
 struct PhdrEntry {
   PhdrEntry(unsigned type, unsigned flags) : p_type(type), p_flags(flags) {}

lld/trunk/ELF/Writer.cpp

if (p->p_type != PT_LOAD)
       return false;
     if (!p->firstSec)
       return true;
     uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr;
     return size == 0;
   });
 }
 
-static void copySectionsIntoPartitions() {
+void elf::copySectionsIntoPartitions() {
   std::vector<InputSectionBase *> newSections;
   for (unsigned part = 2; part != partitions.size() + 1; ++part) {
     for (InputSectionBase *s : inputSections) {
       if (!(s->flags & SHF_ALLOC) || !s->isLive())
         continue;
       InputSectionBase *copy;
       if (s->type == SHT_NOTE)
         copy = make<InputSection>(cast<InputSection>(*s));

 static OutputSection *findSection(StringRef name, unsigned partition = 1) {
   for (BaseCommand *base : script->sectionCommands)
     if (auto *sec = dyn_cast<OutputSection>(base))
       if (sec->name == name && sec->partition == partition)
         return sec;
   return nullptr;
 }
 
-// Initialize Out members.
-template <class ELFT> static void createSyntheticSections() {
+template <class ELFT> void elf::createSyntheticSections() {
   // Initialize all pointers with NULL. This is needed because
   // you can call lld::elf::main more than once as a library.
   memset(&Out::first, 0, sizeof(Out));
 
   auto add = [](InputSectionBase *sec) { inputSections.push_back(sec); };
 
   in.shStrTab = make<StringTableSection>(".shstrtab", false);
 
if (in.symTabShndx)
     add(in.symTabShndx);
   add(in.shStrTab);
   if (in.strTab)
     add(in.strTab);
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
-  // Make copies of any input sections that need to be copied into each
-  // partition.
-  copySectionsIntoPartitions();
-
-  // Create linker-synthesized sections such as .got or .plt.
-  // Such sections are of type input section.
-  createSyntheticSections<ELFT>();
-
-  // Some input sections that are used for exception handling need to be moved
-  // into synthetic sections. Do that now so that they aren't assigned to
-  // output sections in the usual way.
-  if (!config->relocatable)
-    combineEhSections();
-
-  // We want to process linker script commands. When SECTIONS command
-  // is given we let it create sections.
-  script->processSectionCommands();
-
   // Linker scripts controls how input sections are assigned to output sections.
   // Input sections that were not handled by scripts are called "orphans", and
   // they are assigned to output sections by the default rule. Process that.
   script->addOrphanSections();
 
   if (config->discard != DiscardPolicy::All)
     copyLocalSymbols();
 
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // pieces. The relocation scan uses those pieces, so this has to be
   // earlier.
   for (Partition &part : partitions)
     finalizeSynthetic(part.ehFrame);
 
   symtab->forEachSymbol(
       [](Symbol *s) { s->isPreemptible = computeIsPreemptible(*s); });
 
+  // Change values of linker-script-defined symbols from placeholders (assigned
+  // by declareSymbols) to actual definitions.
+  script->processSymbolAssignments();
+
   // Scan relocations. This must be done after every symbol is declared so that
-  // we can correctly decide if a dynamic relocation is needed.
+  // we can correctly decide if a dynamic relocation is needed. This is called
+  // after processSymbolAssignments() because it needs to know whether a
+  // linker-script-defined symbol is absolute.
   if (!config->relocatable) {
     forEachRelSec(scanRelocations<ELFT>);
     reportUndefinedSymbols<ELFT>();
   }
 
   if (in.plt && in.plt->isNeeded())
     in.plt->addSymbols();
   if (in.iplt && in.iplt->isNeeded())
case BuildIdKind::Uuid:
     break;
   default:
     llvm_unreachable("unknown BuildIdKind");
   }
   for (Partition &part : partitions)
     part.buildId->writeBuildId(buildId);
 }
 
+template void elf::createSyntheticSections<ELF32LE>();
+template void elf::createSyntheticSections<ELF32BE>();
+template void elf::createSyntheticSections<ELF64LE>();
+template void elf::createSyntheticSections<ELF64BE>();
+
 template void elf::writeResult<ELF32LE>();
 template void elf::writeResult<ELF32BE>();
 template void elf::writeResult<ELF64LE>();
 template void elf::writeResult<ELF64BE>();

lld/trunk/test/ELF/linkerscript/early-assign-symbol.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 
-# RUN: echo "SECTIONS { aaa = foo | 1; .text  : { *(.text*) } }" > %t3.script
-# RUN: not ld.lld -o %t --script %t3.script %t.o 2>&1 | FileCheck %s
+## The definitions of symbol assignments may reference other symbols.
+## Test we can handle them.
 
-# CHECK: error: {{.*}}.script:1: unable to evaluate expression: input section .text has no output section assigned
+# RUN: echo "SECTIONS { aaa = foo | 1; .text  : { *(.text*) } }" > %t3.script
+# RUN: ld.lld -o %t --script %t3.script %t.o
+# RUN: llvm-objdump -t %t | FileCheck --check-prefix=VAL1 %s
 
-# Simple cases that we can handle.
+# VAL1: 0000000000000000 .text 00000000 foo
+# VAL1: 0000000000000001 .text 00000000 aaa
 
 # RUN: echo "SECTIONS { aaa = ABSOLUTE(foo - 1) + 1; .text  : { *(.text*) } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -t %t | FileCheck --check-prefix=VAL %s
 
 # RUN: echo "SECTIONS { aaa = 1 + ABSOLUTE(foo - 1); .text  : { *(.text*) } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -t %t | FileCheck --check-prefix=VAL %s

lld/trunk/test/ELF/linkerscript/icf-output-sections.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: echo 'SECTIONS { .text : { *(.text*) } }' > %t1.script
+
+## Sections within the same output section can be freely folded.
+# RUN: ld.lld %t.o --script %t1.script --icf=all --print-icf-sections -o %t | FileCheck --check-prefix=ICF1 %s
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC1 %s --implicit-check-not=.text
+
+# ICF1:      selected section {{.*}}.o:(.text.foo0)
+# ICF1-NEXT:   removing identical section {{.*}}.o:(.text.foo1)
+# ICF1-NEXT:   removing identical section {{.*}}.o:(.text.bar0)
+# ICF1-NEXT:   removing identical section {{.*}}.o:(.text.bar1)
+
+# SEC1: .text   PROGBITS 0000000000000000 001000 000001
+
+## Sections with different output sections cannot be folded. Without the
+## linker script, .text.foo* and .text.bar* go to the same output section
+## .text and they will be folded.
+# RUN: echo 'SECTIONS { .text.foo : {*(.text.foo*)} .text.bar : {*(.text.bar*)} }' > %t2.script
+# RUN: ld.lld %t.o --script %t2.script --icf=all --print-icf-sections -o %t | FileCheck --check-prefix=ICF2 %s
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC2 %s
+
+# ICF2:      selected section {{.*}}.o:(.text.foo0)
+# ICF2-NEXT:   removing identical section {{.*}}.o:(.text.foo1)
+# ICF2-NEXT: selected section {{.*}}.o:(.text.bar0)
+# ICF2-NEXT:   removing identical section {{.*}}.o:(.text.bar1)
+
+# SEC2:      .text.foo   PROGBITS 0000000000000000 001000 000001
+# SEC2-NEXT: .text.bar   PROGBITS 0000000000000001 001001 000001
+
+## .text.bar* are orphans that get assigned to .text.
+# RUN: echo 'SECTIONS { .text.foo : {*(.text.foo*)} }' > %t3.script
+# RUN: ld.lld %t.o --script %t3.script --icf=all --print-icf-sections -o %t | FileCheck --check-prefix=ICF2 %s
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC3 %s
+
+# SEC3:      .text.foo   PROGBITS 0000000000000000 001000 000001
+# SEC3-NEXT: .text       PROGBITS 0000000000000004 001004 000001
+
+.section .text.foo0,"ax"
+ret
+.section .text.foo1,"ax"
+ret
+.section .text.bar0,"ax"
+ret
+.section .text.bar1,"ax"
+ret

lld/trunk/test/ELF/linkerscript/subalign.s

 # RUN: echo "SECTIONS { .aaa : SUBALIGN(1) { *(.aaa.*) } }" > %t2.script
 # RUN: ld.lld -o %t2 --script %t2.script %t1.o
 # RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SUBALIGN %s
 # SUBALIGN: Contents of section .aaa:
 # SUBALIGN:   01000000 00000000 02000000 00000000
 # SUBALIGN:   03000000 00000000 04000000 00000000
 
 ## Test we do not assert or crash when dot(.) is used inside SUBALIGN.
-## ld.bfd does not allow to use dot in such expressions, our behavior is
-## different for simplicity of implementation. Value of dot is undefined.
+## Value of dot is undefined. Some versions of ld.bfd do not allow to use dot
+## in such expressions.
 # RUN: echo "SECTIONS { . = 0x32; .aaa : SUBALIGN(.) { *(.aaa*) } }" > %t3.script
-# RUN: ld.lld %t1.o --script %t3.script -o %t3
-# RUN: llvm-objdump -s %t3 > /dev/null
+# RUN: not ld.lld %t1.o --script %t3.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERR1 %s
+# ERR1: {{.*}}.script:1: unable to get location counter value
 
 ## Test we are able to link with zero alignment, this is consistent with bfd 2.26.1.
 # RUN: echo "SECTIONS { .aaa : SUBALIGN(0) { *(.aaa*) } }" > %t4.script
 # RUN: ld.lld %t1.o --script %t4.script -o %t4
 # RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SUBALIGN %s
 
 ## Test we fail gracefuly when alignment value is not a power of 2.
 # RUN: echo "SECTIONS { .aaa : SUBALIGN(3) { *(.aaa*) } }" > %t5.script
-# RUN: not ld.lld %t1.o --script %t5.script -o /dev/null 2>&1 | FileCheck -check-prefix=ERR %s
-# ERR: {{.*}}.script:1: alignment must be power of 2
+# RUN: not ld.lld %t1.o --script %t5.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERR2 %s
+# ERR2: {{.*}}.script:1: alignment must be power of 2
 
 .global _start
 _start:
  nop
 
 .section .aaa.1, "a"
 .align 16
 .quad 1