[ELF2] - Basic implementation of -r/--relocatable

[grimar]

Summary

Currently does not have support for files containing relocation sections with entries that refer to local symbols (like rel[a].eh_frame which refer to sections and not to symbols).

[grimar]

ELF/OutputSections.cpp

642

Sorry, forgot about that "true ?", will fix in updated patch.

[ruiu]

I took a quick look at the code. This patch doesn't remove relocations that were successfully resolved within an object file the linker is writing, does this? Is it hard to support that? I think that's the reason why users want to use -r in the first place (so that the number of relocations in a combined object file is much smaller than the total number of relocations in the input files.) If it's going to be more code, it's fine to do in a follow up patch, though.

ELF/Driver.cpp

155

Move this into the code block above and sort.

ELF/InputFiles.cpp

211–213

I'd use cast<> instead of dyn_cast<> and remove the check.

[grimar]

In D14382#282370, @ruiu wrote:

I took a quick look at the code. This patch doesn't remove relocations that were successfully resolved within an object file the linker is writing, does this? Is it hard to support that? I think that's the reason why users want to use -r in the first place (so that the number of relocations in a combined object file is much smaller than the total number of relocations in the input files.) If it's going to be more code, it's fine to do in a follow up patch, though.

Actually no relocations are applied atm. See ELF/InputFiles.cpp (215) has "break;" so nothing is added to S->RelocSections list and no relocations resolved during that link because of that. I can put correcting that into plan at first place but would be nice to split this to following patches. That one looks large already.

I am also have plan to add support for rel[a].eh_frame sections in following one(s) as well.

ELF/Driver.cpp

155

Ok. I just wasn`t sure here how to highlight that Relocatable affects on other options. Thats why put it outside as well.

[grimar]

In D14382#282370, @ruiu wrote:

I took a quick look at the code. This patch doesn't remove relocations that were successfully resolved within an object file the linker is writing, does this? Is it hard to support that?

I also didnt investigate that case yet. For test case ld behaves in the same way as lld now. No any relocations happen for R_X86_64_32S and I didn`t look at other ones.

[ruiu]

I'd like to see a patch to apply (and reduce) relocations. This patch seems generally good, but there's a chance that the fields and functions added in this patch will not make sense with the follow-up patch. We don't have to combine all changes into one patch, but can split into a series of patches.

[• rafael]

I don't think traditional linkers resolve relocations during -r.

I would probably delay implementing that if so. A simple -r should help us
with linking freebsd.

Cheers, Rafael

[grimar]

In D14382#282400, @ruiu wrote:

I'd like to see a patch to apply (and reduce) relocations. This patch seems generally good, but there's a chance that the fields and functions added in this patch will not make sense with the follow-up patch. We don't have to combine all changes into one patch, but can split into a series of patches.

Well I tried to build some background. All added functions/variables are mostly used for -r option which implementation is a subject to change anyways since it is initial.
I understand the core idea you want to see in this patch at first though. So if reducing relocations is needed for it initial commit, I can handle that I think. Currently I dont know the valid test case for that yet (which exactly relocations can be applied during relocatable output linking). If you could say what can I use then that info will be really helpfull, if not I`ll try to investigate that tomorrow.

[grimar]

In D14382#282433, @rafael wrote:

I don't think traditional linkers resolve relocations during -r.

I would probably delay implementing that if so. A simple -r should help us
with linking freebsd.

Cheers, Rafael

Sounds good :)

[grimar]

That said, great to see -r implemented, I plan to take a closer look
at this patch for review in the next days.

Just in case only basic implementation is done atm. I still plan to work on rel[a].eh_frame relocation sections support.

[grimar]

So according to Joerg in "llvm-commits Digest, Vol 137, Issue 69" this one seems to be useful ? Or not ?

[grimar]

elf2 does not need that it seems

[ruiu]

ELF/Driver.cpp

156–162

Move this to checkOptions.

ELF/InputFiles.cpp

209

This needs a description. (Any piece of code that does something obvious needs explanation.)

It is probably better to explain how you are handling object files if -r.

ELF/InputSection.cpp

95–107

I don't think this is a right place to add this code. This is more like copying existing relocations rather than relocating. You want to create a new function to copy relocation sections instead of embedding here.

149–159

This code is not very readable -- you defined a vector with only one element and run a for-loop over that vector? It is probably better to just call a different function if we find that we are handling a relocation section.

ELF/InputSection.h

120

// If -r (or --relocatable) option is given, this member may have a non-null value.
// During partial linking, we do not apply any relocations but just leave them as is,
// expecting the final static linking applies them all at once.
// In that case, relocation sections are handled as regular input sections, and their
// RelocatingSection pointers point to their target sections.

ELF/OutputSections.cpp

174

Why did you change the function name? If not relevant to this change, please revert.

639

Remove this temporary variable and directly assign to this->Header.

646–649

I'm not quite sure what you are doing here.

654–655

Is it possible that we do not have the symbol table if -r is specified?

942

Why did you need this change?

948

What is this for?

ELF/OutputSections.h

235–236

This needs explanation.

// This section contains input relocation sections so that they are copied
// to the output. Used only when -r is specified (-r lets the linker do partial
// linking, which combines multiple .o files into single .o file).
// Normally, we don't need this class because we interpret and consume
// relocations ourselves instead of copying.

243

What is this variable for?

ELF/Writer.cpp

829–833

It looks a bit weird to use ?: in combination with if. I'd write

if (Config->Shared)
  EHdr->e_type = ET_DYN;
else if (Config->Relocatable)
  EHdr->e_type = ET_REL;
else
  EHdr->e_type = ET_EXEC;

837

Use Config->Relocatable instead of EHdr->e_type==ET_REL

840

Ditto

[grimar]

Hi Rui,

I am not sure what do you mean, I thought that we discussed that not going to implement "-r/--relocatable" about 3 month ago. This patch is pretty old and abandoned :)
I assume it was reviewed by mistake.

[grimar]

In D14382#354426, @grimar wrote:

Hi Rui,

I am not sure what do you mean, I thought that we discussed that not going to implement "-r/--relocatable" about 3 month ago. This patch is pretty old and abandoned :)
I assume it was reviewed by mistake.

Sorry, didn`t see the new discussion about it when wrote that. Please ignore comment above.

