[ELF] - Linkerscript: implement REGION_ALIAS.

[grimar]

Summary

REGION_ALIAS(alias, region)

Alias names can be added to existing memory regions created with
the MEMORY command. Each name corresponds to at most one
memory region.

Used in many scripts that can be found in the wild.
Patch implements it.

[grimar]

• Updated testcase (added missing quote escapes).

[ruiu]

ELF/ScriptParser.cpp

403

It'll eventually fail if you call setError, so don't worry too much about ErrorCount. I'd remove this if and execute the following line unconditionally.

1240–1242

Does this work?

Script->Opt.MemoryRegions[Name] =
  make<MemoryRegion>(Name, Origin, Length, Flags, NegFlags);

[grimar]

• Addressed comments.
• Formatted testcase to 80 columns.

ELF/ScriptParser.cpp

403

Done.

1240–1242

Nope. Error is: "'lld::elf::MemoryRegion::MemoryRegion': no overloaded function takes 5 arguments",
that is why I did not do that initially. I believe it will work if we add constructor taking these 5 to
MemoryRegion, but does not seems it really worth to do for me.

[ruiu]

ELF/ScriptParser.cpp

1240–1242

Then how about this?

Script->Opt.MemoryRegions[Name] =
  make<MemoryRegion>({Name, Origin, Length, Flags, NegFlags});

[grimar]

ELF/ScriptParser.cpp

1240–1242

That was first I tried initially, it will error out:
error C2660: 'lld::elf::make': function does not take 1 arguments

As I mentioned, with constructor taking this arguments it is possible to use

Script->Opt.MemoryRegions[Name] =
  make<MemoryRegion>(Name, Origin, Length, Flags, NegFlags);

Do you want me to add constructor ?

[ruiu]

LGTM

ELF/ScriptParser.cpp

1240–1242

Do you want me to add constructor ?

No, as it's not overall a win.

ELF/LinkerScript.h

struct ScriptConfiguration {
 
   bool HasSections = false;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<InputSectionDescription *> KeptSections;
 
   // A map from memory region name to a memory region descriptor.
-  llvm::DenseMap<llvm::StringRef, MemoryRegion> MemoryRegions;
+  llvm::DenseMap<llvm::StringRef, MemoryRegion *> MemoryRegions;
 
