[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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

Move this into the code block above and sort.

ELF/InputFiles.cpp

211–213 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

Move this to checkOptions.

ELF/InputFiles.cpp

209 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

// 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 ↗

(On Diff #39367)

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

639 ↗

(On Diff #39367)

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

646–649 ↗

(On Diff #39367)

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

654–655 ↗

(On Diff #39367)

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

942 ↗

(On Diff #39367)

Why did you need this change?

948 ↗

(On Diff #39367)

What is this for?

ELF/OutputSections.h

235–236 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

What is this variable for?

ELF/Writer.cpp

829–833 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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

840 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

Since StripAll is forced disabled, then looks like not.

942 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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 ↗

(On Diff #39367)

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

[ruiu]

ELF/Config.h

70 ↗

(On Diff #48305)

Remove ' = false'.

ELF/InputSection.cpp

99 ↗

(On Diff #48305)

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.

103 ↗

(On Diff #48305)

s/RelType/RelTy/

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

106 ↗

(On Diff #48305)

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

118 ↗

(On Diff #48305)

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

288–291 ↗

(On Diff #48305)

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

70 ↗

(On Diff #48305)

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

1402–1403 ↗

(On Diff #48305)

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()).

1410 ↗

(On Diff #48305)

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

ELF/OutputSections.h

302 ↗

(On Diff #48305)

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

305 ↗

(On Diff #48305)

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.

309 ↗

(On Diff #48305)

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

ELF/Writer.cpp

103 ↗

(On Diff #48305)

This needs an explanation.

1310 ↗

(On Diff #48305)

This needs a comment.

1472 ↗

(On Diff #48305)

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

[grimar]

• Addressed Rui's comments.

ELF/OutputSections.cpp

1402–1403 ↗

(On Diff #48305)

Yes, it looks I dont need sorting. Fixed.

1410 ↗

(On Diff #48305)

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

305 ↗

(On Diff #48305)

Ok. Btw it is still used in

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

[• rafael]

ELF/InputSection.h

95 ↗

(On Diff #48506)

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

751 ↗

(On Diff #48506)

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

763 ↗

(On Diff #48506)

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

[grimar]

ELF/InputSection.h

95 ↗

(On Diff #48506)

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

751 ↗

(On Diff #48506)

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 ?

763 ↗

(On Diff #48506)

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

751 ↗

(On Diff #48506)

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

230 ↗

(On Diff #48506)

choosen -> chosen

ELF/InputSection.cpp

109 ↗

(On Diff #48506)

You are not using BufEnd. Please remove.

112–113 ↗

(On Diff #48506)

Why don't you use range-based for?

ELF/OutputSections.cpp

763 ↗

(On Diff #48506)

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

844 ↗

(On Diff #48506)

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

763 ↗

(On Diff #48506)

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

844 ↗

(On Diff #48506)

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

39 ↗

(On Diff #48802)

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

746 ↗

(On Diff #48917)

Use S as a variable name.

[• rafael]

LGTM

[grimar]

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

lld/trunk/ELF/Config.h

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

lld/trunk/ELF/Driver.cpp

if (WholeArchive) {
       StringRef S = MBRef.getBufferIdentifier();
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(MB, S));
       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);
+      return;
+    }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     Files.push_back(createObjectFile(MBRef));
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);
   if (Path.empty())
     error("Unable to find library -l" + Name);
   else
     addFile(Path);
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
-  // Traditional linkers can generate re-linkable object files instead
-  // of executables or DSOs. We don't support that since the feature
-  // does not seem to provide more value than the static archiver.
-  if (Args.hasArg(OPT_relocatable))
-    error("-r option is not supported. Use 'ar' command instead.");
-
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
     error("The .gnu.hash section is not compatible with the MIPS target.");
 
   if (Config->EMachine == EM_AMDGPU && !Config->Entry.empty())
     error("-e option is not valid for AMDGPU.");
+
+  if (Config->Relocatable && Config->Shared)
+    error("-r and -shared may not be used together");
 }
 
 static StringRef
 getString(opt::InputArgList &Args, unsigned Key, StringRef Default = "") {
   if (auto *Arg = Args.getLastArg(Key))
     return Arg->getValue();
   return Default;
 }
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   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->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
+  Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->Verbose = Args.hasArg(OPT_verbose);
 
   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);
 
   Config->ZExecStack = hasZOption(Args, "execstack");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");
 
+  if (Config->Relocatable)
+    Config->StripAll = false;
+
   if (auto *Arg = Args.getLastArg(OPT_O)) {
     StringRef Val = Arg->getValue();
     if (Val.getAsInteger(10, Config->Optimize))
       error("Invalid optimization level");
   }
 
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {
     StringRef S = Arg->getValue();
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
 
   SymbolTable<ELFT> Symtab;
   std::unique_ptr<TargetInfo> TI(createTarget());
   Target = TI.get();
 
-  if (!Config->Shared) {
+  if (!Config->Shared && !Config->Relocatable) {
     // Add entry symbol.
     //
     // There is no entry symbol for AMDGPU binaries, so skip adding one to avoid
     // having and undefined symbol.
     if (Config->Entry.empty() && Config->EMachine != EM_AMDGPU)
       Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
 
     // In the assembly for 32 bit x86 the _GLOBAL_OFFSET_TABLE_ symbol

lld/trunk/ELF/InputFiles.cpp

case SHT_REL: {
           Sections[RelocatedSectionIndex];
       // Strictly speaking, a relocation section must be included in the
       // group of the section it relocates. However, LLVM 3.3 and earlier
       // would fail to do so, so we gracefully handle that case.
       if (RelocatedSection == InputSection<ELFT>::Discarded)
         continue;
       if (!RelocatedSection)
         fatal("Unsupported relocation reference");
-      if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection)) {
+      if (Config->Relocatable) {
+        // For -r, relocation sections are handled as regular input sections.
+        Sections[I] = new (Alloc) InputSection<ELFT>(this, &Sec);
+      } else if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection)) {
         S->RelocSections.push_back(&Sec);
       } else if (auto *S = dyn_cast<EHInputSection<ELFT>>(RelocatedSection)) {
         if (S->RelocSection)
           fatal("Multiple relocation sections to .eh_frame are not supported");
         S->RelocSection = &Sec;
       } else {
         fatal("Relocations pointing to SHF_MERGE are not supported");
       }

lld/trunk/ELF/InputSection.h

public:
   // Relocation sections that refer to this one.
   llvm::TinyPtrVector<const Elf_Shdr *> 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);
+
+  InputSectionBase<ELFT> *getRelocatedSection();
+
+private:
+  template <bool isRela>
+  using RelIteratorRange =
+      llvm::iterator_range<const llvm::object::Elf_Rel_Impl<ELFT, isRela> *>;
+
+  template <bool isRela>
+  void copyRelocations(uint8_t *Buf, RelIteratorRange<isRela> Rels);
 };
 
 // MIPS .reginfo section provides information on the registers used by the code
 // in the object file. Linker should collect this information and write a single
 // .reginfo section in the output file. The output section contains a union of
 // used registers masks taken from input .reginfo sections and final value
 // of the `_gp` symbol.  For details: Chapter 4 / "Register Information" at
 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf

lld/trunk/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>
+InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
+  assert(this->Header->sh_type == SHT_RELA || this->Header->sh_type == SHT_REL);
+  ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
+  return Sections[this->Header->sh_info];
+}
+
+// This is used for -r. 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.
+template <class ELFT>
+template <bool isRela>
+void InputSection<ELFT>::copyRelocations(uint8_t *Buf,
+                                         RelIteratorRange<isRela> Rels) {
+  typedef Elf_Rel_Impl<ELFT, isRela> RelType;
+  InputSectionBase<ELFT> *RelocatedSection = getRelocatedSection();
+
+  for (const RelType &Rel : Rels) {
+    uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
+    uint32_t Type = Rel.getType(Config->Mips64EL);
+    const Elf_Shdr *SymTab = this->File->getSymbolTable();
+
+    RelType *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)
+      fatal("Relocation against local symbols is not supported yet");
+
+    SymbolBody *Body = this->File->getSymbolBody(SymIndex)->repl();
+    P->r_offset = RelocatedSection->getOffset(Rel.r_offset);
+    P->setSymbolAndType(Body->DynsymIndex, Type, Config->Mips64EL);
+  }
+}
+
+template <class ELFT>
 template <bool isRela>
 uint8_t *
 InputSectionBase<ELFT>::findMipsPairedReloc(uint8_t *Buf, uint32_t SymIndex,
                                             uint32_t Type,
                                             RelIteratorRange<isRela> Rels) {
   // Some MIPS relocations use addend calculated from addend of the relocation
   // itself and addend of paired relocation. ABI requires to compute such
   // combined addend in case of REL relocation record format only.
void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->getSectionData();
+  ELFFile<ELFT> &EObj = this->File->getObj();
+
+  // That happens with -r. In that case we need fix the relocation position and
+  // target. No relocations are applied.
+  if (this->Header->sh_type == SHT_RELA) {
+    this->copyRelocations(Buf + OutSecOff, EObj.relas(this->Header));
+    return;
+  }
+  if (this->Header->sh_type == SHT_REL) {
+    this->copyRelocations(Buf + OutSecOff, EObj.rels(this->Header));
+    return;
+  }
+
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
-  ELFFile<ELFT> &EObj = this->File->getObj();
   uint8_t *BufEnd = Buf + OutSecOff + Data.size();
   // Iterate over all relocation sections that apply to this section.
   for (const Elf_Shdr *RelSec : this->RelocSections) {
     if (RelSec->sh_type == SHT_RELA)
       this->relocate(Buf, BufEnd, EObj.relas(RelSec));
     else
       this->relocate(Buf, BufEnd, EObj.rels(RelSec));
   }

lld/trunk/ELF/Options.td

def o : Separate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def print_gc_sections: Flag<["--"], "print-gc-sections">,
   HelpText<"List removed unused sections">;
 
 def rpath : Separate<["-"], "rpath">,
   HelpText<"Add a DT_RUNPATH to the output">;
 
-def relocatable : Flag<["--"], "relocatable">;
+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">;

lld/trunk/ELF/OutputSections.h

public:
   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 Type, uintX_t Flags);
   void addSection(InputSectionBase<ELFT> *C) override;
   void sortInitFini();
   void sortCtorsDtors();
   void writeTo(uint8_t *Buf) override;
+  void finalize() override;
 
 private:
   void reassignOffsets();
   std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT>
 class MergeOutputSection final : public OutputSectionBase<ELFT> {

lld/trunk/ELF/OutputSections.cpp

 template <class ELFT> void EhFrameHeader<ELFT>::reserveFde() {
   // Each FDE entry is 8 bytes long:
   // The first four bytes are an offset to the initial PC value for the FDE. The
   // last four byte are an offset to the FDE data itself.
   this->Header.sh_size += 8;
 }
 
 template <class ELFT>
-OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type,
-                                   uintX_t Flags)
-    : OutputSectionBase<ELFT>(Name, Type, Flags) {}
+OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type, uintX_t Flags)
+    : OutputSectionBase<ELFT>(Name, Type, Flags) {
+  if (Type == SHT_RELA)
+    this->Header.sh_entsize = sizeof(Elf_Rela);
+  else if (Type == SHT_REL)
+    this->Header.sh_entsize = sizeof(Elf_Rel);
+}
+
+template <class ELFT> void OutputSection<ELFT>::finalize() {
+  uint32_t Type = this->Header.sh_type;
+  if (Type != SHT_RELA && Type != SHT_REL)
+    return;
+  this->Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
+  // sh_info for SHT_REL[A] sections should contain the section header index of
+  // the section to which the relocation applies.
+  InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
+  this->Header.sh_info = S->OutSec->SectionIndex;
+}
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<InputSection<ELFT>>(C);
   Sections.push_back(S);
   S->OutSec = this;
   this->updateAlign(S->Align);
 

 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
   if (this->Header.sh_size)
     return; // Already finalized.
 
   this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
   this->Header.sh_link = StrTabSec.SectionIndex;
   this->Header.sh_info = NumLocals + 1;
 
+  if (Config->Relocatable) {
+    size_t I = NumLocals;
+    for (const std::pair<SymbolBody *, size_t> &P : Symbols)
+      P.first->DynsymIndex = ++I;
+    return;
+  }
+
   if (!StrTabSec.isDynamic()) {
     std::stable_sort(Symbols.begin(), Symbols.end(),
                      [](const std::pair<SymbolBody *, unsigned> &L,
                         const std::pair<SymbolBody *, unsigned> &R) {
                        return getSymbolBinding(L.first) == STB_LOCAL &&
                               getSymbolBinding(R.first) != STB_LOCAL;
                      });
     return;

lld/trunk/ELF/Writer.cpp

private:
   template <bool isRela>
   void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
 
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void createPhdrs();
   void assignAddresses();
+  void assignAddressesRelocatable();
   void fixAbsoluteSymbols();
   bool openFile();
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(InputSectionBase<ELFT> *S) const;
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
 
   OutputSection<ELFT> *getBss();
   void addCommonSymbols(std::vector<DefinedCommon *> &Syms);
   void addCopyRelSymbols(std::vector<SharedSymbol<ELFT> *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
 
   // We create a section for the ELF header and one for the program headers.
-  const unsigned NumDummySections = 2;
   ArrayRef<OutputSectionBase<ELFT> *> getSections() const {
-    return makeArrayRef(OutputSections).slice(NumDummySections);
+    return makeArrayRef(OutputSections).slice(dummySectionsNum());
   }
   unsigned getNumSections() const {
-    return OutputSections.size() + 1 - NumDummySections;
+    return OutputSections.size() + 1 - dummySectionsNum();
   }
+  // Usually there are 2 dummies sections: ELF header and program header.
+  // Relocatable output does not require program headers to be created.
+  unsigned dummySectionsNum() const { return Config->Relocatable ? 1 : 2; }
 
   void addRelIpltSymbols();
   void addStartEndSymbols();
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
 
   SymbolTable<ELFT> &Symtab;
   std::vector<Phdr> Phdrs;
 

 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
   if (!createSections())
     return;
+  if (!Config->Relocatable) {
     createPhdrs();
     assignAddresses();
+  } else {
+    assignAddressesRelocatable();
+  }
   fixAbsoluteSymbols();
   if (!openFile())
     return;
   writeHeader();
   writeSections();
   if (HasError)
     return;
   fatal(Buffer->commit());
void Writer<ELFT>::scanRelocs(InputSectionBase<ELFT> &S,
   if (RelSec.sh_type == SHT_RELA)
     scanRelocs(S, EObj.relas(&RelSec));
   else
     scanRelocs(S, EObj.rels(&RelSec));
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {
-  if (Config->Shared && !Config->NoUndefined)
+  if ((Config->Relocatable || Config->Shared) && !Config->NoUndefined)
     return;
 
   std::string Msg = "undefined symbol: " + Sym->getName().str();
   if (ELFFileBase<ELFT> *File = Symtab.findFile(Sym))
     Msg += " in " + File->getName().str();
   if (Config->NoInhibitExec)
     warning(Msg);
   else

 template <class ELFT> static void sortCtorsDtors(OutputSectionBase<ELFT> *S) {
   if (S)
     reinterpret_cast<OutputSection<ELFT> *>(S)->sortCtorsDtors();
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> bool Writer<ELFT>::createSections() {
   OutputSections.push_back(Out<ELFT>::ElfHeader);
+  if (!Config->Relocatable)
     OutputSections.push_back(Out<ELFT>::ProgramHeaders);
 
   // Add .interp first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (needsInterpSection())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   // Create output sections for input object file sections.
   std::vector<OutputSectionBase<ELFT> *> RegularSections;
template <class ELFT> bool Writer<ELFT>::createSections() {
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();
 
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareSections<ELFT>);
 
-  for (unsigned I = NumDummySections, N = OutputSections.size(); I < N; ++I)
-    OutputSections[I]->SectionIndex = I + 1 - NumDummySections;
+  for (unsigned I = dummySectionsNum(), N = OutputSections.size(); I < N; ++I)
+    OutputSections[I]->SectionIndex = I + 1 - dummySectionsNum();
 
   for (OutputSectionBase<ELFT> *Sec : getSections())
     Sec->setSHName(Out<ELFT>::ShStrTab->addString(Sec->getName()));
 
   // Finalizers fix each section's size.
   // .dynsym is finalized early since that may fill up .gnu.hash.
   if (isOutputDynamic())
     Out<ELFT>::DynSymTab->finalize();
template <class ELFT> void Writer<ELFT>::createPhdrs() {
   }
 
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack)
     AddHdr(PT_GNU_STACK, PF_R | PF_W);
 }
 
+// Used for relocatable output (-r). In this case we create only ELF file
+// header, do not create program headers. Also assign of section addresses
+// is very straightforward: we just put all sections sequentually to the file.
+template <class ELFT> void Writer<ELFT>::assignAddressesRelocatable() {
+  Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
+  uintX_t FileOff = 0;
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    FileOff = alignTo(FileOff, Sec->getAlign());
+    Sec->setFileOffset(FileOff);
+    FileOff += Sec->getSize();
+  }
+  SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
+  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+}
+
 // Visits all headers in PhdrTable and assigns the adresses to
 // the output sections. Also creates common and special headers.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
   size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
   Out<ELFT>::ProgramHeaders->setSize(PhdrSize);
 
   // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
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();
 
-  EHdr->e_type = Config->Shared ? ET_DYN : ET_EXEC;
+  if (Config->Shared)
+    EHdr->e_type = ET_DYN;
+  else if (Config->Relocatable)
+    EHdr->e_type = ET_REL;
+  else
+    EHdr->e_type = ET_EXEC;
+
   EHdr->e_machine = FirstObj.getEMachine();
   EHdr->e_version = EV_CURRENT;
   EHdr->e_entry = getEntryAddr<ELFT>();
-  EHdr->e_phoff = sizeof(Elf_Ehdr);
   EHdr->e_shoff = SectionHeaderOff;
   EHdr->e_flags = getELFFlags();
   EHdr->e_ehsize = sizeof(Elf_Ehdr);
-  EHdr->e_phentsize = 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;
 
+  if (!Config->Relocatable) {
+    EHdr->e_phoff = sizeof(Elf_Ehdr);
+    EHdr->e_phentsize = sizeof(Elf_Phdr);
+  }
+
   // Write the program header table.
   auto *HBuf = reinterpret_cast<Elf_Phdr *>(Buf + EHdr->e_phoff);
   for (Phdr &P : Phdrs)
     *HBuf++ = P.H;
 
   // 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 : getSections())

lld/trunk/test/ELF/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

lld/trunk/test/ELF/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

lld/trunk/test/ELF/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.lld -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
 
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
-# RUN: not ld.lld -r %t -o %t2 2>&1 | FileCheck %s
+## Test --relocatable alias
+# RUN: ld.lld --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
 
-# CHECK: -r option is not supported. Use 'ar' command instead.
+## Verify that we can use our relocation output as input to produce executable
+# RUN: ld.lld -e main %t -o %texec
+# RUN: llvm-readobj -file-headers %texec | FileCheck -check-prefix=CHECKEXE %s
 
-.globl _start;
-_start:
+## Attempt to link DSO with -r
+# RUN: ld.lld -shared %t1.o -o %t.so
+# RUN: not ld.lld -r %t.so %t2.o -o %tfail 2>&1 | FileCheck -check-prefix=ERR %s
+# ERR: Attempted static link of dynamic object
+
+## Attempt to use -r and shared together
+# RUN: not ld.lld -r -shared %t2.o -o %tfail 2>&1 | FileCheck -check-prefix=ERR2 %s
+# ERR2: -r and -shared may not be used together
+
+# 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: 0x2D8
+# 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: 0x11E8
+# CHECKEXE-NEXT:    Flags [
+# CHECKEXE-NEXT:    ]
+# CHECKEXE-NEXT:    HeaderSize: 64
+# CHECKEXE-NEXT:    ProgramHeaderEntrySize: 56
+# CHECKEXE-NEXT:    ProgramHeaderCount: 5
+# 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
+
+blah:
+goo:
+abs = 42

lld/trunk/test/ELF/strip-all.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %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.lld %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.lld %t.o --strip-all -r -o %t1
+#RUN: llvm-objdump -section-headers %t1 | FileCheck %s -check-prefix BEFORE
+
 # Test alias -s
 #RUN: ld.lld %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