[grimar]

So, since this is needed functionality,
I will rebase and reupload the fresh patch in few days.

[grimar]

• Rebased
• Addressed review comments.

ELF/OutputSections.cpp

174

There is no more such function in lld code, but I changed the member name also. For explanations why - please see comments below.

646–649

I need to have the section index for finalize() (The section header index of the section to which the relocation applies.).
So I save output section here for that. Also I perform a check that such output section is the same. As it would be error for them to have different index. Last is just for safety, I am not sure how much is possible.

654–655

Since StripAll is forced disabled, then looks like not.

942

I need to set correct symtab index for relacations in
void InputSectionBase<ELFT>::copyRelocatable(uint8_t *Buf, uint8_t *BufEnd, RelIteratorRange<isRela> Rels)
Alternative would be to iterate over bodies in symtab right in place there, but that would be much slower.
So I am using SymIndex (it is no more DynSymIndex) and keep correct index in it. For relocatable output in keeps index in symtab, otherwize - in dynsym, like was before.

948

Because of written above - I need to skip locals to assign correct indexes. DynSym does not have locals, so it is always 0 for it. But for SymTab I need to start iteration from its value.

ELF/OutputSections.h

243

Updated name, added comment + please see comments for void StaticRelocSection<ELFT>::addSection(InputSection<ELFT> *C),
where it is used.

[ruiu]

ELF/Config.h

59

Remove ' = false'.

ELF/InputSection.cpp

83

What does this function do? It needs a comment.

I figured that out myself. So, this function seems to do this.

// This function copies section contents to Buf, assuming that the current section
// contains relocations. Usually this function is not called because we apply and
// consume relocation ourselves as a static linker. However, if -r is specified,
// we are a producer of an object file, so instead of applying, we
// copy all relocations to a resulting object file and let the final static
// linker resolve all relocations.
// We can't use memcpy to copy relocations because we need to update symbol table
// offset and section index for each relocation. So we copy relocations one by one.

87

s/RelType/RelTy/

(I think we used this name at somewhere else.)

90

I believe RI originally stands for Relocation Iterator. Using RI as a name of a relocation is probably inappropriate. Please rename Rel.

102

fatal("Relocation against local symbols is not supported yet")

153–156

OK, so these functions are called after you copy all relocations to Buf. But inside fixupRelocations, you copy all relocations to Buf again. That's not wasting but confusing. I'd rename fixupRelocations to copyRelocations and move this function call before memcpy in this function.

ELF/InputSection.h

66–67

I'm not a big fan of optional parameters because it adds complexity (even though it is small.) And this function converts a given offset to a different offset starting from a different point of origin, so it is weird to call this function without any argument.

ELF/OutputSections.cpp

942–944

Please try to separate the control flow for -r from the regular control flow. (Or, in general, please do not try to add small ifs for various flags to achieve something.)

!StrTabSec.isDynamic() does not make sense for -r. As I understand, what you want to do is to set DynsymIndex for each symbol if -r is given, so that you can use the indices in fixRelocations() later. In that case, you don't actually want to sort anything (is this correct?). So, please add

if (Config->Relocatable) {
  size_t I = 0;
  for (const std::pair<SymbolBody *, size_t> &P : Symbols)
    P.first->DynsymIndex = ++I;
  return;
}

before if (!StrTabSec.isDynamic()).

948

I do not understand -- isn't this an incompatible change if you do not use -r?

ELF/OutputSections.h

241

I do not want to define a derived class of OutputSection. All other subclasses are of OutputSectionBase.

244

Do not use C for InputSections because C stands for Chunk. We have removed Chunk, so it no longer makes sense. I'd name S.

248

// The output section to which relocation would be applied.

ELF/Writer.cpp

76

This needs an explanation.

778

This needs a comment.

837

if (!Config->Relocatable) {
  EHdr->e_phoff = sizeof(Elf_Ehdr);
  EHdr->e_phentsize = sizeof(Elf_Phdr);
}

[grimar]

• Addressed Rui's comments.

ELF/OutputSections.cpp

942–944

Yes, it looks I dont need sorting. Fixed.

948