   // A list of symbols referenced by the script.
   std::vector<llvm::StringRef> ReferencedSymbols;
 };
 
 class LinkerScript final {
   // Temporary state used in processCommands() and assignAddresses()
   // that must be reinitialized for each call to the above functions, and must

ELF/LinkerScript.cpp

 // section in. If found, a pointer to the appropriate memory region is
 // returned. Otherwise, a nullptr is returned.
 MemoryRegion *LinkerScript::findMemoryRegion(OutputSection *Sec) {
   // If a memory region name was specified in the output section command,
   // then try to find that region first.
   if (!Sec->MemoryRegionName.empty()) {
     auto It = Opt.MemoryRegions.find(Sec->MemoryRegionName);
     if (It != Opt.MemoryRegions.end())
-      return &It->second;
+      return It->second;
     error("memory region '" + Sec->MemoryRegionName + "' not declared");
     return nullptr;
   }
 
   // If at least one memory region is defined, all sections must
   // belong to some memory region. Otherwise, we don't need to do
   // anything for memory regions.
   if (Opt.MemoryRegions.empty())
     return nullptr;
 
   // See if a region can be found by matching section flags.
   for (auto &Pair : Opt.MemoryRegions) {
-    MemoryRegion &M = Pair.second;
-    if ((M.Flags & Sec->Flags) && (M.NegFlags & Sec->Flags) == 0)
-      return &M;
+    MemoryRegion *M = Pair.second;
+    if ((M->Flags & Sec->Flags) && (M->NegFlags & Sec->Flags) == 0)
+      return M;
   }
 
   // Otherwise, no suitable region was found.
   if (Sec->Flags & SHF_ALLOC)
     error("no memory region specified for section '" + Sec->Name + "'");
   return nullptr;
 }
 
void LinkerScript::allocateHeaders(std::vector<PhdrEntry *> &Phdrs) {
   }
 
   llvm::erase_if(Phdrs,
                  [](const PhdrEntry *E) { return E->p_type == PT_PHDR; });
 }
 
 LinkerScript::AddressState::AddressState(const ScriptConfiguration &Opt) {
   for (auto &MRI : Opt.MemoryRegions) {
-    const MemoryRegion *MR = &MRI.second;
+    const MemoryRegion *MR = MRI.second;
     MemRegionOffset[MR] = MR->Origin;
   }
 }
 
 void LinkerScript::assignAddresses() {
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
   auto State = make_unique<AddressState>(Opt);

ELF/ScriptParser.cpp

private:
   void readExtern();
   void readGroup();
   void readInclude();
   void readMemory();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readPhdrs();
+  void readRegionAlias();
   void readSearchDir();
   void readSections();
   void readVersion();
   void readVersionScriptCommand();
 
   SymbolAssignment *readAssignment(StringRef Name);
   BytesDataCommand *readBytesDataCommand(StringRef Tok);
   uint32_t readFill();
while (!atEOF()) {
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
     } else if (Tok == "PHDRS") {
       readPhdrs();
+    } else if (Tok == "REGION_ALIAS") {
+      readRegionAlias();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
     } else if (Tok == "SECTIONS") {
       readSections();
     } else if (Tok == "VERSION") {
       readVersion();
     } else if (SymbolAssignment *Cmd = readProvideOrAssignment(Tok)) {
       Script->Opt.Commands.push_back(Cmd);
while (!ErrorCount && !consume(";")) {
       else if (consume("FLAGS"))
         PhdrCmd.Flags = readParenExpr()().getValue();
       else
         setError("unexpected header attribute: " + next());
     }
   }
 }
 
+void ScriptParser::readRegionAlias() {
+  expect("(");
+  StringRef Alias = unquote(next());
+  expect(",");
+  StringRef Name = next();
+  expect(")");
+
+  if (Script->Opt.MemoryRegions.count(Alias))
+    setError("redefinition of memory region '" + Alias + "'");
+  if (!Script->Opt.MemoryRegions.count(Name))
+    setError("memory region '" + Name + "' is not defined");
+  if (!ErrorCount)
+    Script->Opt.MemoryRegions[Alias] = Script->Opt.MemoryRegions[Name];
+}
+
 void ScriptParser::readSearchDir() {
   expect("(");
   StringRef Tok = next();
   if (!Config->Nostdlib)
     Config->SearchPaths.push_back(unquote(Tok));
   expect(")");
 }
 
