Diff 29688

CMakeLists.txt

	Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
	add_subdirectory(test)			add_subdirectory(test)

	if (LLVM_INCLUDE_TESTS)			if (LLVM_INCLUDE_TESTS)
	add_subdirectory(unittests)			add_subdirectory(unittests)
	endif()			endif()

	add_subdirectory(docs)			add_subdirectory(docs)
	add_subdirectory(COFF)			add_subdirectory(COFF)
				add_subdirectory(ELF)

ELF/CMakeLists.txt

This file was added.

				set(LLVM_TARGET_DEFINITIONS Options.td)
				tablegen(LLVM Options.inc -gen-opt-parser-defs)
				add_public_tablegen_target(ELFOptionsTableGen)

				add_llvm_library(lldELF2
				Chunks.cpp
				Driver.cpp
				DriverUtils.cpp
				InputFiles.cpp
				SymbolTable.cpp
				Symbols.cpp
				Writer.cpp

				LINK_COMPONENTS
				${LLVM_TARGETS_TO_BUILD}
				Core
				LTO
				ruiuUnsubmitted Done Reply Inline Actions Can you remove LTO from this patch? Unless we start working on LTO right now, it's going to be dead code. I'd like you to strip down as much as you can. ruiu: Can you remove LTO from this patch? Unless we start working on LTO right now, it's going to be…
				MC
				rafaelUnsubmitted Done Reply Inline Actions Please delete the LTO dependency. I added it to CMakeList to fix the build, but it should be removed and the code changed to avoid the dependency. rafael: Please delete the LTO dependency. I added it to CMakeList to fix the build, but it should be…
				MCDisassembler
				Support
				)

				add_dependencies(lldELF2 ELFOptionsTableGen)

ELF/Chunks.h