No, it`s not:

When I don't use -r, SymTab execution flow returns earlier, inside if (!StrTabSec.isDynamic()) {...}
For DynSymTab case NumLocals is always 0, so it has no any impact on logic.

ELF/OutputSections.h

244

Ok. Btw it is still used in

OutputSection::addSection(InputSectionBase<ELFT> *C) override;

[• rafael]

ELF/InputSection.h

82

Why do you need to store this? You can always use sh_info, no?
That way you don't add a field to every InputSectionBase.

ELF/OutputSections.cpp

636

This is remarkably similar to OutputSeciton. Can you use that?

648

Can you get here? If so, add a test, if not, use an assert.

[grimar]

ELF/InputSection.h

82

I tried to do that, but for me there are too much additional code required instead of the single field. I had to add something like

template <class ELFT>
void StaticRelocSection<ELFT>::addSection(InputSectionBase<ELFT> *Sec) {
  if (!RelocOutSec) {
    const ObjectFile<ELFT> &File = *Sec->getFile();
    ArrayRef<InputSectionBase<ELFT> *> Sections = File.getSections();
    InputSectionBase<ELFT> *RelocatedSection =
        Sections[Sec->getSectionHdr()->sh_info];
    RelocOutSec = RelocatedSection->OutSec;
  }

for places where I was need that. If you insist I will update the patch with such change.
But I would leave code as is for now.

ELF/OutputSections.cpp

636

Sorry, I am not sure what do you mean here. If you mean I can inhirit from OutputSeciton then I was already asked to not do that. That was initial plan in earlier revision of this patch.
If you meant something else, could you please give more details about that ?

648

I just assumed that users who will try linker probably will use the release version. So if them meet that error situation, there is no way they see the assert, it will not be debug build for them.
error() is universal way to prompt here. I would use it or fatal() here.

[grimar]

ELF/OutputSections.cpp

636

I also can't just use OutputSection instead of StaticRelocSection because of additional logic involved.

[• rafael]

---

rafael wrote:

Can you get here? If so, add a test, if not, use an assert.

I just assumed that users who will try linker probably will use the release version. So if them meet that error situation, there is no way they see the assert, it will not be debug build for them.
error() is universal way to prompt here. I would use it or fatal() here.

If it cannot be reached this is dead code and should be an assert.
Never add an error or fatal that cannot actually happen.

Cheers,
Rafael

[• rafael]

I just tried applying this patch. I noticed two things:

• It is not git-clang-format clean. In particular some lines are more

than 80 chars long.

• It doesn't compile on linux:

/home/espindola/llvm/llvm/tools/lld/ELF/OutputSections.h:306:53:
error: unknown type name 'uintX_t'; did you mean 'uint8_t'?

StaticRelocSection(StringRef Name, uint32_t Type, uintX_t Flags, bool IsRela);
                                                  ^~~~~~~
                                                  uint8_t

[ruiu]

ELF/InputFiles.cpp

208

choosen -> chosen

ELF/InputSection.cpp

93

You are not using BufEnd. Please remove.

96–97

Why don't you use range-based for?

ELF/OutputSections.cpp

648

So, the point is that

• if this is not reachable except by programmer's error (by a bug), assert is better
• if this is reachable by feeding incompatible files, giving incorrect combination of flags, etc, error is appropriate

ELF/Writer.cpp

447–448

Checking for RelocatingSection to see if an input section is a relocation section is an obscure way to distinguish two different kind of sections. Maybe we should define RelInputSection for relocation sections?

[grimar]

• Addressed review comments
• Fixed compilation issues under linux

ELF/OutputSections.cpp

648

Yep, that was clear for me. I just not always sure which situations are reachable by feeding incompatible files for example. 'Corrupted' files can contain absolutely anything to trigger different unexpected situations.
Replaced with assert as I dont know way how to reach here.

ELF/Writer.cpp

447–448

Done. May be RelInput would be better ?
Then we would have:

enum Kind { Regular, RelInput, EHFrame, Merge, MipsReginfo };

I mean all of that are sections kind, IMO no need to specify "section" in enum name again.

[emaste]

In D14382#359582, @grimar wrote:

• Fixed compilation issues under linux

Confirmed it builds on FreeBSD now (previously failed the same as on Linux).

test/ELF/invalid-linkerscript.test needs updating because it currently relies on the -r option is not supported output (to verify functionality unrelated to -r).

[emaste]

As an aside, the Bindings/Go/go.test test gets further but still fails, with FDE doesn't reference another section. I will test the FreeBSD buildworld with this patch incorporated soon.

[emaste]

looks like recent commits invalided the new test in test/ELF/relocatable.s

/tank/emaste/src/llvm/tools/lld/test/ELF/relocatable.s:93:18: error: expected string not found in input
# CHECKEXE-NEXT: SectionHeaderOffset: 0x2190
                 ^
<stdin>:22:2: note: scanning from here
 SectionHeaderOffset: 0x11E8
 ^

[• rafael]

As pointed out, the following tests are failing:

lld :: ELF/invalid-linkerscript.test
lld :: ELF/relocatable.s

[ruiu]

ELF/InputSection.h

38

So you just added RelInputSection kind? Adding a new kind and does not add a new class does not make sense. What I suggested was to actually define a new class for a relocation section. See http://reviews.llvm.org/D17551. I applied your patch and updated yours to separate the class from InputSection.

[• rafael]

• t.diff204 KBDownload

[grimar]

• Updated diff with changes proposed by Rafael Ávila de Espíndola.
• Moved getRelocatedSection and copyRelocations from InputSectionBase to InputSection as was suggested by Rui Ueyama.

[ruiu]

LGTM

ELF/OutputSections.cpp

631

Use S as a variable name.

[• rafael]

LGTM

[grimar]

Rafael, Rui, thank you for reviews and help with that !

ELF/Config.h

struct Configuration {
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;
   bool GnuHash = false;
   bool Mips64EL = false;
   bool NoInhibitExec;
   bool NoUndefined;
+  bool Relocatable = false;
   bool Shared;
   bool Static = false;
   bool StripAll;
   bool SysvHash = true;
   bool Verbose;
   bool ZNodelete = false;
   bool ZNow = false;
   bool ZOrigin = false;

ELF/Driver.cpp

if (WholeArchive) {
       for (MemoryBufferRef &MB : File->getMembers())
         Files.push_back(createELFFile<ObjectFile>(MB));
       OwningArchives.emplace_back(std::move(File));
       return;
     }
     Files.push_back(make_unique<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
+    if (Config->Relocatable)
+      error("attempted static link of dynamic object " + Path);
     Files.push_back(createELFFile<SharedFile>(MBRef));
     return;
   default:
     Files.push_back(createELFFile<ObjectFile>(MBRef));
   }
 }
 
 static StringRef
void LinkerDriver::createFiles(opt::InputArgList &Args) {
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->Verbose = Args.hasArg(OPT_verbose);
 
+  Config->Relocatable = Args.hasArg(OPT_relocatable);
+  if (Config->Relocatable) {
+    // -strip-all is silently ignored.
+    Config->StripAll = false;
+    Config->Static = true;
+    if (Config->Shared)
+      error("-r and -shared may not be used together");
+  }
+
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);
 
void LinkerDriver::createFiles(opt::InputArgList &Args) {
   if (Files.empty())
     error("no input files.");
 }
 
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   Target.reset(createTarget());
 
-  if (!Config->Shared) {
+  if (!Config->Shared && !Config->Relocatable) {
     // Add entry symbol.
     if (Config->Entry.empty())
       Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
 
     // Set either EntryAddr (if S is a number) or EntrySym (otherwise).
     StringRef S = Config->Entry;
     if (S.getAsInteger(0, Config->EntryAddr))
       Config->EntrySym = Symtab.addUndefined(S);

ELF/InputFiles.cpp

for (const Elf_Shdr &Sec : Obj.sections()) {
     case SHT_REL: {
       uint32_t RelocatedSectionIndex = Sec.sh_info;
       if (RelocatedSectionIndex >= Size)
         error("Invalid relocated section index");
       InputSectionBase<ELFT> *RelocatedSection =
           Sections[RelocatedSectionIndex];
       if (!RelocatedSection)
         error("Unsupported relocation reference");
+
+      if (Config->Relocatable) {
+        InputSection<ELFT> *S = new (this->Alloc) InputSection<ELFT>(this, &Sec);
+        S->RelocatingSection = dyn_cast<InputSection<ELFT>>(RelocatedSection);
+        if (!S->RelocatingSection)
+          error("Unsupported relocating section");
+        Sections[I] = S;
+        break;
+      }
+
       if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection))
         S->RelocSections.push_back(&Sec);
       else
         error("Relocations pointing to SHF_MERGE are not supported");
       break;
     }
     default:
       if (shouldMerge<ELFT>(Sec))

ELF/InputSection.h

protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   const Elf_Shdr *Header;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
 public:
   enum Kind { Regular, Merge };
   Kind SectionKind;
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    Kind SectionKind);
   OutputSectionBase<ELFT> *OutSec = nullptr;
 
   // Used for garbage collection.
   // Live bit makes sense only when Config->GcSections is true.
public:
 
   // The writer sets and uses the addresses.
   uintX_t getAlign() {
     // The ELF spec states that a value of 0 means the section has no alignment
     // constraits.
     return std::max<uintX_t>(Header->sh_addralign, 1);
   }
 
   uintX_t getOffset(const Elf_Sym &Sym);
   ArrayRef<uint8_t> getSectionData() const;
 
   // Returns a section that Rel is pointing to. Used by the garbage collector.
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Rel &Rel);
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Rela &Rel);
 };
 
 template <class ELFT>
 InputSectionBase<ELFT>
     InputSectionBase<ELFT>::Discarded(nullptr, nullptr,
                                       InputSectionBase<ELFT>::Regular);
 
 // This corresponds to a SHF_MERGE section of an input file.
 template <class ELFT> class MergeInputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 
 public:
   std::vector<std::pair<uintX_t, size_t>> Offsets;
   MergeInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
   static bool classof(const InputSectionBase<ELFT> *S);
   // Translate an offset in the input section to an offset in the output
public:
   SmallVector<const Elf_Shdr *, 1> RelocSections;
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
   static bool classof(const InputSectionBase<ELFT> *S);
 
+  // Section to which the relocation applies if this is a SHT_REL[A] section.
+  InputSection<ELFT> *RelocatingSection = nullptr;
+
 private:
   template <bool isRela>
   void relocate(uint8_t *Buf, uint8_t *BufEnd,
                 llvm::iterator_range<
                     const llvm::object::Elf_Rel_Impl<ELFT, isRela> *> Rels,
                 const ObjectFile<ELFT> &File, uintX_t BaseAddr);
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 InputSection<ELFT>::InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header)
     : InputSectionBase<ELFT>(F, Header, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == Base::Regular;
 }
 
 template <class ELFT>
 template <bool isRela>
 void InputSection<ELFT>::relocate(
     uint8_t *Buf, uint8_t *BufEnd,
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
     const ObjectFile<ELFT> &File, uintX_t BaseAddr) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
+    const Elf_Shdr *SymTab = File.getSymbolTable();
+
+    if (RelocatingSection) {
+      auto *P = reinterpret_cast<RelType *>(Buf);
+      Buf += sizeof(RelType);
+      // Relocation for local symbol here means that it is probably
+      // rel[a].eh_frame section which has references to
+      // sections in r_info field. Also needs fix for addend.
+      if (SymIndex < SymTab->sh_info)
+        error("Not implemented relocation section type");
+      SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
+      P->r_offset += RelocatingSection->OutSecOff;
+      P->setSymbolAndType(Body.getSymbolTableIndex(), Type, Config->Mips64EL);
+      continue;
+    }
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
-    const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(File, RI);
       Target->relocateOne(Buf + RI.r_offset, BufEnd, Type,
                           BaseAddr + RI.r_offset, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->getSectionData();
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
   ELFFile<ELFT> &EObj = this->File->getObj();
   uint8_t *Base = Buf + OutSecOff;
   uintX_t BaseAddr = this->OutSec->getVA() + OutSecOff;
+
+  // If it is SHT_REL[A] section then RelocatingSection will be available.
+  // That happens if relocatable output was choosen. In that case we should fix
+  // the symbol indices within symtab table, fix addends in some cases and also
+  // other possible data.
+  SmallVector<const Elf_Shdr *, 1> Info;
+  if (RelocatingSection)
+    Info.emplace_back(Header);
+
   // Iterate over all relocation sections that apply to this section.
-  for (const Elf_Shdr *RelSec : RelocSections) {
+  SmallVector<const Elf_Shdr *, 1> &Relocs = RelocatingSection ? Info : RelocSections;
+  for (const Elf_Shdr *RelSec : Relocs) {
     if (RelSec->sh_type == SHT_RELA)
       relocate(Base, Base + Data.size(), EObj.relas(RelSec), *this->File,
                BaseAddr);
     else
       relocate(Base, Base + Data.size(), EObj.rels(RelSec), *this->File,
                BaseAddr);
   }
 }

ELF/Options.td

def no_undefined : Flag<["--"], "no-undefined">,
   HelpText<"Report unresolved symbols even if the linker is creating a shared library">;
 
 def o : Separate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def rpath : Separate<["-"], "rpath">,
   HelpText<"Add a DT_RUNPATH to the output">;
 
+def relocatable : Flag<["--"], "relocatable">,
+  HelpText<"Create relocatable object file">;
+
 def script : Separate<["--"], "script">, HelpText<"Read linker script">;
 
 def shared : Flag<["-"], "shared">,
   HelpText<"Build a shared object">;
 
 def soname : Joined<["-"], "soname=">,
   HelpText<"Set DT_SONAME">;
 

 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
 def alias_entry_e : Separate<["-"], "e">, Alias<entry>;
 def alias_fini_fini : Joined<["-"], "fini=">, Alias<fini>;
 def alias_hash_style_hash_style : Joined<["--", "-"], "hash-style=">, Alias<hash_style>;
 def alias_init_init : Joined<["-"], "init=">, Alias<init>;
 def alias_l__library : Joined<["--"], "library=">, Alias<l>;
 def alias_o_output : Joined<["--"], "output=">, Alias<o>;
+def alias_relocatable : Flag<["-"], "r">, Alias<relocatable>;
 def alias_rpath_rpath : Joined<["-"], "rpath=">, Alias<rpath>;
 def alias_shared_Bshareable : Flag<["-"], "Bshareable">, Alias<shared>;
 def alias_soname_h : Separate<["-"], "h">, Alias<soname>;
 def alias_soname_soname : Separate<["-"], "soname">, Alias<soname>;
 def alias_script_T : Separate<["-"], "T">, Alias<script>;
 def alias_strip_all: Flag<["-"], "s">, Alias<strip_all>;
 def alias_undefined_u : Separate<["-"], "u">, Alias<undefined>;
 

ELF/OutputSections.h

 namespace lld {
 namespace elf2 {
 
 class SymbolBody;
 template <class ELFT> class SymbolTable;
 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class InputSection;
+template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class OutputSection;
+template <class ELFT> class StaticRelocSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class DefinedRegular;
 template <class ELFT> class ELFSymbolBody;
 
 template <class ELFT>
 static inline typename llvm::object::ELFFile<ELFT>::uintX_t
 getAddend(const typename llvm::object::ELFFile<ELFT>::Elf_Rel &Rel) {
   return 0;
public:
   bool isRela() const { return IsRela; }
 
 private:
   std::vector<DynamicReloc<ELFT>> Relocs;
   const bool IsRela;
 };
 
 template <class ELFT>
-class OutputSection final : public OutputSectionBase<ELFT> {
+class OutputSection : public OutputSectionBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   OutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
-  void addSection(InputSection<ELFT> *C);
+  virtual void addSection(InputSection<ELFT> *C);
   void writeTo(uint8_t *Buf) override;
 
 private:
   std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT>
+class StaticRelocSection final : public OutputSection<ELFT> {
+public:
+  StaticRelocSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  void addSection(InputSection<ELFT> *C) override;
+  void finalize() override;
+
+private:
+  OutputSectionBase<ELFT> *LinkedOut = nullptr;
+};
+
+template <class ELFT>
 class MergeOutputSection final : public OutputSectionBase<ELFT> {
   typedef typename OutputSectionBase<ELFT>::uintX_t uintX_t;
 
   bool shouldTailMerge() const;
 
 public:
   MergeOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void addSection(MergeInputSection<ELFT> *S);
   void writeTo(uint8_t *Buf) override;
   unsigned getOffset(StringRef Val);

ELF/OutputSections.cpp

for (const DynamicReloc<ELFT> &Rel : Relocs) {
     bool NeedsCopy = Body && Target->relocNeedsCopy(Type, *Body);
     bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
     bool CanBePreempted = canBePreempted(Body, NeedsGot);
     bool LazyReloc = Body && Target->supportsLazyRelocations() &&
                      Target->relocNeedsPlt(Type, *Body);
 
     if (CanBePreempted) {
       if (NeedsGot)
-        P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
+        P->setSymbolAndType(Body->getSymbolTableIndex(),
                             LazyReloc ? Target->getPltReloc()
                                       : Target->getGotReloc(),
                             Config->Mips64EL);
       else
-        P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
+        P->setSymbolAndType(Body->getSymbolTableIndex(),
                             NeedsCopy ? Target->getCopyReloc() : Type,
                             Config->Mips64EL);
     } else {
       P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
     }
 
     if (NeedsGot) {
       if (LazyReloc)
template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
   *P++ = NumSymbols; // nbucket
   *P++ = NumSymbols; // nchain
 
   Elf_Word *Buckets = P;
   Elf_Word *Chains = P + NumSymbols;
 
   for (SymbolBody *Body : Out<ELFT>::DynSymTab->getSymbols()) {
     StringRef Name = Body->getName();
-    unsigned I = Body->getDynamicSymbolTableIndex();
+    unsigned I = Body->getSymbolTableIndex();
     uint32_t Hash = hashSysv(Name) % NumSymbols;
     Chains[I] = Buckets[Hash];
     Buckets[Hash] = I;
   }
 }
 
 static uint32_t hashGnu(StringRef Name) {
   uint32_t H = 5381;
void GnuHashTableSection<ELFT>::writeHashTable(uint8_t *Buf) {
   Elf_Word *Values = Buckets + NBuckets;
 
   int PrevBucket = -1;
   int I = 0;
   for (const HashedSymbolData &Item : HashedSymbols) {
     int Bucket = Item.Hash % NBuckets;
     assert(PrevBucket <= Bucket);
     if (Bucket != PrevBucket) {
-      Buckets[Bucket] = Item.Body->getDynamicSymbolTableIndex();
+      Buckets[Bucket] = Item.Body->getSymbolTableIndex();
       PrevBucket = Bucket;
       if (I > 0)
         Values[I - 1] |= 1;
     }
     Values[I] = Item.Hash & ~1;
     ++I;
   }
   if (I > 0)
void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
   C->OutSec = this;
   uint32_t Align = C->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
 
   uintX_t Off = this->Header.sh_size;
   Off = RoundUpToAlignment(Off, Align);
   C->OutSecOff = Off;
   Off += C->getSize();
   this->Header.sh_size = Off;
 }
 
 template <class ELFT>
+StaticRelocSection<ELFT>::StaticRelocSection(StringRef Name, uint32_t sh_type,
+                                             uintX_t sh_flags)
+    : OutputSection<ELFT>(Name, sh_type, sh_flags) {
+  Elf_Shdr &Header = this->Header;
+  Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
+  Header.sh_entsize = true ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
+}
+
+template <class ELFT>
+void StaticRelocSection<ELFT>::addSection(InputSection<ELFT> *C) {
+  if (!LinkedOut)
+    LinkedOut = C->RelocatingSection->OutSec;
+  else if (LinkedOut != C->RelocatingSection->OutSec)
+    error("Sections to which the relocations applies doesn`t match");
+  OutputSection<ELFT>::addSection(C);
+}
+
+template <class ELFT> void StaticRelocSection<ELFT>::finalize() {
+  if (Out<ELFT>::SymTab)
+    Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
+  Header.sh_info = LinkedOut->SectionIndex;
+}
+
+template <class ELFT>
 typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Sym.st_value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
   this->Header.sh_info = NumLocals + 1;
 
   if (!StrTabSec.isDynamic()) {
     std::stable_sort(Symbols.begin(), Symbols.end(),
                      [](SymbolBody *L, SymbolBody *R) {
                        return getSymbolBinding(L) == STB_LOCAL &&
                               getSymbolBinding(R) != STB_LOCAL;
                      });
+    if (!Config->Relocatable)
       return;
   }
   if (Out<ELFT>::GnuHashTab)
     // NB: It also sorts Symbols to meet the GNU hash table requirements.
     Out<ELFT>::GnuHashTab->addSymbols(Symbols);