Expr ScriptParser::readPrimary() {
   if (Tok == "DEFINED") {
     StringRef Name = readParenLiteral();
     return [=] { return Script->isDefined(Name) ? 1 : 0; };
   }
   if (Tok == "LENGTH") {
     StringRef Name = readParenLiteral();
     if (Script->Opt.MemoryRegions.count(Name) == 0)
       setError("memory region not defined: " + Name);
-    return [=] { return Script->Opt.MemoryRegions[Name].Length; };
+    return [=] { return Script->Opt.MemoryRegions[Name]->Length; };
   }
   if (Tok == "LOADADDR") {
     StringRef Name = readParenLiteral();
     OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
     return [=] { return checkSection(Cmd, Location)->getLMA(); };
   }
   if (Tok == "ORIGIN") {
     StringRef Name = readParenLiteral();
     if (Script->Opt.MemoryRegions.count(Name) == 0)
       setError("memory region not defined: " + Name);
-    return [=] { return Script->Opt.MemoryRegions[Name].Origin; };
+    return [=] { return Script->Opt.MemoryRegions[Name]->Origin; };
   }
   if (Tok == "SEGMENT_START") {
     expect("(");
     skip();
     expect(",");
     Expr E = readExpr();
     expect(")");
     return [=] { return E(); };
if (consume("(")) {
       expect(")");
     }
     expect(":");
 
     uint64_t Origin = readMemoryAssignment("ORIGIN", "org", "o");
     expect(",");
     uint64_t Length = readMemoryAssignment("LENGTH", "len", "l");
 
-    // Add the memory region to the region map (if it doesn't already exist).
-    auto It = Script->Opt.MemoryRegions.find(Name);
-    if (It != Script->Opt.MemoryRegions.end())
+    // Add the memory region to the region map.
+    if (Script->Opt.MemoryRegions.count(Name))
       setError("region '" + Name + "' already defined");
-    else
-      Script->Opt.MemoryRegions[Name] = {Name, Origin, Length, Flags, NegFlags};
+    MemoryRegion *MR = make<MemoryRegion>();
+    *MR = {Name, Origin, Length, Flags, NegFlags};
+    Script->Opt.MemoryRegions[Name] = MR;
   }
 }
 
 // This function parses the attributes used to match against section
 // flags when placing output sections in a memory region. These flags
 // are only used when an explicit memory region name is not used.
 std::pair<uint32_t, uint32_t> ScriptParser::readMemoryAttributes() {
   uint32_t Flags = 0;

test/ELF/linkerscript/region-alias.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "MEMORY {                                  \
+# RUN:   ROM (rwx): ORIGIN = 0x1000, LENGTH = 0x100    \
+# RUN:   RAM (rwx): ORIGIN = 0x2000, LENGTH = 0x100    \
+# RUN: }                                               \
+# RUN: INCLUDE \"%t.script.inc\"                       \
+# RUN: SECTIONS {                                      \
+# RUN:  .text : { *(.text*) } > ALIAS_TEXT             \
+# RUN:  .data : { *(.data*) } > ALIAS_DATA             \
+# RUN: }" > %t.script
+
+## .text to ROM, .data to RAM.
+# RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" > %t.script.inc
+# RUN: echo "REGION_ALIAS (\"ALIAS_DATA\", RAM);" >> %t.script.inc
+# RUN: ld.lld %t --script %t.script -o %t2
+# RUN: llvm-objdump -section-headers %t2 | FileCheck %s
+# CHECK: .text       00000001 0000000000001000 TEXT DATA
+# CHECK: .data       00000008 0000000000002000 DATA
+
+## All to ROM.
+# RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" > %t.script.inc
+# RUN: echo "REGION_ALIAS (\"ALIAS_DATA\", ROM);" >> %t.script.inc
+# RUN: ld.lld %t --script %t.script -o %t2
+# RUN: llvm-objdump -section-headers %t2 | FileCheck %s --check-prefix=RAM
+# RAM: .text         00000001 0000000000001000 TEXT DATA
+# RAM: .data         00000008 0000000000001001 DATA
+
+## Redefinition of region.
+# RUN: echo "REGION_ALIAS (\"ROM\", ROM);" > %t.script.inc
+# RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | FileCheck %s --check-prefix=ERR1
+# ERR1: {{.*}}script.inc:1: redefinition of memory region 'ROM'
+
+## Redefinition of alias.
+# RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" > %t.script.inc
+# RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", ROM);" >> %t.script.inc
+# RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | FileCheck %s --check-prefix=ERR2
+# ERR2: {{.*}}script.inc:2: redefinition of memory region 'ALIAS_TEXT'
+
+## Attemp to create an alias for undefined region.
+# RUN: echo "REGION_ALIAS (\"ALIAS_TEXT\", FOO);" > %t.script.inc
+# RUN: not ld.lld %t --script %t.script -o %t2 2>&1 | FileCheck %s --check-prefix=ERR3
+# ERR3: {{.*}}script.inc:1: memory region 'FOO' is not defined
+
+.text
+.global _start
+_start:
+ nop
+
+.section .data,"aw"
+.quad 0