This file was added.

				//===- Chunks.h -----------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_CHUNKS_H
				#define LLD_ELF_CHUNKS_H

				#include "lld/Core/LLVM.h"
				#include "llvm/ADT/ArrayRef.h"
				#include "llvm/Object/ELF.h"
				#include <map>
				#include <vector>

				namespace lld {
				namespace elfv2 {
				ruiuUnsubmitted Done Reply Inline Actions I'd name elf2 instead of elfv2 because it's shorter and consistent with lldELF2. ruiu: I'd name elf2 instead of elfv2 because it's shorter and consistent with lldELF2.

				class Defined;
				template <class ELFT> class ObjectFile;
				class OutputSection;

				// A Chunk represents a chunk of data that will occupy space in the
				// output (if the resolver chose that). It may or may not be backed by
				// a section of an input file. It could be linker-created data, or
				// doesn't even have actual data (if common or bss).
				class Chunk {
				public:
				virtual ~Chunk() = default;

				// Returns the size of this chunk (even if this is a common or BSS.)
				virtual size_t getSize() const = 0;

				// Write this chunk to a mmap'ed file, assuming Buf is pointing to
				// beginning of the file. Because this function may use VA values
				// of other chunks for relocations, you need to set them properly
				// before calling this function.
				virtual void writeTo(uint8_t *Buf) {}

				// The writer sets and uses the addresses.
				uint64_t getVA() { return VA; }
				uint64_t getFileOff() { return FileOff; }
				uint32_t getAlign() { return Align; }
				atanasyanUnsubmitted Not Done Reply Inline Actions Make these methods `const` atanasyan: Make these methods `const`
				void setVA(uint64_t V) { VA = V; }
				void setFileOff(uint64_t V) { FileOff = V; }

				// Returns true if this has non-zero data. BSS chunks return
				// false. If false is returned, the space occupied by this chunk
				// will be filled with zeros.
				virtual bool hasData() const { return true; }

				// Returns readable/writable/executable bits.
				virtual uint32_t getFlags() const { return 0; }

				// Returns the section name if this is a section chunk.
				// It is illegal to call this function on non-section chunks.
				virtual StringRef getSectionName() const {
				llvm_unreachable("unimplemented getSectionName");
				}

				// Called if the garbage collector decides to not include this chunk
				// in a final output. It's supposed to print out a log message to stdout.
				// It is illegal to call this function on non-section chunks because
				// only section chunks are subject of garbage collection.
				virtual void printDiscardedMessage() {
				llvm_unreachable("unimplemented printDiscardedMessage");
				}

				// Used by the garbage collector.
				bool isRoot() { return Root; }
				bool isLive() { return Live; }
				atanasyanUnsubmitted Not Done Reply Inline Actions Make these methods `const` atanasyan: Make these methods `const`
				void markLive() {
				if (!Live)
				mark();
				}

				// An output section has pointers to chunks in the section, and each
				// chunk has a back pointer to an output section.
				void setOutputSection(OutputSection *O) { Out = O; }
				OutputSection *getOutputSection() { return Out; }

				protected:
				// The VA of this chunk in the output. The writer sets a value.
				uint64_t VA = 0;

				// The offset from beginning of the output file. The writer sets a value.
				uint64_t FileOff = 0;

				rafaelUnsubmitted Done Reply Inline Actions Delete the garbage collector. It should be added in another patch and the terminology for ELF is different anyway. rafael: Delete the garbage collector. It should be added in another patch and the terminology for ELF…
				// The output section for this chunk.
				OutputSection *Out = nullptr;

				// The alignment of this chunk. The writer uses the value.
				uint32_t Align = 1;

				// Used by the garbage collector.
				virtual void mark() {}
				bool Live = true;
				bool Root = false;
				};

				// A chunk corresponding a section of an input file.
				template <class ELFT> class SectionChunk : public Chunk {
				typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
				typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
				typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;

				public:
				SectionChunk(ObjectFile<ELFT> File, const Elf_Shdr Header,
				uint32_t SectionIndex);
				size_t getSize() const override { return Header->sh_size; }
				void writeTo(uint8_t *Buf) override;
				bool hasData() const override;
				uint32_t getFlags() const override;
				StringRef getSectionName() const override { return SectionName; }
				void printDiscardedMessage() override;

				private:
				void mark() override;
				const Elf_Shdr *getSectionHdr();
				void applyReloc(uint8_t Buf, const Elf_Rela Rel);
				void applyReloc(uint8_t Buf, const Elf_Rel Rel);

				// A file this chunk was created from.
				ObjectFile<ELFT> *File;

				const Elf_Shdr *Header;
				uint32_t SectionIndex;
				StringRef SectionName;
				};

				// A chunk for common symbols. Common chunks don't have actual data.
				template <class ELFT> class CommonChunk : public Chunk {
				typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;

				public:
				CommonChunk(const Elf_Sym *Sym);
				size_t getSize() const override { return Sym->getValue(); }
				bool hasData() const override { return false; }
				uint32_t getFlags() const override;
				StringRef getSectionName() const override { return ".bss"; }

				private:
				const Elf_Sym *Sym;
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/Chunks.cpp

This file was added.

				//===- Chunks.cpp ---------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Chunks.h"
				#include "InputFiles.h"
				#include "Writer.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/Endian.h"
				#include "llvm/Support/raw_ostream.h"

				using namespace llvm;
				using namespace llvm::object;
				using namespace llvm::support::endian;
				using namespace llvm::ELF;

				using namespace lld;
				using namespace lld::elfv2;

				template <class ELFT>
				SectionChunk<ELFT>::SectionChunk(elfv2::ObjectFile<ELFT> F, const Elf_Shdr H,
				ruiuUnsubmitted Done Reply Inline Actions You can remove "elfv2::". ruiu: You can remove "elfv2::".
				BigcheeseAuthorUnsubmitted Not Done Reply Inline Actions ObjectFile is also a name in llvm::object. Bigcheese: ObjectFile is also a name in llvm::object.
				uint32_t SI)
				: File(F), Header(H), SectionIndex(SI) {
				// Initialize SectionName.
				SectionName = *File->getObj()->getSectionName(Header);

				Align = Header->sh_addralign;

				// When a new chunk is created, we don't if if it's going to make it
				// to the final output. Initially all sections are unmarked in terms
				// of garbage collection. The writer will call markLive() to mark
				// all reachable section chunks.
				Live = false;

				Root = true;
				}

				template <class ELFT> void SectionChunk<ELFT>::writeTo(uint8_t *Buf) {
				if (!hasData())
				return;
				// Copy section contents from source object file to output file.
				ArrayRef<uint8_t> Data = *File->getObj()->getSectionContents(Header);
				memcpy(Buf + FileOff, Data.data(), Data.size());

				// FIXME: Relocations
				}

				template <class ELFT> void SectionChunk<ELFT>::mark() {
				assert(!Live);
				Live = true;

				// Mark all symbols listed in the relocation table for this section.
				// FIXME: Relocations
				}

				template <class ELFT>
				void SectionChunk<ELFT>::applyReloc(uint8_t Buf, const Elf_Rela Rel) {
				// FIXME: Relocations
				}

				template <class ELFT>
				void SectionChunk<ELFT>::applyReloc(uint8_t Buf, const Elf_Rel Rel) {}

				template <class ELFT> bool SectionChunk<ELFT>::hasData() const {
				return Header->sh_type != SHT_NOBITS;
				}

				template <class ELFT> uint32_t SectionChunk<ELFT>::getFlags() const {
				return Header->sh_flags;
				}

				// Prints "Discarded <symbol>" for all external function symbols.
				template <class ELFT> void SectionChunk<ELFT>::printDiscardedMessage() {
				auto Obj = File->getObj();
				rafaelUnsubmitted Not Done Reply Inline Actions You don't need this on the first patch. rafael: You don't need this on the first patch.

				for (auto &&Sym : Obj->symbols()) {
				auto Sec = Obj->getSection(&Sym);
				if (Sec && *Sec != Header)
				continue;
				rafaelUnsubmitted Done Reply Inline Actions This test doesn't need common symbols. Delete this. It should be added in a followup patch. This is also copying over COFF specific code and comments. rafael: This test doesn't need common symbols. Delete this. It should be added in a followup patch.
				if (Sym.getType() != STT_FUNC)
				continue;
				if (auto Name = Obj->getStaticSymbolName(&Sym)) {
				llvm::outs() << "Discarded " << *Name << " from " << File->getShortName()
				<< "\n";
				}
				}
				}

				template <class ELFT>
				const llvm::object::Elf_Shdr_Impl<ELFT> *SectionChunk<ELFT>::getSectionHdr() {
				return Header;
				}

				template <class ELFT>
				CommonChunk<ELFT>::CommonChunk(const Elf_Sym *S)
				: Sym(S) {
				// Alignment is a section attribute, but common symbols don't
				// belong to any section. How do we know common data alignments?
				// Needs investigating. For now, we set a large number as an alignment.
				Align = 16;
				}

				template <class ELFT> uint32_t CommonChunk<ELFT>::getFlags() const {
				return PF_R \| PF_W;
				}

				namespace lld {
				namespace elfv2 {
				template class SectionChunk<llvm::object::ELF32LE>;
				template class SectionChunk<llvm::object::ELF32BE>;
				template class SectionChunk<llvm::object::ELF64LE>;
				template class SectionChunk<llvm::object::ELF64BE>;

				template class CommonChunk<llvm::object::ELF32LE>;
				template class CommonChunk<llvm::object::ELF32BE>;
				template class CommonChunk<llvm::object::ELF64LE>;
				template class CommonChunk<llvm::object::ELF64BE>;
				}
				}

ELF/Config.h

This file was added.

				//===- Config.h -----------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_CONFIG_H
				#define LLD_ELF_CONFIG_H

				#include "llvm/ADT/StringRef.h"
				#include "llvm/Object/ELF.h"
				#include <set>
				#include <string>

				namespace lld {
				namespace elfv2 {

				using llvm::StringRef;

				class Configuration {
				public:
				int MachineArchitecture = llvm::ELF::EM_X86_64;
				bool Verbose = false;
				StringRef EntryName;
				std::string OutputFile;
				bool DoGC = true;

				// Symbols in this set are considered as live by the garbage collector.
				std::set<StringRef> GCRoots;
				};

				extern Configuration *Config;

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/Driver.h

This file was added.

				//===- Driver.h -----------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_DRIVER_H
				#define LLD_ELF_DRIVER_H

				#include "lld/Core/LLVM.h"
				#include "llvm/ADT/Optional.h"
				#include "llvm/ADT/StringRef.h"
				#include "llvm/Object/ELF.h"
				#include "llvm/Option/Arg.h"
				#include "llvm/Option/ArgList.h"
				#include "llvm/Support/StringSaver.h"
				#include <memory>
				#include <set>
				#include <system_error>
				#include <vector>

				namespace lld {
				namespace elfv2 {

				class LinkerDriver;
				extern LinkerDriver *Driver;

				using llvm::Optional;
				class InputFile;

				// Entry point of the ELF linker.
				bool link(llvm::ArrayRef<const char *> Args);

				class ArgParser {
				public:
				ArgParser() : Alloc(AllocAux) {}
				// Parses command line options.
				ErrorOr<llvm::opt::InputArgList> parse(llvm::ArrayRef<const char *> Args);

				// Tokenizes a given string and then parses as command line options.
				ErrorOr<llvm::opt::InputArgList> parse(StringRef S) {
				return parse(tokenize(S));
				}

				private:
				ErrorOr<llvm::opt::InputArgList> parse(std::vector<const char *> Argv);

				std::vector<const char *> tokenize(StringRef S);

				ErrorOr<std::vector<const char *>>
				replaceResponseFiles(std::vector<const char *>);

				llvm::BumpPtrAllocator AllocAux;
				llvm::BumpPtrStringSaver Alloc;
				};

				class LinkerDriver {
				public:
				LinkerDriver() : Alloc(AllocAux) {}
				bool link(llvm::ArrayRef<const char *> Args);

				private:
				llvm::BumpPtrAllocator AllocAux;
				llvm::BumpPtrStringSaver Alloc;
				ArgParser Parser;

				// Opens a file. Path has to be resolved already.
				ErrorOr<MemoryBufferRef> openFile(StringRef Path);

				// Searches a file from search paths.
				Optional<StringRef> findFile(StringRef Filename);
				Optional<StringRef> findLib(StringRef Filename);
				StringRef doFindFile(StringRef Filename);
				StringRef doFindLib(StringRef Filename);

				std::vector<StringRef> SearchPaths;
				std::set<std::string> VisitedFiles;

				// Driver is the owner of all opened files.
				// InputFiles have MemoryBufferRefs to them.
				std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
				};

				// Functions below this line are defined in DriverUtils.cpp.

				void printHelp(const char *Argv0);

				// Create enum with OPT_xxx values for each option in Options.td
				enum {
				OPT_INVALID = 0,
				#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
				#include "Options.inc"
				#undef OPTION
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/Driver.cpp

This file was added.

				//===- Driver.cpp ---------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Config.h"
				#include "Driver.h"
				#include "InputFiles.h"
				#include "SymbolTable.h"
				#include "Writer.h"
				#include "llvm/ADT/Optional.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/ADT/StringSwitch.h"
				#include "llvm/LibDriver/LibDriver.h"
				#include "llvm/Option/Arg.h"
				#include "llvm/Option/ArgList.h"
				#include "llvm/Option/Option.h"
				#include "llvm/Support/CommandLine.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/Path.h"
				#include "llvm/Support/Process.h"
				#include "llvm/Support/TargetSelect.h"
				#include "llvm/Support/raw_ostream.h"
				#include <algorithm>
				#include <memory>

				using namespace llvm;
				using llvm::sys::fs::file_magic;
				using llvm::sys::fs::identify_magic;

				using namespace lld;
				using namespace lld::elfv2;

				namespace lld {
				namespace elfv2 {
				Configuration *Config;
				LinkerDriver *Driver;

				bool link(llvm::ArrayRef<const char *> Args) {
				auto C = make_unique<Configuration>();
				Config = C.get();
				auto D = make_unique<LinkerDriver>();
				Driver = D.get();
				return Driver->link(Args);
				}
				}
				}

				// Drop directory components and replace extension with ".exe".
				static std::string getOutputPath(StringRef Path) {
				auto P = Path.find_last_of("\\/");
				StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
				return (S.substr(0, S.rfind('.')) + ".exe").str();
				atanasyanUnsubmitted Not Done Reply Inline Actions Does the `exe` extension has a sense for ELF file? atanasyan: Does the `exe` extension has a sense for ELF file?
				}
				ruiuUnsubmitted Done Reply Inline Actions Let's remove this function and make -o option mandatory for now. This function is really Windows-specific. ruiu: Let's remove this function and make -o option mandatory for now. This function is really…

				// Opens a file. Path has to be resolved already.
				// Newly created memory buffers are owned by this driver.
				ErrorOr<MemoryBufferRef> LinkerDriver::openFile(StringRef Path) {
				auto MBOrErr = MemoryBuffer::getFile(Path);
				if (auto EC = MBOrErr.getError())
				return EC;
				std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
				MemoryBufferRef MBRef = MB->getMemBufferRef();
				OwningMBs.push_back(std::move(MB)); // take ownership
				return MBRef;
				}

				static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
				// File type is detected by contents, not by file extension.
				file_magic Magic = identify_magic(MB.getBuffer());
				if (Magic == file_magic::archive)
				return std::unique_ptr<InputFile>(new ArchiveFile(MB));
				if (Magic == file_magic::bitcode)
				return std::unique_ptr<InputFile>(new BitcodeFile(MB));
				if (Config->OutputFile == "")
				Config->OutputFile = getOutputPath(MB.getBufferIdentifier());
				return std::unique_ptr<InputFile>(new ObjectFile<llvm::object::ELF64LE>(MB));
				}

				// Find file from search paths. You can omit ".obj", this function takes
				atanasyanUnsubmitted Not Done Reply Inline Actions s/obj/o/ atanasyan: s/obj/o/
				// care of that. Note that the returned path is not guaranteed to exist.
				StringRef LinkerDriver::doFindFile(StringRef Filename) {
				bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
				if (hasPathSep)
				return Filename;
				bool hasExt = (Filename.find('.') != StringRef::npos);
				for (StringRef Dir : SearchPaths) {
				SmallString<128> Path = Dir;
				llvm::sys::path::append(Path, Filename);
				if (llvm::sys::fs::exists(Path.str()))
				return Alloc.save(Path.str());
				if (!hasExt) {
				Path.append(".obj");
				atanasyanUnsubmitted Not Done Reply Inline Actions s/obj/o/ atanasyan: s/obj/o/
				if (llvm::sys::fs::exists(Path.str()))
				return Alloc.save(Path.str());
				}
				}
				return Filename;
				}
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto

				// Resolves a file path. This never returns the same path
				// (in that case, it returns None).
				Optional<StringRef> LinkerDriver::findFile(StringRef Filename) {
				StringRef Path = doFindFile(Filename);
				bool Seen = !VisitedFiles.insert(Path.lower()).second;
				if (Seen)
				return None;
				return Path;
				}

				// Find library file from search path.
				StringRef LinkerDriver::doFindLib(StringRef Filename) {
				// Add ".lib" to Filename if that has no file extension.
				bool hasExt = (Filename.find('.') != StringRef::npos);
				if (!hasExt)
				Filename = Alloc.save(Filename + ".lib");
				atanasyanUnsubmitted Not Done Reply Inline Actions This code is not applicable for ELF atanasyan: This code is not applicable for ELF
				return doFindFile(Filename);
				}

				// Resolves a library path. /nodefaultlib options are taken into
				atanasyanUnsubmitted Not Done Reply Inline Actions /nodefaultlib is not applicable for ELF. atanasyan: /nodefaultlib is not applicable for ELF.
				// consideration. This never returns the same path (in that case,
				// it returns None).
				Optional<StringRef> LinkerDriver::findLib(StringRef Filename) {
				ruiuUnsubmitted Done Reply Inline Actions Same for findFile, doFindLib and findLib. ruiu: Same for findFile, doFindLib and findLib.
				StringRef Path = doFindLib(Filename);
				bool Seen = !VisitedFiles.insert(Path.lower()).second;
				if (Seen)
				return None;
				return Path;
				}

				bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
				atanasyanUnsubmitted Not Done Reply Inline Actions The code below are from the COFF linker. Do we really need to commit it to ELF? atanasyan: The code below are from the COFF linker. Do we really need to commit it to ELF?
				// Needed for LTO.
				llvm::InitializeAllTargetInfos();
				llvm::InitializeAllTargets();
				llvm::InitializeAllTargetMCs();
				llvm::InitializeAllAsmParsers();
				llvm::InitializeAllAsmPrinters();
				llvm::InitializeAllDisassemblers();
				ruiuUnsubmitted Done Reply Inline Actions If you remove LTO, you can remove these function calls. ruiu: If you remove LTO, you can remove these function calls.

				// Parse command line options.
				auto ArgsOrErr = Parser.parse(ArgsArr);
				if (auto EC = ArgsOrErr.getError()) {
				llvm::errs() << EC.message() << "\n";
				return false;
				}
				llvm::opt::InputArgList Args = std::move(ArgsOrErr.get());

				// Handle /help
				if (Args.hasArg(OPT_help)) {
				printHelp(ArgsArr[0]);
				return true;
				}

				if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end()) {
				llvm::errs() << "no input files.\n";
				return false;
				}

				// Construct search path list.
				SearchPaths.push_back("");
				for (auto *Arg : Args.filtered(OPT_L))
				SearchPaths.push_back(Arg->getValue());

				// Handle /out
				if (auto *Arg = Args.getLastArg(OPT_output))
				Config->OutputFile = Arg->getValue();

				// Handle /entry
				if (auto *Arg = Args.getLastArg(OPT_e))
				Config->EntryName = Arg->getValue();

				// Create a list of input files. Files can be given as arguments
				// for /defaultlib option.
				std::vector<StringRef> InputPaths;
				std::vector<MemoryBufferRef> Inputs;
				for (auto *Arg : Args.filtered(OPT_INPUT))
				if (Optional<StringRef> Path = findFile(Arg->getValue()))
				InputPaths.push_back(*Path);

				for (StringRef Path : InputPaths) {
				ErrorOr<MemoryBufferRef> MBOrErr = openFile(Path);
				if (auto EC = MBOrErr.getError()) {
				llvm::errs() << "cannot open " << Path << ": " << EC.message() << "\n";
				return false;
				}
				Inputs.push_back(MBOrErr.get());
				}

				// Create a symbol table.
				SymbolTable<llvm::object::ELF64LE> Symtab;

				// Parse all input files and put all symbols to the symbol table.
				// The symbol table will take care of name resolution.
				for (MemoryBufferRef MB : Inputs) {
				std::unique_ptr<InputFile> File = createFile(MB);
				if (Config->Verbose)
				llvm::outs() << "Reading " << File->getName() << "\n";
				if (auto EC = Symtab.addFile(std::move(File))) {
				llvm::errs() << MB.getBufferIdentifier() << ": " << EC.message() << "\n";
				return false;
				}
				}

				// Make sure we have resolved all symbols.
				if (Symtab.reportRemainingUndefines())
				return false;

				// Initialize a list of GC root.
				Config->GCRoots.insert(Config->EntryName);

				// Do LTO by compiling bitcode input files to a native ELF file
				// then link that file.
				if (auto EC = Symtab.addCombinedLTOObject()) {
				llvm::errs() << EC.message() << "\n";
				return false;
				}

				// Write the result.
				Writer<llvm::object::ELF64LE> Out(&Symtab);
				if (auto EC = Out.write(Config->OutputFile)) {
				llvm::errs() << EC.message() << "\n";
				return false;
				}
				return true;
				}

ELF/DriverUtils.cpp

This file was added.

				//===- DriverUtils.cpp ----------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file contains utility functions for the driver. Because there
				// are so many small functions, we created this separate file to make
				// Driver.cpp less cluttered.
				//
				//===----------------------------------------------------------------------===//

				#include "Config.h"
				#include "Driver.h"
				#include "Error.h"
				#include "llvm/ADT/Optional.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/ADT/StringSwitch.h"
				#include "llvm/Option/Arg.h"
				#include "llvm/Option/ArgList.h"
				#include "llvm/Option/Option.h"
				#include "llvm/Support/CommandLine.h"
				#include "llvm/Support/Process.h"
				#include "llvm/Support/Program.h"
				#include "llvm/Support/raw_ostream.h"
				#include <memory>

				using namespace llvm;
				using llvm::cl::ExpandResponseFiles;
				using llvm::cl::TokenizeWindowsCommandLine;
				using llvm::sys::Process;

				using namespace lld;
				using namespace lld::elfv2;

				// Create OptTable

				// Create prefix string literals used in Options.td
				#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
				#include "Options.inc"
				#undef PREFIX

				// Create table mapping all options defined in Options.td
				static const llvm::opt::OptTable::Info infoTable[] = {
				#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X6, X7, X8, X9, X10) \
				{ \
				X1, X2, X9, X10, OPT_##ID, llvm::opt::Option::KIND##Class, X8, X7, \
				OPT_##GROUP, OPT_##ALIAS, X6 \
				} \
				,
				#include "Options.inc"
				#undef OPTION
				};

				class ELFOptTable : public llvm::opt::OptTable {
				public:
				ELFOptTable() : OptTable(infoTable, llvm::array_lengthof(infoTable)) {}
				};

				// Parses a given list of options.
				ErrorOr<llvm::opt::InputArgList>
				ArgParser::parse(std::vector<const char *> Argv) {
				// First, replace respnose files (@<file>-style options).
				auto ArgvOrErr = replaceResponseFiles(Argv);
				if (auto EC = ArgvOrErr.getError()) {
				llvm::errs() << "error while reading response file: " << EC.message()
				<< "\n";
				return EC;
				}
				Argv = std::move(ArgvOrErr.get());

				// Make InputArgList from string vectors.
				ELFOptTable Table;
				unsigned MissingIndex;
				unsigned MissingCount;

				llvm::opt::InputArgList Args =
				Table.ParseArgs(Argv, MissingIndex, MissingCount);
				if (MissingCount) {
				llvm::errs() << "missing arg value for \""
				<< Args.getArgString(MissingIndex) << "\", expected "
				<< MissingCount
				<< (MissingCount == 1 ? " argument.\n" : " arguments.\n");
				return make_error_code(LLDError::InvalidOption);
				}
				for (auto *Arg : Args.filtered(OPT_UNKNOWN))
				llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
				return std::move(Args);
				}

				ErrorOr<llvm::opt::InputArgList>
				ArgParser::parse(llvm::ArrayRef<const char *> Args) {
				Args = Args.slice(1);
				std::vector<const char *> V(Args.begin(), Args.end());
				return parse(V);
				}

				std::vector<const char *> ArgParser::tokenize(StringRef S) {
				SmallVector<const char *, 16> Tokens;
				BumpPtrStringSaver Saver(AllocAux);
				llvm::cl::TokenizeWindowsCommandLine(S, Saver, Tokens);
				return std::vector<const char *>(Tokens.begin(), Tokens.end());
				}

				// Creates a new command line by replacing options starting with '@'
				// character. '@<filename>' is replaced by the file's contents.
				ErrorOr<std::vector<const char *>>
				ArgParser::replaceResponseFiles(std::vector<const char *> Argv) {
				SmallVector<const char *, 256> Tokens(Argv.data(), Argv.data() + Argv.size());
				rafaelUnsubmitted Done Reply Inline Actions Delete this. It should be added when we add a test that uses response files. rafael: Delete this. It should be added when we add a test that uses response files.
				BumpPtrStringSaver Saver(AllocAux);
				ExpandResponseFiles(Saver, TokenizeWindowsCommandLine, Tokens);
				return std::vector<const char *>(Tokens.begin(), Tokens.end());
				}

				void lld::elfv2::printHelp(const char *Argv0) {
				ELFOptTable Table;
				Table.PrintHelp(llvm::outs(), Argv0, "LLVM Linker", false);
				}

ELF/Error.h

This file was added.

				//===- Error.h ------------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_ERROR_H
				#define LLD_ELF_ERROR_H

				#include <string>
				#include <system_error>
				#include "llvm/Support/ErrorHandling.h"

				namespace lld {
				namespace elfv2 {

				enum class LLDError {
				InvalidOption = 1,
				InvalidFile,
				BrokenFile,
				DuplicateSymbols,
				};

				class LLDErrorCategory : public std::error_category {
				public:
				const char *name() const LLVM_NOEXCEPT override { return "lld"; }

				std::string message(int EV) const override {
				switch (static_cast<LLDError>(EV)) {
				case LLDError::InvalidOption:
				return "Invalid option";
				case LLDError::InvalidFile:
				return "Invalid file";
				case LLDError::BrokenFile:
				return "Broken file";
				case LLDError::DuplicateSymbols:
				return "Duplicate symbols";
				}
				llvm_unreachable("unknown error");
				}
				};

				inline std::error_code make_error_code(LLDError Err) {
				static LLDErrorCategory C;
				return std::error_code(static_cast<int>(Err), C);
				}

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/InputFiles.h

This file was added.

				//===- InputFiles.h -------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_INPUT_FILES_H
				#define LLD_ELF_INPUT_FILES_H

				#include "Chunks.h"
				#include "Symbols.h"
				#include "lld/Core/LLVM.h"
				#include "llvm/ADT/ArrayRef.h"
				#include "llvm/LTO/LTOModule.h"
				#include "llvm/Object/Archive.h"
				#include "llvm/Object/ELF.h"
				#include "llvm/Support/StringSaver.h"
				#include <memory>
				#include <set>
				#include <vector>

				namespace lld {
				namespace elfv2 {

				using llvm::LTOModule;
				using llvm::object::Archive;
				using llvm::object::ELFFile;

				// The root class of input files.
				class InputFile {
				public:
				enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
				Kind kind() const { return FileKind; }
				virtual ~InputFile() {}

				// Returns the filename.
				StringRef getName() { return MB.getBufferIdentifier(); }

				// Returns symbols defined by this file.
				virtual std::vector<SymbolBody *> &getSymbols() = 0;

				// Reads a file (constructors don't do that). Returns an error if a
				// file is broken.
				virtual std::error_code parse() = 0;

				// Returns a short, human-friendly filename. If this is a member of
				// an archive file, a returned value includes parent's filename.
				// Used for logging or debugging.
				std::string getShortName();

				// Sets a parent filename if this file is created from an archive.
				void setParentName(StringRef N) { ParentName = N; }

				protected:
				explicit InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
				MemoryBufferRef MB;

				private:
				const Kind FileKind;
				StringRef ParentName;
				};

				// .lib or .a file.
				class ArchiveFile : public InputFile {
				public:
				explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
				static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
				std::error_code parse() override;

				// Returns a memory buffer for a given symbol. An empty memory buffer
				// is returned if we have already returned the same memory buffer.
				// (So that we don't instantiate same members more than once.)
				ErrorOr<MemoryBufferRef> getMember(const Archive::Symbol *Sym);

				// NB: All symbols returned by ArchiveFiles are of Lazy type.
				std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }

				private:
				std::unique_ptr<Archive> File;
				std::string Filename;
				std::vector<SymbolBody *> SymbolBodies;
				std::set<const char *> Seen;
				llvm::MallocAllocator Alloc;
				};

				// .obj or .o file. This may be a member of an archive file.
				template <class ELFT> class ObjectFile : public InputFile {
				typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;

				public:
				explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
				static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
				std::error_code parse() override;
				std::vector<Chunk *> &getChunks() { return Chunks; }
				std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }

				// Returns a SymbolBody object for the SymbolIndex'th symbol in the
				// underlying object file.
				SymbolBody *getSymbolBody(uint32_t SymbolIndex);

				// Returns the underying ELF file.
				ELFFile<ELFT> *getObj() { return ELFObj.get(); }

				private:
				std::error_code initializeChunks();
				std::error_code initializeSymbols();

				SymbolBody createSymbolBody(const Elf_Sym Sym);

				std::unique_ptr<ELFFile<ELFT>> ELFObj;
				llvm::BumpPtrAllocator Alloc;

				// List of all chunks defined by this file. This includes both section
				// chunks and non-section chunks for common symbols.
				std::vector<Chunk *> Chunks;

				// This vector contains the same chunks as Chunks, but they are
				// indexed such that you can get a SectionChunk by section index.
				// Nonexistent section indices are filled with null pointers.
				// (Because section number is 1-based, the first slot is always a
				// null pointer.)
				std::vector<Chunk *> SparseChunks;

				// List of all symbols referenced or defined by this file.
				std::vector<SymbolBody *> SymbolBodies;

				// This vector contains the same symbols as SymbolBodies, but they
				// are indexed such that you can get a SymbolBody by symbol
				// index. Nonexistent indices (which are occupied by auxiliary
				// symbols in the real symbol table) are filled with null pointers.
				std::vector<SymbolBody *> SparseSymbolBodies;
				};

				// Used for LTO.
				class BitcodeFile : public InputFile {
				public:
				explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
				static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
				std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }

				LTOModule *getModule() const { return M.get(); }
				LTOModule *releaseModule() { return M.release(); }

				private:
				std::error_code parse() override;

				std::vector<SymbolBody *> SymbolBodies;
				llvm::BumpPtrAllocator Alloc;
				std::unique_ptr<LTOModule> M;
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/InputFiles.cpp

This file was added.

				//===- InputFiles.cpp -----------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Chunks.h"
				#include "Error.h"
				#include "InputFiles.h"
				#include "Writer.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/LTO/LTOModule.h"
				#include "llvm/Object/ELF.h"
				#include "llvm/Support/ELF.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/Endian.h"
				#include "llvm/Support/raw_ostream.h"

				using namespace llvm::ELF;
				using namespace llvm::object;
				using namespace llvm::support::endian;
				using llvm::RoundUpToAlignment;
				using llvm::sys::fs::identify_magic;
				using llvm::sys::fs::file_magic;

				using namespace lld;
				using namespace lld::elfv2;

				// Returns the last element of a path, which is supposed to be a filename.
				static StringRef getBasename(StringRef Path) {
				atanasyanUnsubmitted Done Reply Inline Actions Is this code equal to `llvm::sys::path::filename`? atanasyan: Is this code equal to `llvm::sys::path::filename`?
				size_t Pos = Path.rfind('\\');
				if (Pos == StringRef::npos)
				return Path;
				return Path.substr(Pos + 1);
				}

				// Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
				std::string InputFile::getShortName() {
				if (ParentName == "")
				return getName().lower();
				std::string Res =
				(getBasename(ParentName) + "(" + getBasename(getName()) + ")").str();
				return StringRef(Res).lower();
				}
				rafaelUnsubmitted Done Reply Inline Actions Handle the error in here instead of returning it. rafael: Handle the error in here instead of returning it.

				std::error_code ArchiveFile::parse() {
				// Parse a MemoryBufferRef as an archive file.
				auto ArchiveOrErr = Archive::create(MB);
				if (auto EC = ArchiveOrErr.getError())
				return EC;
				File = std::move(ArchiveOrErr.get());

				// Allocate a buffer for Lazy objects.
				size_t BufSize = File->getNumberOfSymbols() * sizeof(Lazy);
				Lazy Buf = (Lazy )Alloc.Allocate(BufSize, llvm::alignOf<Lazy>());

				// Read the symbol table to construct Lazy objects.
				uint32_t I = 0;
				for (const Archive::Symbol &Sym : File->symbols()) {
				SymbolBodies.push_back(new (&Buf[I++]) Lazy(this, Sym));
				}
				return std::error_code();
				}

				// Returns a buffer pointing to a member file containing a given symbol.
				ErrorOr<MemoryBufferRef> ArchiveFile::getMember(const Archive::Symbol *Sym) {
				auto ItOrErr = Sym->getMember();
				if (auto EC = ItOrErr.getError())
				return EC;
				Archive::child_iterator It = ItOrErr.get();

				// Return an empty buffer if we have already returned the same buffer.
				const char *StartAddr = It->getBuffer().data();
				auto Pair = Seen.insert(StartAddr);
				if (!Pair.second)
				return MemoryBufferRef();
				return It->getMemoryBufferRef();
				}

				template <class ELFT> std::error_code elfv2::ObjectFile<ELFT>::parse() {
				// Parse a memory buffer as a ELF file.
				std::error_code EC;
				ELFObj = llvm::make_unique<ELFFile<ELFT>>(MB.getBuffer(), EC);

				if (EC) {
				llvm::errs() << getName() << " is not an ELF file.\n";
				return EC;
				}

				// Read section and symbol tables.
				if ((EC = initializeChunks()))
				return EC;
				return initializeSymbols();
				}

				template <class ELFT>
				SymbolBody *elfv2::ObjectFile<ELFT>::getSymbolBody(uint32_t SymbolIndex) {
				return SparseSymbolBodies[SymbolIndex]->getReplacement();
				}

				static bool isIgnoredSectionType(unsigned Type) {
				switch (Type) {
				case SHT_NULL:
				case SHT_SYMTAB:
				case SHT_STRTAB:
				case SHT_RELA:
				case SHT_HASH:
				case SHT_DYNAMIC:
				case SHT_NOTE:
				case SHT_REL:
				case SHT_DYNSYM:
				case SHT_SYMTAB_SHNDX:
				return true;
				}
				return false;
				}

				template <class ELFT>
				std::error_code elfv2::ObjectFile<ELFT>::initializeChunks() {
				auto Size = ELFObj->getNumSections();
				ruiuUnsubmitted Done Reply Inline Actions Replace "auto" with its real type. ruiu: Replace "auto" with its real type.
				Chunks.reserve(Size);
				SparseChunks.resize(Size);
				int I = 0;
				for (auto &&Sec : ELFObj->sections()) {
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				if (isIgnoredSectionType(Sec.sh_type) \|\| Sec.sh_addralign == 0) {
				++I;
				continue;
				}
				auto *C = new (Alloc) SectionChunk<ELFT>(this, &Sec, I);
				Chunks.push_back(C);
				SparseChunks[I] = C;
				++I;
				}
				return std::error_code();
				atanasyanUnsubmitted Not Done Reply Inline Actions Will this function return something else except "success" code? atanasyan: Will this function return something else except "success" code?
				BigcheeseAuthorUnsubmitted Not Done Reply Inline Actions It will. The intent is for this to be the one place we scan the entire section table, which can find broken files. Bigcheese: It will. The intent is for this to be the one place we scan the entire section table, which can…
				}

				template <class ELFT>
				std::error_code elfv2::ObjectFile<ELFT>::initializeSymbols() {
				auto Syms = ELFObj->symbols();
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				Syms = typename ELFFile<ELFT>::Elf_Sym_Range(Syms.begin() + 1, Syms.end());
				auto NumSymbols = std::distance(Syms.begin(), Syms.end());
				SymbolBodies.reserve(NumSymbols + 1);
				SparseSymbolBodies.resize(NumSymbols + 1);
				int I = 1;
				for (auto &&Sym : Syms) {
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				SymbolBody *Body = createSymbolBody(&Sym);
				if (Body) {
				SymbolBodies.push_back(Body);
				SparseSymbolBodies[I] = Body;
				}
				++I;
				}

				return std::error_code();
				}

				template <class ELFT>
				SymbolBody elfv2::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym Sym) {
				StringRef Name;
				if (Sym->isUndefined()) {
				Name = *ELFObj->getStaticSymbolName(Sym);
				return new (Alloc) Undefined(Name);
				}
				if (Sym->isCommon()) {
				Chunk *C = new (Alloc) CommonChunk<ELFT>(Sym);
				Chunks.push_back(C);
				return new (Alloc) DefinedRegular<ELFT>(ELFObj.get(), Sym, C);
				}
				if (Sym->isAbsolute()) {
				Name = *ELFObj->getStaticSymbolName(Sym);
				return new (Alloc) DefinedAbsolute(Name, Sym->getValue());
				}
				if (Chunk *C = SparseChunks[Sym->st_shndx])
				return new (Alloc) DefinedRegular<ELFT>(ELFObj.get(), Sym, C);
				return nullptr;
				}

				std::error_code BitcodeFile::parse() {
				std::string Err;
				M.reset(LTOModule::createFromBuffer(MB.getBufferStart(), MB.getBufferSize(),
				llvm::TargetOptions(), Err));
				if (!Err.empty()) {
				llvm::errs() << Err << '\n';
				return make_error_code(LLDError::BrokenFile);
				}

				for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
				lto_symbol_attributes Attrs = M->getSymbolAttributes(I);
				if ((Attrs & LTO_SYMBOL_SCOPE_MASK) == LTO_SYMBOL_SCOPE_INTERNAL)
				continue;

				StringRef SymName = M->getSymbolName(I);
				int SymbolDef = Attrs & LTO_SYMBOL_DEFINITION_MASK;
				if (SymbolDef == LTO_SYMBOL_DEFINITION_UNDEFINED) {
				SymbolBodies.push_back(new (Alloc) Undefined(SymName));
				} else {
				bool Replaceable = (SymbolDef == LTO_SYMBOL_DEFINITION_TENTATIVE \|\|
				(Attrs & LTO_SYMBOL_COMDAT));
				SymbolBodies.push_back(new (Alloc) DefinedBitcode(SymName, Replaceable));
				}
				}

				return std::error_code();
				}

				namespace lld {
				namespace elfv2 {
				template class elfv2::ObjectFile<llvm::object::ELF32LE>;
				template class elfv2::ObjectFile<llvm::object::ELF32BE>;
				template class elfv2::ObjectFile<llvm::object::ELF64LE>;
				template class elfv2::ObjectFile<llvm::object::ELF64BE>;
				}
				}

ELF/Options.td

This file was added.

				include "llvm/Option/OptParser.td"

				//===----------------------------------------------------------------------===//
				/// Utility Functions
				//===----------------------------------------------------------------------===//
				// Single and multiple dash options combined
				multiclass smDash<string opt1, string opt2, string help> {
				// Option
				def "" : Separate<["-"], opt1>, HelpText<help>;
				def opt1_eq : Joined<["-"], opt1#"=">,
				Alias<!cast<Option>(opt1)>;
				// Compatibility aliases
				def opt2_dashdash : Separate<["--"], opt2>,
				Alias<!cast<Option>(opt1)>;
				def opt2_dashdash_eq : Joined<["--"], opt2#"=">,
				Alias<!cast<Option>(opt1)>;
				}

				// Support -<option>,-<option>=
				multiclass dashEq<string opt1, string opt2, string help> {
				// Option
				def "" : Separate<["-"], opt1>, HelpText<help>;
				// Compatibility aliases
				def opt2_eq : Joined<["-"], opt2#"=">,
				Alias<!cast<Option>(opt1)>;
				}

				// Support --<option>,--<option>=
				multiclass mDashEq<string opt1, string help> {
				// Option
				def "" : Separate<["--"], opt1>, HelpText<help>;
				// Compatibility aliases
				def opt2_eq : Joined<["--"], opt1#"=">,
				Alias<!cast<Option>(opt1)>;
				}

				def output : Separate<["-"], "o">, MetaVarName<"<path>">,
				HelpText<"Path to file to write output">;

				def L : Joined<["-"], "L">, MetaVarName<"<dir>">,
				HelpText<"Directory to search for libraries">;
				def l : Joined<["-"], "l">, MetaVarName<"<libName>">,
				HelpText<"Root name of library to use">;
				def noinhibit_exec : Flag<["--"], "noinhibit-exec">,
				HelpText<"Retain the executable output file whenever"
				" it is still usable">;
				defm e : smDash<"e", "entry",
				"Name of entry point symbol">;

				//===----------------------------------------------------------------------===//
				/// Help
				//===----------------------------------------------------------------------===//
				def help : Flag<["--"], "help">,
				HelpText<"Display this help message">;

ELF/README.md

This file was added.

				The New ELF Linker
				==================
				This directory contains a port of the new PE/COFF linker for ELF.

				Overall Design
				--------------
				See COFF/README.md for details on the design.

				Capabilities
				------------
				This linker can currently generate a valid ELF file that can be run on linux
				from a single input file.

ELF/SymbolTable.h

This file was added.

				//===- SymbolTable.h ------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_SYMBOL_TABLE_H
				#define LLD_ELF_SYMBOL_TABLE_H

				#include "InputFiles.h"
				#include "llvm/Support/Allocator.h"
				#include <unordered_map>

				namespace llvm {
				struct LTOCodeGenerator;
				}

				namespace lld {
				namespace elfv2 {

				// SymbolTable is a bucket of all known symbols, including defined,
				// undefined, or lazy symbols (the last one is symbols in archive
				// files whose archive members are not yet loaded).
				//
				// We put all symbols of all files to a SymbolTable, and the
				// SymbolTable selects the "best" symbols if there are name
				// conflicts. For example, obviously, a defined symbol is better than
				// an undefined symbol. Or, if there's a conflict between a lazy and a
				// undefined, it'll read an archive member to read a real definition
				// to replace the lazy symbol. The logic is implemented in resolve().
				template <class ELFT> class SymbolTable {
				public:
				SymbolTable();

				std::error_code addFile(std::unique_ptr<InputFile> File);

				// Print an error message on undefined symbols.
				bool reportRemainingUndefines();

				// Returns a list of chunks of selected symbols.
				std::vector<Chunk *> getChunks();

				// Returns a symbol for a given name. It's not guaranteed that the
				// returned symbol actually has the same name (because of various
				// mechanisms to allow aliases, a name can be resolved to a
				// different symbol). Returns a nullptr if not found.
				Defined *find(StringRef Name);

				// Dump contents of the symbol table to stderr.
				void dump();

				// Build an ELF object representing the combined contents of BitcodeFiles
				// and add it to the symbol table. Called after all files are added and
				// before the writer writes results to a file.
				std::error_code addCombinedLTOObject();

				// The writer needs to infer the machine type from the object files.
				std::vector<std::unique_ptr<ObjectFile<ELFT>>> ObjectFiles;

				// Creates an Undefined symbol for a given name.
				std::error_code addUndefined(StringRef Name);

				// Rename From -> To in the symbol table.
				std::error_code rename(StringRef From, StringRef To);
				ruiuUnsubmitted Done Reply Inline Actions I'd remove this for now. This maybe Windows-specific, and we can bring it back if we need it. ruiu: I'd remove this for now. This maybe Windows-specific, and we can bring it back if we need it.

				private:
				std::error_code addObject(ObjectFile<ELFT> *File);
				std::error_code addArchive(ArchiveFile *File);
				std::error_code addBitcode(BitcodeFile *File);

				std::error_code resolve(SymbolBody *Body);
				std::error_code addMemberFile(Lazy *Body);
				ErrorOr<ObjectFile<ELFT> > createLTOObject(llvm::LTOCodeGenerator CG);

				std::unordered_map<StringRef, Symbol *> Symtab;
				std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
				std::vector<std::unique_ptr<BitcodeFile>> BitcodeFiles;
				std::unique_ptr<MemoryBuffer> LTOMB;
				llvm::BumpPtrAllocator Alloc;
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/SymbolTable.cpp

This file was added.

				//===- SymbolTable.cpp ----------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Config.h"
				#include "Driver.h"
				#include "Error.h"
				#include "SymbolTable.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/LTO/LTOCodeGenerator.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/raw_ostream.h"

				using namespace llvm;

				using namespace lld;
				using namespace lld::elfv2;

				template <class ELFT> SymbolTable<ELFT>::SymbolTable() {
				if (!Config->EntryName.empty())
				resolve(new (Alloc) Undefined(Config->EntryName));
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
				if (auto EC = File->parse())
				return EC;
				InputFile *FileP = File.release();
				if (auto *P = dyn_cast<ObjectFile<ELFT>>(FileP))
				return addObject(P);
				if (auto *P = dyn_cast<ArchiveFile>(FileP))
				return addArchive(P);
				if (auto *P = dyn_cast<BitcodeFile>(FileP))
				return addBitcode(P);
				llvm_unreachable("Unknown file");
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addObject(ObjectFile<ELFT> *File) {
				ObjectFiles.emplace_back(File);
				for (SymbolBody *Body : File->getSymbols())
				if (Body->isExternal())
				if (auto EC = resolve(Body))
				return EC;
				return std::error_code();
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addArchive(ArchiveFile *File) {
				ArchiveFiles.emplace_back(File);
				for (SymbolBody *Body : File->getSymbols())
				if (auto EC = resolve(Body))
				return EC;
				return std::error_code();
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addBitcode(BitcodeFile *File) {
				BitcodeFiles.emplace_back(File);
				for (SymbolBody *Body : File->getSymbols())
				if (Body->isExternal())
				if (auto EC = resolve(Body))
				return EC;
				return std::error_code();
				}

				template <class ELFT> bool SymbolTable<ELFT>::reportRemainingUndefines() {
				bool Ret = false;
				for (auto &I : Symtab) {
				Symbol *Sym = I.second;
				auto *Undef = dyn_cast<Undefined>(Sym->Body);
				if (!Undef)
				continue;
				if (SymbolBody *Alias = Undef->getWeakAlias()) {
				Sym->Body = Alias->getReplacement();
				if (!isa<Defined>(Sym->Body)) {
				// Aliases are yet another symbols pointed by other symbols
				// that could also remain undefined.
				llvm::errs() << "undefined symbol: " << Undef->getName() << "\n";
				Ret = true;
				}
				continue;
				}
				ruiuUnsubmitted Done Reply Inline Actions Does this also make sense for ELF? If in doubt, I'd remove for now. ruiu: Does this also make sense for ELF? If in doubt, I'd remove for now.
				llvm::errs() << "undefined symbol: " << Undef->getName() << "\n";
				Ret = true;
				}
				return Ret;
				}

				// This function resolves conflicts if there's an existing symbol with
				// the same name. Decisions are made based on symbol type.
				template <class ELFT>
				std::error_code SymbolTable<ELFT>::resolve(SymbolBody *New) {
				// Find an existing Symbol or create and insert a new one.
				StringRef Name = New->getName();
				Symbol *&Sym = Symtab[Name];
				if (!Sym) {
				Sym = new (Alloc) Symbol(New);
				New->setBackref(Sym);
				return std::error_code();
				}
				New->setBackref(Sym);

				// compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
				// equivalent (conflicting), or more preferable, respectively.
				SymbolBody *Existing = Sym->Body;
				int comp = Existing->compare(New);
				if (comp < 0)
				Sym->Body = New;
				if (comp == 0) {
				llvm::errs() << "duplicate symbol: " << Name << "\n";
				return make_error_code(LLDError::DuplicateSymbols);
				}

				// If we have an Undefined symbol for a Lazy symbol, we need
				// to read an archive member to replace the Lazy symbol with
				// a Defined symbol.
				if (isa<Undefined>(Existing) \|\| isa<Undefined>(New))
				if (auto *B = dyn_cast<Lazy>(Sym->Body))
				return addMemberFile(B);
				return std::error_code();
				}

				// Reads an archive member file pointed by a given symbol.
				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addMemberFile(Lazy *Body) {
				auto FileOrErr = Body->getMember();
				if (auto EC = FileOrErr.getError())
				return EC;
				std::unique_ptr<InputFile> File = std::move(FileOrErr.get());

				// getMember returns an empty buffer if the member was already
				// read from the library.
				if (!File)
				return std::error_code();
				if (Config->Verbose)
				llvm::outs() << "Loaded " << File->getShortName() << " for "
				<< Body->getName() << "\n";
				return addFile(std::move(File));
				}

				template <class ELFT> std::vector<Chunk *> SymbolTable<ELFT>::getChunks() {
				std::vector<Chunk *> Res;
				for (std::unique_ptr<ObjectFile<ELFT>> &File : ObjectFiles) {
				std::vector<Chunk *> &V = File->getChunks();
				Res.insert(Res.end(), V.begin(), V.end());
				}
				return Res;
				}

				template <class ELFT> Defined *SymbolTable<ELFT>::find(StringRef Name) {
				auto It = Symtab.find(Name);
				if (It == Symtab.end())
				return nullptr;
				if (auto *Def = dyn_cast<Defined>(It->second->Body))
				return Def;
				return nullptr;
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addUndefined(StringRef Name) {
				return resolve(new (Alloc) Undefined(Name));
				}

				// Resolve To, and make From an alias to To.
				template <class ELFT>
				std::error_code SymbolTable<ELFT>::rename(StringRef From, StringRef To) {
				SymbolBody *Body = new (Alloc) Undefined(To);
				if (auto EC = resolve(Body))
				return EC;
				Symtab[From]->Body = Body->getReplacement();
				return std::error_code();
				}

				template <class ELFT> void SymbolTable<ELFT>::dump() {
				for (auto &P : Symtab) {
				Symbol *Ref = P.second;
				if (auto *Body = dyn_cast<Defined>(Ref->Body))
				llvm::dbgs() << Twine::utohexstr(Body->getVA()) << " " << Body->getName()
				<< "\n";
				}
				}

				template <class ELFT>
				std::error_code SymbolTable<ELFT>::addCombinedLTOObject() {
				if (BitcodeFiles.empty())
				return std::error_code();

				// Create an object file and add it to the symbol table by replacing any
				// DefinedBitcode symbols with the definitions in the object file.
				LTOCodeGenerator CG;
				auto FileOrErr = createLTOObject(&CG);
				if (auto EC = FileOrErr.getError())
				return EC;
				ObjectFile<ELFT> *Obj = FileOrErr.get();

				for (SymbolBody *Body : Obj->getSymbols()) {
				if (!Body->isExternal())
				continue;
				// Find an existing Symbol. We should not see any new undefined symbols at
				// this point.
				StringRef Name = Body->getName();
				Symbol *&Sym = Symtab[Name];
				if (!Sym) {
				if (!isa<Defined>(Body)) {
				llvm::errs() << "LTO: undefined symbol: " << Name << '\n';
				return make_error_code(LLDError::BrokenFile);
				}
				Sym = new (Alloc) Symbol(Body);
				Body->setBackref(Sym);
				continue;
				}
				Body->setBackref(Sym);

				if (isa<DefinedBitcode>(Sym->Body)) {
				// The symbol should now be defined.
				if (!isa<Defined>(Body)) {
				llvm::errs() << "LTO: undefined symbol: " << Name << '\n';
				return make_error_code(LLDError::BrokenFile);
				}
				Sym->Body = Body;
				} else {
				int comp = Sym->Body->compare(Body);
				if (comp < 0)
				Sym->Body = Body;
				if (comp == 0) {
				llvm::errs() << "LTO: unexpected duplicate symbol: " << Name << "\n";
				return make_error_code(LLDError::BrokenFile);
				}
				}

				// We may see new references to runtime library symbols such as __chkstk
				// here. These symbols must be wholly defined in non-bitcode files.
				if (auto *B = dyn_cast<Lazy>(Sym->Body)) {
				size_t NumBitcodeFiles = BitcodeFiles.size();
				if (auto EC = addMemberFile(B))
				return EC;
				if (BitcodeFiles.size() != NumBitcodeFiles) {
				llvm::errs()
				<< "LTO: late loaded symbol created new bitcode reference: " << Name
				<< "\n";
				return make_error_code(LLDError::BrokenFile);
				}
				}
				}

				// New runtime library symbol references may have created undefined
				// references.
				if (reportRemainingUndefines())
				return make_error_code(LLDError::BrokenFile);
				return std::error_code();
				}

				// Combine and compile bitcode files and then return the result
				// as a regular ELF object file.
				template <class ELFT>
				ErrorOr<ObjectFile<ELFT> *>
				SymbolTable<ELFT>::createLTOObject(LTOCodeGenerator *CG) {
				// All symbols referenced by non-bitcode objects must be preserved.
				for (std::unique_ptr<ObjectFile<ELFT>> &File : ObjectFiles)
				for (SymbolBody *Body : File->getSymbols())
				if (auto *S = dyn_cast<DefinedBitcode>(Body->getReplacement()))
				CG->addMustPreserveSymbol(S->getName());

				// Likewise for bitcode symbols which we initially resolved to non-bitcode.
				for (std::unique_ptr<BitcodeFile> &File : BitcodeFiles)
				for (SymbolBody *Body : File->getSymbols())
				if (isa<DefinedBitcode>(Body) &&
				!isa<DefinedBitcode>(Body->getReplacement()))
				CG->addMustPreserveSymbol(Body->getName());

				// Likewise for other symbols that must be preserved.
				for (StringRef Name : Config->GCRoots)
				if (isa<DefinedBitcode>(Symtab[Name]->Body))
				CG->addMustPreserveSymbol(Name);

				CG->setModule(BitcodeFiles[0]->releaseModule());
				for (unsigned I = 1, E = BitcodeFiles.size(); I != E; ++I)
				CG->addModule(BitcodeFiles[I]->getModule());

				std::string ErrMsg;
				LTOMB = CG->compile(false, false, false, ErrMsg); // take MB ownership
				if (!LTOMB) {
				llvm::errs() << ErrMsg << '\n';
				return make_error_code(LLDError::BrokenFile);
				}
				auto Obj = new ObjectFile<ELFT>(LTOMB->getMemBufferRef());
				ObjectFiles.emplace_back(Obj);
				if (auto EC = Obj->parse())
				return EC;
				return Obj;
				}

				namespace lld {
				namespace elfv2 {
				template class SymbolTable<llvm::object::ELF32LE>;
				template class SymbolTable<llvm::object::ELF32BE>;
				template class SymbolTable<llvm::object::ELF64LE>;
				template class SymbolTable<llvm::object::ELF64BE>;
				}
				}

ELF/Symbols.h

This file was added.

				//===- Symbols.h ----------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_SYMBOLS_H
				#define LLD_ELF_SYMBOLS_H

				#include "Chunks.h"
				#include "Config.h"
				#include "lld/Core/LLVM.h"
				#include "llvm/ADT/ArrayRef.h"
				#include "llvm/Object/Archive.h"
				#include "llvm/Object/ELF.h"
				#include <memory>
				#include <vector>

				namespace lld {
				namespace elfv2 {

				using llvm::object::Archive;
				using llvm::object::ELFFile;

				class ArchiveFile;
				class InputFile;
				class SymbolBody;

				// A real symbol object, SymbolBody, is usually accessed indirectly
				// through a Symbol. There's always one Symbol for each symbol name.
				// The resolver updates SymbolBody pointers as it resolves symbols.
				struct Symbol {
				explicit Symbol(SymbolBody *P) : Body(P) {}
				SymbolBody *Body;
				};

				// The base class for real symbol classes.
				class SymbolBody {
				public:
				enum Kind {
				DefinedFirst,
				DefinedBitcodeKind,
				DefinedAbsoluteKind,
				DefinedRegularKind,
				DefinedLast,
				LazyKind,
				UndefinedKind,
				};

				Kind kind() const { return SymbolKind; }
				virtual ~SymbolBody() {}

				// Returns true if this is an external symbol.
				virtual bool isExternal() { return true; }

				// Returns the symbol name.
				virtual StringRef getName() = 0;

				// A SymbolBody has a backreference to a Symbol. Originally they are
				// doubly-linked. A backreference will never change. But the pointer
				// in the Symbol may be mutated by the resolver. If you have a
				// pointer P to a SymbolBody and are not sure whether the resolver
				// has chosen the object among other objects having the same name,
				// you can access P->Backref->Body to get the resolver's result.
				void setBackref(Symbol *P) { Backref = P; }
				SymbolBody *getReplacement() { return Backref ? Backref->Body : this; }

				// Decides which symbol should "win" in the symbol table, this or
				// the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
				// they are duplicate (conflicting) symbols.
				virtual int compare(SymbolBody *Other) = 0;

				protected:
				SymbolBody(Kind K) : SymbolKind(K) {}

				private:
				const Kind SymbolKind;
				Symbol *Backref = nullptr;
				};

				// The base class for any defined symbols, including absolute symbols,
				// etc.
				class Defined : public SymbolBody {
				public:
				Defined(Kind K) : SymbolBody(K) {}

				static bool classof(const SymbolBody *S) {
				Kind K = S->kind();
				return DefinedFirst <= K && K <= DefinedLast;
				}

				// Returns the VA (virtual address) of this symbol. The
				// writer sets and uses VAs.
				virtual uint64_t getVA() = 0;

				// Returns the file offset of this symbol in the final executable.
				// The writer uses this information to apply relocations.
				virtual uint64_t getFileOff() = 0;

				// Called by the garbage collector. All Defined subclasses should
				// know how to call depending symbols' markLive functions.
				virtual void markLive() {}

				int compare(SymbolBody *Other) override;
				};

				// Regular defined symbols read from object file symbol tables.
				template <class ELFT> class DefinedRegular : public Defined {
				typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;

				public:
				DefinedRegular(ELFFile<ELFT> F, const Elf_Sym S, Chunk *C)
				: Defined(DefinedRegularKind), File(F), Sym(S), Data(C) {}

				static bool classof(const SymbolBody *S) {
				return S->kind() == DefinedRegularKind;
				}

				StringRef getName() override;
				uint64_t getVA() override { return Data->getVA() + Sym->getValue(); }
				bool isExternal() override { return Sym->isExternal(); }
				void markLive() override { Data->markLive(); }
				uint64_t getFileOff() override {
				return Data->getFileOff() + Sym->getValue();
				}
				int compare(SymbolBody *Other) override;

				// Returns true if this is a common symbol.
				bool isCommon() const { return Sym->isCommon(); }
				uint32_t getCommonSize() const { return Sym->st_size; }

				private:
				StringRef Name;
				ELFFile<ELFT> *File;
				const Elf_Sym *Sym;
				Chunk *Data;
				};

				// Absolute symbols.
				class DefinedAbsolute : public Defined {
				public:
				DefinedAbsolute(StringRef N, uint64_t VA)
				: Defined(DefinedAbsoluteKind), Name(N), VA(VA) {}

				static bool classof(const SymbolBody *S) {
				return S->kind() == DefinedAbsoluteKind;
				}

				StringRef getName() override { return Name; }
				uint64_t getVA() override { return VA; }
				uint64_t getFileOff() override { llvm_unreachable("internal error"); }

				private:
				StringRef Name;
				uint64_t VA;
				};

				// This class represents a symbol defined in an archive file. It is
				// created from an archive file header, and it knows how to load an
				// object file from an archive to replace itself with a defined
				// symbol. If the resolver finds both Undefined and Lazy for
				// the same name, it will ask the Lazy to load a file.
				class Lazy : public SymbolBody {
				atanasyanUnsubmitted Not Done Reply Inline Actions I guess it is a COFF equivalent for ELF Weak symbol? atanasyan: I guess it is a COFF equivalent for ELF Weak symbol?
				BigcheeseAuthorUnsubmitted Not Done Reply Inline Actions This is for archive files. Bigcheese: This is for archive files.
				public:
				Lazy(ArchiveFile *F, const Archive::Symbol S)
				: SymbolBody(LazyKind), Name(S.getName()), File(F), Sym(S) {}

				static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
				StringRef getName() override { return Name; }

				// Returns an object file for this symbol, or a nullptr if the file
				// was already returned.
				ErrorOr<std::unique_ptr<InputFile>> getMember();

				int compare(SymbolBody *Other) override;

				private:
				StringRef Name;
				ArchiveFile *File;
				const Archive::Symbol Sym;
				};

				// Undefined symbols.
				class Undefined : public SymbolBody {
				public:
				explicit Undefined(StringRef N, SymbolBody **S = nullptr)
				: SymbolBody(UndefinedKind), Name(N), Alias(S) {}

				static bool classof(const SymbolBody *S) {
				return S->kind() == UndefinedKind;
				}
				StringRef getName() override { return Name; }

				// An undefined symbol can have a fallback symbol which gives an
				// undefined symbol a second chance if it would remain undefined.
				// If it remains undefined, it'll be replaced with whatever the
				// Alias pointer points to.
				SymbolBody getWeakAlias() { return Alias ? Alias : nullptr; }
				ruiuUnsubmitted Done Reply Inline Actions Remove this if you don't use this. ruiu: Remove this if you don't use this.

				ruiuUnsubmitted Not Done Reply Inline Actions You can now remove this member. ruiu: You can now remove this member.
				int compare(SymbolBody *Other) override;

				private:
				StringRef Name;
				SymbolBody **Alias;
				};

				class DefinedBitcode : public Defined {
				public:
				DefinedBitcode(StringRef N, bool R)
				: Defined(DefinedBitcodeKind), Name(N), Replaceable(R) {}

				static bool classof(const SymbolBody *S) {
				return S->kind() == DefinedBitcodeKind;
				}

				StringRef getName() override { return Name; }
				uint64_t getVA() override { llvm_unreachable("bitcode reached writer"); }
				uint64_t getFileOff() override { llvm_unreachable("bitcode reached writer"); }
				int compare(SymbolBody *Other) override;

				private:
				StringRef Name;
				bool Replaceable;
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/Symbols.cpp

This file was added.

				//===- Symbols.cpp --------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Error.h"
				#include "InputFiles.h"
				#include "Symbols.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/raw_ostream.h"

				using namespace llvm::object;
				using llvm::sys::fs::identify_magic;
				using llvm::sys::fs::file_magic;

				using namespace lld;
				using namespace lld::elfv2;

				// Returns 1, 0 or -1 if this symbol should take precedence
				// over the Other, tie or lose, respectively.
				template <class ELFT> int DefinedRegular<ELFT>::compare(SymbolBody *Other) {
				if (Other->kind() < kind())
				return -Other->compare(this);
				auto *R = dyn_cast<DefinedRegular>(Other);
				if (!R)
				return 1;

				// Common symbols are weaker than other types of defined symbols.
				if (isCommon() && R->isCommon())
				return (getCommonSize() < R->getCommonSize()) ? -1 : 1;
				// TODO: we are not sure if regular defined symbol and common
				// symbols are allowed to have the same name.
				if (isCommon())
				return -1;
				if (R->isCommon())
				return 1;
				return 0;
				}

				int DefinedBitcode::compare(SymbolBody *Other) {
				assert(Other->kind() >= kind());
				if (!isa<Defined>(Other))
				return 1;

				if (auto *B = dyn_cast<DefinedBitcode>(Other)) {
				if (!Replaceable && !B->Replaceable)
				return 0;
				// Non-replaceable symbols win.
				return Replaceable ? -1 : 1;
				}

				// As an approximation, regular symbols win over bitcode symbols,
				// but we definitely have a conflict if the regular symbol is not
				// replaceable and neither is the bitcode symbol. We do not
				// replicate the rest of the symbol resolution logic here; symbol
				// resolution will be done accurately after lowering bitcode symbols
				// to regular symbols in addCombinedLTOObject().
				if (auto *R = dyn_cast<DefinedRegular<llvm::object::ELF64LE>>(Other)) {
				if (!R->isCommon() && !Replaceable)
				return 0;
				return -1;
				}
				return 0;
				}

				int Defined::compare(SymbolBody *Other) {
				if (Other->kind() < kind())
				return -Other->compare(this);
				if (isa<Defined>(Other))
				return 0;
				return 1;
				}

				int Lazy::compare(SymbolBody *Other) {
				if (Other->kind() < kind())
				return -Other->compare(this);

				// Undefined symbols with weak aliases will turn into defined
				// symbols if they remain undefined, so we don't need to resolve
				// such symbols.
				if (auto *U = dyn_cast<Undefined>(Other))
				if (U->getWeakAlias())
				return -1;
				return 1;
				}

				int Undefined::compare(SymbolBody *Other) {
				if (Other->kind() < kind())
				return -Other->compare(this);
				if (cast<Undefined>(Other)->getWeakAlias())
				return -1;
				return 1;
				}

				template <class ELFT> StringRef DefinedRegular<ELFT>::getName() {
				// DefinedSymbol's name is read lazily for a performance reason.
				// Non-external symbol names are never used by the linker
				// except for logging or debugging.
				// Their internal references are resolved not by name but by symbol index.
				// And because they are not external, no one can refer them by name.
				// Object files contain lots of non-external symbols, and creating
				// StringRefs for them (which involves lots of strlen() on the string table)
				// is a waste of time.
				if (Name.empty())
				Name = *File->getStaticSymbolName(Sym);
				return Name;
				}

				ErrorOr<std::unique_ptr<InputFile>> Lazy::getMember() {
				auto MBRefOrErr = File->getMember(&Sym);
				if (auto EC = MBRefOrErr.getError())
				return EC;
				MemoryBufferRef MBRef = MBRefOrErr.get();

				// getMember returns an empty buffer if the member was already
				// read from the library.
				if (MBRef.getBuffer().empty())
				return std::unique_ptr<InputFile>(nullptr);

				file_magic Magic = identify_magic(MBRef.getBuffer());
				if (Magic == file_magic::bitcode)
				return std::unique_ptr<InputFile>(new BitcodeFile(MBRef));
				if (Magic != file_magic::elf_relocatable) {
				llvm::errs() << File->getName() << ": unknown file type\n";
				return make_error_code(LLDError::InvalidFile);
				}

				std::unique_ptr<InputFile> Obj(new ObjectFile<llvm::object::ELF64LE>(MBRef));
				Obj->setParentName(File->getName());
				return std::move(Obj);
				}

				namespace lld {
				namespace elfv2 {
				template class DefinedRegular<llvm::object::ELF32LE>;
				template class DefinedRegular<llvm::object::ELF32BE>;
				template class DefinedRegular<llvm::object::ELF64LE>;
				template class DefinedRegular<llvm::object::ELF64BE>;
				}
				}

ELF/Writer.h

This file was added.

				//===- Writer.h -----------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLD_ELF_WRITER_H
				#define LLD_ELF_WRITER_H

				#include "InputFiles.h"
				#include "SymbolTable.h"
				#include "llvm/Support/ELF.h"
				#include "llvm/Support/FileOutputBuffer.h"
				#include <memory>
				#include <vector>

				namespace lld {
				namespace elfv2 {

				// OutputSection represents a section in an output file. It's a
				// container of chunks. OutputSection and Chunk are 1:N relationship.
				// Chunks cannot belong to more than one OutputSections. The writer
				// creates multiple OutputSections and assign them unique,
				// non-overlapping file offsets and VAs.
				class OutputSection {
				public:
				OutputSection(StringRef N, uint32_t SI)
				: Name(N), SectionIndex(SI), Header({}) {}
				void setVA(uint64_t);
				void setFileOffset(uint64_t);
				void addChunk(Chunk *C);
				StringRef getName() { return Name; }
				uint64_t getSectionIndex() { return SectionIndex; }
				std::vector<Chunk *> &getChunks() { return Chunks; }
				void addPermissions(uint32_t C);
				uint32_t getPermissions() { return 0; }
				uint64_t getVA() { return Header.sh_addr; }
				uint64_t getFileOff() { return Header.sh_offset; }
				void writeHeaderTo(uint8_t *Buf);

				// Returns the size of the section in the output file.
				uint64_t getSize() { return Header.sh_size; }

				// Set offset into the string table storing this section name.
				// Used only when the name is longer than 8 bytes.
				void setStringTableOff(uint32_t V) { StringTableOff = V; }

				private:
				StringRef Name;
				uint32_t SectionIndex;
				llvm::ELF::Elf64_Shdr Header;
				uint32_t StringTableOff = 0;
				std::vector<Chunk *> Chunks;
				};

				// The writer writes a SymbolTable result to a file.
				template <class ELFT> class Writer {
				public:
				explicit Writer(SymbolTable<ELFT> *T) : Symtab(T) {}
				std::error_code write(StringRef Path);

				private:
				void markLive();
				void createSections();
				void assignAddresses();
				void removeEmptySections();
				std::error_code openFile(StringRef OutputPath);
				void writeHeader();
				void writeSections();

				OutputSection *findSection(StringRef Name);

				SymbolTable<ELFT> *Symtab;
				std::unique_ptr<llvm::FileOutputBuffer> Buffer;
				llvm::SpecificBumpPtrAllocator<OutputSection> CAlloc;
				std::vector<OutputSection *> OutputSections;

				uint64_t FileSize;
				uint64_t SizeOfImage;
				uint64_t SizeOfHeaders;

				std::vector<std::unique_ptr<Chunk>> Chunks;
				};

				} // namespace elfv2
				} // namespace lld

				#endif

ELF/Writer.cpp

This file was added.

				//===- Writer.cpp ---------------------------------------------------------===//
				//
				// The LLVM Linker
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//

				#include "Config.h"
				#include "Writer.h"
				#include "llvm/ADT/ArrayRef.h"
				#include "llvm/ADT/Hashing.h"
				#include "llvm/ADT/StringSwitch.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/Endian.h"
				#include "llvm/Support/FileOutputBuffer.h"
				#include "llvm/Support/raw_ostream.h"
				#include <algorithm>
				#include <cstdio>
				#include <functional>
				#include <unordered_map>
				#include <utility>

				#include "llvm/Support/raw_ostream.h"
				ruiuUnsubmitted Done Reply Inline Actions Remove ruiu: Remove

				using namespace llvm;
				using namespace llvm::ELF;
				using namespace llvm::object;
				using namespace llvm::support;
				using namespace llvm::support::endian;

				static const int PageSize = 4096;

				struct SectionTraits {
				uint64_t Type;
				uint64_t Flags;
				StringRef Name;
				};

				bool operator==(const SectionTraits &A, const SectionTraits &B) {
				return A.Type == B.Type && A.Flags == B.Flags && A.Name == B.Name;
				}

				namespace std {
				template <> struct hash<SectionTraits> {
				size_t operator()(const SectionTraits &ST) const {
				return hash_combine(ST.Type, ST.Flags, ST.Name);
				}
				};
				}

				using namespace lld;
				using namespace lld::elfv2;
				ruiuUnsubmitted Done Reply Inline Actions Move this above "static const int PageSize...". ruiu: Move this above "static const int PageSize...".

				// The main function of the writer.
				template <class ELFT>
				std::error_code Writer<ELFT>::write(StringRef OutputPath) {
				markLive();
				createSections();
				assignAddresses();
				removeEmptySections();
				if (auto EC = openFile(OutputPath))
				return EC;
				writeHeader();
				writeSections();
				return Buffer->commit();
				}

				void OutputSection::setVA(uint64_t VA) {
				Header.sh_addr = VA;
				for (Chunk *C : Chunks)
				C->setVA(C->getVA() + VA);
				}

				void OutputSection::setFileOffset(uint64_t Off) {
				if (Header.sh_size == 0)
				return;
				Header.sh_offset = Off;
				for (Chunk *C : Chunks)
				C->setFileOff(C->getFileOff() + Off);
				}

				void OutputSection::addChunk(Chunk *C) {
				Chunks.push_back(C);
				C->setOutputSection(this);
				uint64_t Off = Header.sh_size;
				Off = RoundUpToAlignment(Off, C->getAlign());
				C->setVA(Off);
				C->setFileOff(Off);
				Off += C->getSize();
				Header.sh_size = Off;
				}

				void OutputSection::addPermissions(uint32_t C) {
				// Header.Characteristics \|= C & PermMask;
				}

				// Write the section header to a given buffer.
				void OutputSection::writeHeaderTo(uint8_t *Buf) {}

				// Set live bit on for each reachable chunk. Unmarked (unreachable)
				// COMDAT chunks will be ignored in the next step, so that they don't
				// come to the final output file.
				template <class ELFT> void Writer<ELFT>::markLive() {
				if (!Config->DoGC)
				return;
				for (StringRef Name : Config->GCRoots)
				cast<Defined>(Symtab->find(Name))->markLive();
				for (Chunk *C : Symtab->getChunks())
				if (C->isRoot())
				C->markLive();
				}

				static SectionTraits getChunkTraits(Chunk *C) {
				return {0, C->getFlags(), C->getSectionName()};
				}

				// Create output section objects and add them to OutputSections.
				template <class ELFT> void Writer<ELFT>::createSections() {
				std::unordered_map<SectionTraits, std::vector<Chunk *>> Map;
				for (Chunk *C : Symtab->getChunks()) {
				if (Config->DoGC && !C->isLive()) {
				if (Config->Verbose)
				C->printDiscardedMessage();
				continue;
				}
				Map[getChunkTraits(C)].push_back(C);
				}

				for (auto &P : Map) {
				auto Sec = new (CAlloc.Allocate())
				OutputSection(P.first.Name, OutputSections.size());
				OutputSections.push_back(Sec);
				for (Chunk *C : P.second) {
				Sec->addChunk(C);
				Sec->addPermissions(C->getFlags());
				}
				}
				}

				template <class ELFT> void Writer<ELFT>::removeEmptySections() {
				auto IsEmpty = [](OutputSection *S) { return S->getSize() == 0; };
				OutputSections.erase(
				std::remove_if(OutputSections.begin(), OutputSections.end(), IsEmpty),
				OutputSections.end());
				}
				ruiuUnsubmitted Done Reply Inline Actions I think you don't actually need this function for ELF. ruiu: I think you don't actually need this function for ELF.

				// Visits all sections to assign incremental, non-overlapping RVAs and
				// file offsets.
				template <class ELFT> void Writer<ELFT>::assignAddresses() {
				SizeOfHeaders = RoundUpToAlignment(sizeof(Elf_Ehdr_Impl<ELFT>) +
				sizeof(Elf_Shdr_Impl<ELFT>) *
				OutputSections.size(),
				PageSize);
				uint64_t VA = 0x1000; // The first page is kept unmapped.
				uint64_t FileOff = SizeOfHeaders;
				for (OutputSection *Sec : OutputSections) {
				Sec->setVA(VA);
				Sec->setFileOffset(FileOff);
				VA += RoundUpToAlignment(Sec->getSize(), PageSize);
				FileOff += RoundUpToAlignment(Sec->getSize(), 8);
				}
				SizeOfImage = SizeOfHeaders + RoundUpToAlignment(VA - 0x1000, PageSize);
				FileSize = SizeOfHeaders + RoundUpToAlignment(FileOff - SizeOfHeaders, 8);
				}

				template <class ELFT> void Writer<ELFT>::writeHeader() {
				uint8_t *Buf = Buffer->getBufferStart();
				auto EHdr = reinterpret_cast<Elf_Ehdr_Impl<ELFT> >(Buf);
				EHdr->e_ident[EI_MAG0] = 0x7F;
				EHdr->e_ident[EI_MAG1] = 0x45;
				EHdr->e_ident[EI_MAG2] = 0x4C;
				EHdr->e_ident[EI_MAG3] = 0x46;
				EHdr->e_ident[EI_CLASS] = ELFCLASS64;
				EHdr->e_ident[EI_DATA] = ELFDATA2LSB;
				EHdr->e_ident[EI_VERSION] = EV_CURRENT;
				EHdr->e_ident[EI_OSABI] = ELFOSABI_GNU;

				EHdr->e_type = ET_EXEC;
				EHdr->e_machine = EM_X86_64;
				EHdr->e_version = EV_CURRENT;
				EHdr->e_entry = 0x401000;
				EHdr->e_phoff = sizeof(Elf_Ehdr_Impl<ELFT>);
				EHdr->e_shoff = 0;
				EHdr->e_ehsize = sizeof(Elf_Ehdr_Impl<ELFT>);
				EHdr->e_phentsize = sizeof(Elf_Phdr_Impl<ELFT>);
				EHdr->e_phnum = 1;
				EHdr->e_shentsize = sizeof(Elf_Shdr_Impl<ELFT>);
				EHdr->e_shnum = 0;
				EHdr->e_shstrndx = 0;

				auto PHdrs = reinterpret_cast<Elf_Phdr_Impl<ELFT> *>(Buf + EHdr->e_phoff);
				PHdrs->p_type = PT_LOAD;
				PHdrs->p_flags = PF_R \| PF_X;
				PHdrs->p_offset = 0x0000;
				PHdrs->p_vaddr = 0x400000;
				PHdrs->p_paddr = PHdrs->p_vaddr;
				PHdrs->p_filesz = FileSize;
				PHdrs->p_memsz = FileSize;
				PHdrs->p_align = 0x4000;
				}

				template <class ELFT> std::error_code Writer<ELFT>::openFile(StringRef Path) {
				if (auto EC = FileOutputBuffer::create(Path, FileSize, Buffer,
				FileOutputBuffer::F_executable)) {
				llvm::errs() << "failed to open " << Path << ": " << EC.message() << "\n";
				return EC;
				}
				return std::error_code();
				}

				// Write section contents to a mmap'ed file.
				template <class ELFT> void Writer<ELFT>::writeSections() {
				uint8_t *Buf = Buffer->getBufferStart();
				for (OutputSection *Sec : OutputSections) {
				// Fill gaps between functions in .text with nop instructions instead of
				// leaving as null bytes (which can be interpreted as ADD instructions).
				if (Sec->getPermissions() & PF_X)
				memset(Buf + Sec->getFileOff(), 0x90, Sec->getSize());
				for (Chunk *C : Sec->getChunks())
				C->writeTo(Buf);
				}
				}

				template <class ELFT> OutputSection *Writer<ELFT>::findSection(StringRef Name) {
				for (OutputSection *Sec : OutputSections)
				if (Sec->getName() == Name)
				return Sec;
				return nullptr;
				}

				namespace lld {
				namespace elfv2 {
				template class Writer<ELF32LE>;
				template class Writer<ELF32BE>;
				template class Writer<ELF64LE>;
				template class Writer<ELF64BE>;
				}
				}

include/lld/Driver/Driver.h

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines	private:
WinLinkDriver() = delete;		WinLinkDriver() = delete;
};		};

/// Driver for Windows 'link.exe' command line options		/// Driver for Windows 'link.exe' command line options
namespace coff {		namespace coff {
bool link(llvm::ArrayRef<const char *> args);		bool link(llvm::ArrayRef<const char *> args);
}		}

		namespace elfv2 {
		bool link(llvm::ArrayRef<const char *> args);
		}

/// Driver for lld unit tests		/// Driver for lld unit tests
class CoreDriver : public Driver {		class CoreDriver : public Driver {
public:		public:
/// Parses command line arguments same as lld-core and performs link.		/// Parses command line arguments same as lld-core and performs link.
/// Returns true iff there was an error.		/// Returns true iff there was an error.
static bool link(llvm::ArrayRef<const char *> args,		static bool link(llvm::ArrayRef<const char *> args,
raw_ostream &diag = llvm::errs());		raw_ostream &diag = llvm::errs());

Show All 12 Lines

lib/Driver/UniversalDriver.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
public:		public:
UniversalDriverOptTable()		UniversalDriverOptTable()
: OptTable(infoTable, llvm::array_lengthof(infoTable)) {}		: OptTable(infoTable, llvm::array_lengthof(infoTable)) {}
};		};

enum class Flavor {		enum class Flavor {
invalid,		invalid,
gnu_ld, // -flavor gnu		gnu_ld, // -flavor gnu
		gnu_ld2, // -flavor gnu2
win_link, // -flavor link		win_link, // -flavor link
win_link2, // -flavor link2		win_link2, // -flavor link2
darwin_ld, // -flavor darwin		darwin_ld, // -flavor darwin
core // -flavor core OR -core		core // -flavor core OR -core
};		};

struct ProgramNameParts {		struct ProgramNameParts {
StringRef _target;		StringRef _target;
StringRef _flavor;		StringRef _flavor;
};		};

} // anonymous namespace		} // anonymous namespace

static Flavor strToFlavor(StringRef str) {		static Flavor strToFlavor(StringRef str) {
return llvm::StringSwitch<Flavor>(str)		return llvm::StringSwitch<Flavor>(str)
.Case("gnu", Flavor::gnu_ld)		.Case("gnu", Flavor::gnu_ld)
		.Case("gnu2", Flavor::gnu_ld2)
.Case("link", Flavor::win_link)		.Case("link", Flavor::win_link)
.Case("lld-link", Flavor::win_link)		.Case("lld-link", Flavor::win_link)
.Case("link2", Flavor::win_link2)		.Case("link2", Flavor::win_link2)
.Case("lld-link2", Flavor::win_link2)		.Case("lld-link2", Flavor::win_link2)
.Case("darwin", Flavor::darwin_ld)		.Case("darwin", Flavor::darwin_ld)
.Case("core", Flavor::core)		.Case("core", Flavor::core)
.Case("ld", Flavor::gnu_ld)		.Case("ld", Flavor::gnu_ld)
.Default(Flavor::invalid);		.Default(Flavor::invalid);
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines	bool UniversalDriver::link(llvm::MutableArrayRef<const char *> args,
}		}

Flavor flavor = getFlavor(args, parsedArgs);		Flavor flavor = getFlavor(args, parsedArgs);

// Switch to appropriate driver.		// Switch to appropriate driver.
switch (flavor) {		switch (flavor) {
case Flavor::gnu_ld:		case Flavor::gnu_ld:
return GnuLdDriver::linkELF(args, diagnostics);		return GnuLdDriver::linkELF(args, diagnostics);
		case Flavor::gnu_ld2:
		return elfv2::link(args);
case Flavor::darwin_ld:		case Flavor::darwin_ld:
return DarwinLdDriver::linkMachO(args, diagnostics);		return DarwinLdDriver::linkMachO(args, diagnostics);
case Flavor::win_link:		case Flavor::win_link:
return WinLinkDriver::linkPECOFF(args, diagnostics);		return WinLinkDriver::linkPECOFF(args, diagnostics);
case Flavor::win_link2:		case Flavor::win_link2:
return coff::link(args);		return coff::link(args);
case Flavor::core:		case Flavor::core:
return CoreDriver::link(args, diagnostics);		return CoreDriver::link(args, diagnostics);
Show All 9 Lines

test/elfv2/basic.test

This file was added.

				# RUN: yaml2obj -format elf %s -o %t
				# RUN: lld -flavor gnu2 %t -e _start -o %t2
				rafaelUnsubmitted Done Reply Inline Actions Rename the directory to elf2 You can test this with llvm-mc. Please don't use yaml2obj when it is not needed. rafael: Rename the directory to elf2 You can test this with llvm-mc. Please don't use yaml2obj when it…
				# RUN: llvm-readobj -file-headers -program-headers %t2 \| FileCheck %s

				FileHeader:
				Class: ELFCLASS64
				Data: ELFDATA2LSB
				OSABI: ELFOSABI_GNU
				Type: ET_REL
				Machine: EM_X86_64
				Sections:
				- Name: .text
				Type: SHT_PROGBITS
				Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
				AddressAlign: 0x0000000000000004
				Content: 5548C7C03C00000048C7C7010000000F05
				Symbols:
				Global:
				- Name: _start
				Type: STT_FUNC
				Section: .text

				# CHECK: ElfHeader {
				# CHECK: Ident {
				# CHECK: Magic: (7F 45 4C 46)
				# CHECK: Class: 64-bit (0x2)
				# CHECK: DataEncoding: LittleEndian (0x1)
				# CHECK: FileVersion: 1
				# CHECK: OS/ABI: GNU/Linux (0x3)
				# CHECK: ABIVersion: 0
				# CHECK: Unused: (00 00 00 00 00 00 00)
				# CHECK: }
				# CHECK: Type: Executable (0x2)
				# CHECK: Machine: EM_X86_64 (0x3E)
				# CHECK: Version: 1
				# Entry: 0x401000
				# CHECK: ProgramHeaderOffset: 0x40
				# SectionHeaderOffset: 0x0
				# CHECK: Flags [ (0x0)
				# CHECK: ]
				# CHECK: HeaderSize: 64
				# CHECK: ProgramHeaderEntrySize: 56
				# ProgramHeaderCount: 1
				# CHECK: SectionHeaderEntrySize: 64
				# SectionHeaderCount: 0
				# StringTableSectionIndex: 0
				# CHECK: }
				# CHECK: ProgramHeaders [
				# CHECK: ProgramHeader {
				# CHECK: Type: PT_LOAD (0x1)
				# Offset: 0x0
				# VirtualAddress: 0x400000
				# PhysicalAddress: 0x400000
				# FileSize: 4128
				# MemSize: 4128
				# CHECK: Flags [ (0x5)
				# CHECK: PF_R (0x4)
				# CHECK: PF_X (0x1)
				# CHECK: ]
				# Alignment: 16384
				# CHECK: }
				# CHECK: ]

tools/lld/CMakeLists.txt

	add_llvm_executable(lld			add_llvm_executable(lld
	lld.cpp			lld.cpp
	)			)

	target_link_libraries(lld			target_link_libraries(lld
	lldDriver			lldDriver
	lldCOFF			lldCOFF
				lldELF2
	LLVMSupport			LLVMSupport
	)			)

	install(TARGETS lld			install(TARGETS lld
	RUNTIME DESTINATION bin)			RUNTIME DESTINATION bin)

	# Create the lld-link[.exe] symlink in the build directory. If symlink is not			# Create the lld-link[.exe] symlink in the build directory. If symlink is not
	# supported by the operating system, create a copy instead.			# supported by the operating system, create a copy instead.
	Show All 16 Lines

unittests/DriverTests/CMakeLists.txt

	add_lld_unittest(DriverTests			add_lld_unittest(DriverTests
	UniversalDriverTest.cpp			UniversalDriverTest.cpp
	GnuLdDriverTest.cpp			GnuLdDriverTest.cpp
	DarwinLdDriverTest.cpp			DarwinLdDriverTest.cpp
	WinLinkDriverTest.cpp			WinLinkDriverTest.cpp
	WinLinkModuleDefTest.cpp			WinLinkModuleDefTest.cpp
	)			)

	target_link_libraries(DriverTests			target_link_libraries(DriverTests
	lldDriver			lldDriver
	lldCOFF			lldCOFF
	lldCore			lldCore
				lldELF2
	lldPECOFF			lldPECOFF
	lldMachO			lldMachO
	)			)

This is an archive of the discontinued LLVM Phabricator instance.

[LLD] New ELF implementation
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 29688

CMakeLists.txt

ELF/CMakeLists.txt

ELF/Chunks.h

ELF/Chunks.cpp

ELF/Config.h

ELF/Driver.h

ELF/Driver.cpp

ELF/DriverUtils.cpp

ELF/Error.h

ELF/InputFiles.h

ELF/InputFiles.cpp

ELF/Options.td

ELF/README.md

ELF/SymbolTable.h

ELF/SymbolTable.cpp

ELF/Symbols.h

ELF/Symbols.cpp

ELF/Writer.h

ELF/Writer.cpp

include/lld/Driver/Driver.h

lib/Driver/UniversalDriver.cpp

test/elfv2/basic.test

tools/lld/CMakeLists.txt

unittests/DriverTests/CMakeLists.txt

This is an archive of the discontinued LLVM Phabricator instance.

[LLD] New ELF implementationClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 29688

CMakeLists.txt

ELF/CMakeLists.txt

ELF/Chunks.h

ELF/Chunks.cpp

ELF/Config.h

ELF/Driver.h

ELF/Driver.cpp

ELF/DriverUtils.cpp

ELF/Error.h

ELF/InputFiles.h

ELF/InputFiles.cpp

ELF/Options.td

ELF/README.md

ELF/SymbolTable.h

ELF/SymbolTable.cpp

ELF/Symbols.h

ELF/Symbols.cpp

ELF/Writer.h

ELF/Writer.cpp

include/lld/Driver/Driver.h

lib/Driver/UniversalDriver.cpp

test/elfv2/basic.test

tools/lld/CMakeLists.txt

unittests/DriverTests/CMakeLists.txt

[LLD] New ELF implementation
ClosedPublic