-  size_t I = 0;
+  size_t I = NumLocals;
   for (SymbolBody *B : Symbols)
-    B->setDynamicSymbolTableIndex(++I);
+    B->setSymbolTableIndex(++I);
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::addLocalSymbol(StringRef Name) {
   StrTabSec.add(Name);
   ++NumVisible;
   ++NumLocals;
 }

 template class DynamicSection<ELF64LE>;
 template class DynamicSection<ELF64BE>;
 
 template class OutputSection<ELF32LE>;
 template class OutputSection<ELF32BE>;
 template class OutputSection<ELF64LE>;
 template class OutputSection<ELF64BE>;
 
+template class StaticRelocSection<ELF32LE>;
+template class StaticRelocSection<ELF32BE>;
+template class StaticRelocSection<ELF64LE>;
+template class StaticRelocSection<ELF64BE>;
+
 template class MergeOutputSection<ELF32LE>;
 template class MergeOutputSection<ELF32BE>;
 template class MergeOutputSection<ELF64LE>;
 template class MergeOutputSection<ELF64BE>;
 
 template class StringTableSection<ELF32LE>;
 template class StringTableSection<ELF32BE>;
 template class StringTableSection<ELF64LE>;

ELF/Symbols.h

public:
   void setUsedInDynamicReloc() { IsUsedInDynamicReloc = true; }
   bool isTLS() const { return IsTLS; }
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   uint8_t getVisibility() const { return Visibility; }
 
-  unsigned getDynamicSymbolTableIndex() const {
-    return DynamicSymbolTableIndex;
+  unsigned getSymbolTableIndex() const {
+    return SymbolTableIndex;
   }
-  void setDynamicSymbolTableIndex(unsigned V) { DynamicSymbolTableIndex = V; }
+  void setSymbolTableIndex(unsigned V) { SymbolTableIndex = V; }
 
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   bool isInGot() const { return GotIndex != -1U; }
   bool isInGotPlt() const { return GotPltIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
protected:
   }
 
   const unsigned SymbolKind : 8;
   unsigned IsWeak : 1;
   unsigned Visibility : 2;
   unsigned IsUsedInRegularObj : 1;
   unsigned IsUsedInDynamicReloc : 1;
   unsigned IsTLS : 1;
-  unsigned DynamicSymbolTableIndex = 0;
+  unsigned SymbolTableIndex = 0;
   StringRef Name;
   Symbol *Backref = nullptr;
 };
 
 // This is for symbols created from elf files and not from the command line.
 // Since they come from object files, they have a Elf_Sym.
 //
 // FIXME: Another alternative is to give every symbol an Elf_Sym. To do that

ELF/Writer.cpp

 private:
   void copyLocalSymbols();
   void createSections();
   template <bool isRela>
   void scanRelocs(const InputSection<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
   void scanRelocs(const InputSection<ELFT> &C);
   void assignAddresses();
+  void assignAddressesRel();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
   uintX_t getVAStart() const { return Config->Shared ? 0 : Target->getVAStart(); }
   uintX_t getEntryAddr() const;
   int getPhdrsNum() const;
 
   OutputSection<ELFT> *getBSS();
   void addCommonSymbols(std::vector<DefinedCommon<ELFT> *> &Syms);
   void addSharedCopySymbols(std::vector<SharedSymbol<ELFT> *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
+  SpecificBumpPtrAllocator<StaticRelocSection<ELFT>> RelSecAlloc;
   SpecificBumpPtrAllocator<MergeOutputSection<ELFT>> MSecAlloc;
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Size, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);
 
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
template <class ELFT> void lld::elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   Writer<ELFT>(*Symtab).run();
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   createSections();
+  if (!Config->Relocatable)
     assignAddresses();
+  else
+    assignAddressesRel();
   openFile(Config->OutputFile);
   writeHeader();
   writeSections();
   error(Buffer->commit());
 }
 
 namespace {
 template <bool Is64Bits> struct SectionKey {
void Writer<ELFT>::scanRelocs(const InputSection<ELFT> &C) {
   }
 }
 
 template <class ELFT>
 static void reportUndefined(const SymbolTable<ELFT> &S, const SymbolBody &Sym) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 
-  if (Config->Shared && !Config->NoUndefined)
+  if ((Config->Relocatable || Config->Shared) && !Config->NoUndefined)
     return;
 
   const Elf_Sym &SymE = cast<ELFSymbolBody<ELFT>>(Sym).Sym;
   ELFFileBase<ELFT> *SymFile = nullptr;
 
   for (const std::unique_ptr<ObjectFile<ELFT>> &File : S.getObjectFiles()) {
     Elf_Sym_Range Syms = File->getObj().symbols(File->getSymbolTable());
     if (&SymE > Syms.begin() && &SymE < Syms.end())
if (Align == 0)
       Align = SecAlign;
     Out<ELFT>::Bss->updateAlign(Align);
     Off = RoundUpToAlignment(Off, Align);
     C->OffsetInBSS = Off;
     Off += Sym.st_size;
   }
   Out<ELFT>::Bss->setSize(Off);
 }
 
 static StringRef getOutputName(StringRef S) {
   if (S.startswith(".text."))
     return ".text";
   if (S.startswith(".rodata."))
     return ".rodata";
   if (S.startswith(".data."))
     return ".data";
   if (S.startswith(".bss."))
     return ".bss";
for (InputSectionBase<ELFT> *C : F->getSections()) {
       // This makes each output section simple and keeps a single level
       // mapping from input to output.
       auto *IS = dyn_cast<InputSection<ELFT>>(C);
       uintX_t EntSize = IS ? 0 : H->sh_entsize;
       SectionKey<ELFT::Is64Bits> Key{getOutputName(C->getSectionName()),
                                      H->sh_type, OutFlags, EntSize};
       OutputSectionBase<ELFT> *&Sec = Map[Key];
       if (!Sec) {
-        if (IS)
+        if (IS) {
+          if (IS->RelocatingSection)
+            Sec = new (RelSecAlloc.Allocate())
+                StaticRelocSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+          else
             Sec = new (SecAlloc.Allocate())
                 OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
-        else
+        } else {
           Sec = new (MSecAlloc.Allocate())
               MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+        }
         OutputSections.push_back(Sec);
         RegularSections.push_back(Sec);
       }
       if (IS)
         static_cast<OutputSection<ELFT> *>(Sec)->addSection(IS);
       else
         static_cast<MergeOutputSection<ELFT> *>(Sec)
             ->addSection(cast<MergeInputSection<ELFT>>(C));
static uint32_t toPhdrFlags(uint64_t Flags) {
   uint32_t Ret = PF_R;
   if (Flags & SHF_WRITE)
     Ret |= PF_W;
   if (Flags & SHF_EXECINSTR)
     Ret |= PF_X;
   return Ret;
 }
 
+template <class ELFT> void Writer<ELFT>::assignAddressesRel() {
+  uintX_t FileOff = sizeof(Elf_Ehdr);
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    auto Name = Sec->getName();
+    FileOff = RoundUpToAlignment(FileOff, Sec->getAlign());
+    Sec->setFileOffset(FileOff);
+    FileOff += Sec->getSize();
+  }
+  SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
+  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+}
+
 // Visits all sections to create PHDRs and to assign incremental,
 // non-overlapping addresses to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = getVAStart() + sizeof(Elf_Ehdr);
   uintX_t FileOff = sizeof(Elf_Ehdr);
 
   // Calculate and reserve the space for the program header first so that
   // the first section can start right after the program header.
template <class ELFT> void Writer<ELFT>::assignAddresses() {
 
   // Add an entry for .dynamic.
   if (isOutputDynamic()) {
     Elf_Phdr *PH = &Phdrs[++PhdrIdx];
     PH->p_type = PT_DYNAMIC;
     copyPhdr(PH, Out<ELFT>::Dynamic);
   }
 
   // Fix up PT_INTERP as we now know the address of .interp section.
   if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
template <class ELFT> void Writer<ELFT>::writeHeader() {
   EHdr->e_ident[EI_DATA] = ELFT::TargetEndianness == llvm::support::little
                                ? ELFDATA2LSB
                                : ELFDATA2MSB;
   EHdr->e_ident[EI_VERSION] = EV_CURRENT;
 
   auto &FirstObj = cast<ELFFileBase<ELFT>>(*Config->FirstElf);
   EHdr->e_ident[EI_OSABI] = FirstObj.getOSABI();
 
+  if (Config->Relocatable)
+    EHdr->e_type = ET_REL;
+  else
     EHdr->e_type = Config->Shared ? ET_DYN : ET_EXEC;
+
   EHdr->e_machine = FirstObj.getEMachine();
   EHdr->e_version = EV_CURRENT;
   EHdr->e_entry = getEntryAddr();
-  EHdr->e_phoff = sizeof(Elf_Ehdr);
+  EHdr->e_phoff = EHdr->e_type == ET_REL ? 0 : sizeof(Elf_Ehdr);
   EHdr->e_shoff = SectionHeaderOff;
   EHdr->e_ehsize = sizeof(Elf_Ehdr);
-  EHdr->e_phentsize = sizeof(Elf_Phdr);
+  EHdr->e_phentsize = EHdr->e_type == ET_REL ? 0 : sizeof(Elf_Phdr);
   EHdr->e_phnum = Phdrs.size();
   EHdr->e_shentsize = sizeof(Elf_Shdr);
   EHdr->e_shnum = getNumSections();
   EHdr->e_shstrndx = Out<ELFT>::ShStrTab->SectionIndex;
 
   // Write the program header table.
+  if (!Phdrs.empty())
     memcpy(Buf + EHdr->e_phoff, &Phdrs[0], Phdrs.size() * sizeof(Phdrs[0]));
 
   // Write the section header table. Note that the first table entry is null.
   auto SHdrs = reinterpret_cast<Elf_Shdr *>(Buf + EHdr->e_shoff);
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->writeHeaderTo(++SHdrs);
 }
 
 template <class ELFT> void Writer<ELFT>::openFile(StringRef Path) {

test/elf2/Inputs/relocatable.s

+.text
+.type xx,@object
+.bss
+.globl xx
+.align 4
+xx:
+.long 0
+.size xx, 4
+.type yy,@object
+.globl yy
+.align 4
+yy:
+.long 0
+.size yy, 4
+
+.text
+.globl foo
+.align 16, 0x90
+.type foo,@function
+foo:
+movl $1, xx
+movl $2, yy

test/elf2/Inputs/relocatable2.s

+.text
+.type xxx,@object
+.bss
+.globl xxx
+.align 4
+xxx:
+.long 0
+.size xxx, 4
+.type yyy,@object
+.globl yyy
+.align 4
+yyy:
+.long 0
+.size yyy, 4
+
+.text
+.globl bar
+.align 16, 0x90
+.type bar,@function
+bar:
+movl $8, xxx
+movl $9, yyy

test/elf2/relocatable.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable.s -o %t2.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable2.s -o %t3.o
+// RUN: ld.lld2 -r %t1.o %t2.o %t3.o -o %t
+// RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
+// RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
+
+// Test --relocatable alias
+// RUN: ld.lld2 --relocatable %t1.o %t2.o %t3.o -o %t
+// RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
+// RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
+
+// Verify that we can use our relocation output as input to produce executable
+// RUN: ld.lld2 -e main %t -o %texec
+// RUN: llvm-readobj -file-headers %texec | FileCheck -check-prefix=CHECKEXE %s
+
+# CHECK:       ElfHeader {
+# CHECK-NEXT:  Ident {
+# CHECK-NEXT:    Magic: (7F 45 4C 46)
+# CHECK-NEXT:    Class: 64-bit
+# CHECK-NEXT:    DataEncoding: LittleEndian
+# CHECK-NEXT:    FileVersion: 1
+# CHECK-NEXT:    OS/ABI: SystemV
+# CHECK-NEXT:    ABIVersion: 0
+# CHECK-NEXT:    Unused: (00 00 00 00 00 00 00)
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Type: Relocatable
+# CHECK-NEXT:  Machine: EM_X86_64
+# CHECK-NEXT:  Version: 1
+# CHECK-NEXT:  Entry: 0x0
+# CHECK-NEXT:  ProgramHeaderOffset: 0x0
+# CHECK-NEXT:  SectionHeaderOffset: 0x278
+# CHECK-NEXT:  Flags [
+# CHECK-NEXT:  ]
+# CHECK-NEXT:  HeaderSize: 64
+# CHECK-NEXT:  ProgramHeaderEntrySize: 0
+# CHECK-NEXT:  ProgramHeaderCount: 0
+# CHECK-NEXT:  SectionHeaderEntrySize: 64
+# CHECK-NEXT:  SectionHeaderCount: 7
+# CHECK-NEXT:  StringTableSectionIndex: 5
+# CHECK-NEXT:  }
+
+# CHECK:       Relocations [
+# CHECK-NEXT:  Section (3) .rela.text {
+# CHECK-NEXT:    0x3 R_X86_64_32S x 0x0
+# CHECK-NEXT:    0xE R_X86_64_32S y 0x0
+# CHECK-NEXT:    0x23 R_X86_64_32S xx 0x0
+# CHECK-NEXT:    0x2E R_X86_64_32S yy 0x0
+# CHECK-NEXT:    0x43 R_X86_64_32S xxx 0x0
+# CHECK-NEXT:    0x4E R_X86_64_32S yyy 0x0
+# CHECK-NEXT:  }
+
+# CHECKTEXT:      Disassembly of section .text:
+# CHECKTEXT-NEXT: main:
+# CHECKTEXT-NEXT: 0: c7 04 25 00 00 00 00 05 00 00 00 movl $5, 0
+# CHECKTEXT-NEXT: b: c7 04 25 00 00 00 00 07 00 00 00 movl $7, 0
+# CHECKTEXT:      foo:
+# CHECKTEXT-NEXT: 20: c7 04 25 00 00 00 00 01 00 00 00 movl $1, 0
+# CHECKTEXT-NEXT: 2b: c7 04 25 00 00 00 00 02 00 00 00 movl $2, 0
+# CHECKTEXT:      bar:
+# CHECKTEXT-NEXT: 40: c7 04 25 00 00 00 00 08 00 00 00 movl $8, 0
+# CHECKTEXT-NEXT: 4b: c7 04 25 00 00 00 00 09 00 00 00 movl $9, 0
+
+# CHECKEXE:       Format: ELF64-x86-64
+# CHECKEXE-NEXT:  Arch: x86_64
+# CHECKEXE-NEXT:  AddressSize: 64bit
+# CHECKEXE-NEXT:  LoadName: 
+# CHECKEXE-NEXT:  ElfHeader {
+# CHECKEXE-NEXT:    Ident {
+# CHECKEXE-NEXT:      Magic: (7F 45 4C 46)
+# CHECKEXE-NEXT:      Class: 64-bit
+# CHECKEXE-NEXT:      DataEncoding: LittleEndian
+# CHECKEXE-NEXT:      FileVersion: 1
+# CHECKEXE-NEXT:      OS/ABI: SystemV (0x0)
+# CHECKEXE-NEXT:      ABIVersion: 0
+# CHECKEXE-NEXT:      Unused: (00 00 00 00 00 00 00)
+# CHECKEXE-NEXT:    }
+# CHECKEXE-NEXT:    Type: Executable
+# CHECKEXE-NEXT:    Machine: EM_X86_64
+# CHECKEXE-NEXT:    Version: 1
+# CHECKEXE-NEXT:    Entry: 0x11000
+# CHECKEXE-NEXT:    ProgramHeaderOffset: 0x40
+# CHECKEXE-NEXT:    SectionHeaderOffset: 0x2130
+# CHECKEXE-NEXT:    Flags [
+# CHECKEXE-NEXT:    ]
+# CHECKEXE-NEXT:    HeaderSize: 64
+# CHECKEXE-NEXT:    ProgramHeaderEntrySize: 56
+# CHECKEXE-NEXT:    ProgramHeaderCount: 4
+# CHECKEXE-NEXT:    SectionHeaderEntrySize: 64
+# CHECKEXE-NEXT:    SectionHeaderCount: 6
+# CHECKEXE-NEXT:    StringTableSectionIndex: 4
+# CHECKEXE-NEXT:  }
+
+.text
+.type x,@object
+.bss
+.globl x
+.align 4
+x:
+.long 0
+.size x, 4
+.type y,@object
+.globl y
+.align 4
+y:
+.long 0
+.size y, 4
+
+.text
+.globl main
+.align 16, 0x90
+.type main,@function
+main:
+movl $5, x
+movl $7, y

test/elf2/strip-all.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld2 %t.o -o %t1
 #RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix BEFORE
 #BEFORE:       .symtab
 #BEFORE-NEXT:  .shstrtab
 #BEFORE-NEXT:  .strtab
 
 #RUN: ld.lld2 %t.o --strip-all -o %t1
 #RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix AFTER
 #AFTER-NOT: .symtab
 #AFTER:     .shstrtab
 #AFTER-NOT: .strtab
 
+// Ignore --strip-all if -r is specified
+#RUN: ld.lld2 %t.o --strip-all -r -o %t1
+#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix BEFORE
+
 # Test alias -s
 #RUN: ld.lld2 %t.o -s -o %t1
 #RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix AFTER
 
 # exits with return code 42 on linux
 .globl _start;
 _start:
   mov $60, %rax
   mov $42, %rdi
   syscall