Diff 30404

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
				MC
				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…
				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
				Object
				Option
				Support
				Target
				)

				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 elf2 {

				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; }
				void setVA(uint64_t V) { VA = V; }
				atanasyanUnsubmitted Not Done Reply Inline Actions Make these methods `const` atanasyan: Make these methods `const`
				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");
				}

				// Used by the garbage collector.
				bool isRoot() { return Root; }
				bool isLive() { return Live; }
				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; }
				atanasyanUnsubmitted Not Done Reply Inline Actions Make these methods `const` atanasyan: Make these methods `const`

				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;

				// 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() {}
				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…
				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; }

				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 elf2
				} // 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::elf2;

				template <class ELFT>
				SectionChunk<ELFT>::SectionChunk(elf2::ObjectFile<ELFT> F, const Elf_Shdr H,
				uint32_t SI)
				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.
				: 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;
				}

				template <class ELFT>
				const llvm::object::Elf_Shdr_Impl<ELFT> *SectionChunk<ELFT>::getSectionHdr() {
				return Header;
				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.
				}

				template <class ELFT>
				CommonChunk<ELFT>::CommonChunk(const Elf_Sym *S)
				: Sym(S) {
				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.
				// 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 elf2 {
				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 elf2 {

				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 elf2
				} // 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 elf2 {

				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);

				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 elf2
				} // 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::elf2;

				namespace lld {
				namespace elf2 {
				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);
				}
				}
				}

				// 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;
				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?
				std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
				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…
				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));
				return std::unique_ptr<InputFile>(new ObjectFile<llvm::object::ELF64LE>(MB));
				}

				bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
				// 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)) {
				atanasyanUnsubmitted Not Done Reply Inline Actions s/obj/o/ atanasyan: s/obj/o/
				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());
				atanasyanUnsubmitted Not Done Reply Inline Actions s/obj/o/ atanasyan: s/obj/o/

				// Handle -o
				if (auto *Arg = Args.getLastArg(OPT_output))
				Config->OutputFile = Arg->getValue();
				if (Config->OutputFile.empty()) {
				llvm::errs() << "-o must be specified.\n";
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				return false;
				}

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

				// Create a list of input files.
				std::vector<StringRef> InputPaths;
				std::vector<MemoryBufferRef> Inputs;
				for (auto *Arg : Args.filtered(OPT_INPUT))
				InputPaths.push_back(Arg->getValue());

				for (StringRef Path : InputPaths) {
				ErrorOr<MemoryBufferRef> MBOrErr = openFile(Path);
				if (auto EC = MBOrErr.getError()) {
				llvm::errs() << "cannot open " << Path << ": " << EC.message() << "\n";
				atanasyanUnsubmitted Not Done Reply Inline Actions This code is not applicable for ELF atanasyan: This code is not applicable for ELF
				return false;
				}
				Inputs.push_back(MBOrErr.get());
				}
				atanasyanUnsubmitted Not Done Reply Inline Actions /nodefaultlib is not applicable for ELF. atanasyan: /nodefaultlib is not applicable for ELF.

				// Create a symbol table.
				SymbolTable<llvm::object::ELF64LE> Symtab;
				ruiuUnsubmitted Done Reply Inline Actions Same for findFile, doFindLib and findLib. ruiu: Same for findFile, doFindLib and findLib.

				// 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))) {
				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?
				llvm::errs() << MB.getBufferIdentifier() << ": " << EC.message() << "\n";
				return false;
				}
				}

				// Make sure we have resolved all symbols.
				if (Symtab.reportRemainingUndefines())
				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.
				return false;

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

				// 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::elf2;

				// 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::elf2::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 elf2 {

				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 elf2
				} // 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 elf2 {

				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(StringRef StringTable, 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 elf2
				} // 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/Path.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 llvm::sys::path::filename;

				using namespace lld;
				using namespace lld::elf2;

				// Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
				atanasyanUnsubmitted Done Reply Inline Actions Is this code equal to `llvm::sys::path::filename`? atanasyan: Is this code equal to `llvm::sys::path::filename`?
				std::string InputFile::getShortName() {
				if (ParentName == "")
				return getName().lower();
				std::string Res =
				(filename(ParentName) + "(" + filename(getName()) + ")").str();
				return StringRef(Res).lower();
				}

				std::error_code ArchiveFile::parse() {
				// Parse a MemoryBufferRef as an archive file.
				auto ArchiveOrErr = Archive::create(MB);
				if (auto EC = ArchiveOrErr.getError())
				return EC;
				rafaelUnsubmitted Done Reply Inline Actions Handle the error in here instead of returning it. rafael: Handle the error in here instead of returning it.
				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();
				}

				static void error(std::error_code EC) {
				if (!EC)
				return;
				llvm::report_fatal_error(EC.message());
				}

				// 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.
				ErrorOr<StringRef> BuffOrErr = It->getBuffer();
				error(BuffOrErr.getError());
				const char *StartAddr = BuffOrErr->data();
				auto Pair = Seen.insert(StartAddr);
				if (!Pair.second)
				return MemoryBufferRef();
				return It->getMemoryBufferRef();
				}

				template <class ELFT> std::error_code elf2::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 *elf2::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 elf2::ObjectFile<ELFT>::initializeChunks() {
				ruiuUnsubmitted Done Reply Inline Actions Replace "auto" with its real type. ruiu: Replace "auto" with its real type.
				uint64_t Size = ELFObj->getNumSections();
				Chunks.reserve(Size);
				SparseChunks.resize(Size);
				int I = 0;
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				for (const typename ELFFile<ELFT>::Elf_Shdr &Sec : ELFObj->sections()) {
				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;
				}
				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…
				return std::error_code();
				}

				template <class ELFT>
				std::error_code elf2::ObjectFile<ELFT>::initializeSymbols() {
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
				typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
				typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;

				const Elf_Shdr *Symtab = ELFObj->getDotSymtabSec();
				ErrorOr<StringRef> StringTableOrErr =
				ruiuUnsubmitted Done Reply Inline Actions Ditto ruiu: Ditto
				ELFObj->getStringTableForSymtab(*Symtab);
				error(StringTableOrErr.getError());
				StringRef StringTable = *StringTableOrErr;

				Elf_Sym_Range Syms = ELFObj->symbols();
				Syms = 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 (const Elf_Sym &Sym : Syms) {
				SymbolBody *Body = createSymbolBody(StringTable, &Sym);
				if (Body) {
				SymbolBodies.push_back(Body);
				SparseSymbolBodies[I] = Body;
				}
				++I;
				}

				return std::error_code();
				}

				template <class ELFT>
				SymbolBody *elf2::ObjectFile<ELFT>::createSymbolBody(StringRef StringTable,
				const Elf_Sym *Sym) {
				ErrorOr<StringRef> NameOrErr = Sym->getName(StringTable);
				error(NameOrErr.getError());
				StringRef Name = *NameOrErr;
				if (Sym->isUndefined())
				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(), Name, Sym, C);
				}
				if (Sym->isAbsolute())
				return new (Alloc) DefinedAbsolute(Name, Sym->getValue());
				if (Chunk *C = SparseChunks[Sym->st_shndx])
				return new (Alloc) DefinedRegular<ELFT>(ELFObj.get(), Name, 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 elf2 {
				template class elf2::ObjectFile<llvm::object::ELF32LE>;
				template class elf2::ObjectFile<llvm::object::ELF32BE>;
				template class elf2::ObjectFile<llvm::object::ELF64LE>;
				template class elf2::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 elf2 {

				// 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();

				// 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);

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

				std::error_code resolve(SymbolBody *Body);
				std::error_code addMemberFile(Lazy *Body);

				std::unordered_map<StringRef, Symbol *> Symtab;
				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.
				std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
				llvm::BumpPtrAllocator Alloc;
				};

				} // namespace elf2
				} // 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::elf2;

				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);
				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> 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;
				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;
				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.
				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));
				}

				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";
				}
				}

				namespace lld {
				namespace elf2 {
				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 elf2 {

				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, StringRef Name, const Elf_Sym S, Chunk *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 {
				public:
				Lazy(ArchiveFile *F, const Archive::Symbol S)
				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.
				: 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(UndefinedKind), Name(N) {}

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

				int compare(SymbolBody *Other) override;

				private:
				StringRef Name;
				};

				class DefinedBitcode : public Defined {
				public:
				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.
				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 elf2
				} // 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::elf2;

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

				// 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);
				return 1;
				}

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

				template <class ELFT> StringRef DefinedRegular<ELFT>::getName() { 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 elf2 {
				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 elf2 {

				// 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();
				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 elf2
				} // 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>

				using namespace llvm;
				using namespace llvm::ELF;
				ruiuUnsubmitted Done Reply Inline Actions Remove ruiu: Remove
				using namespace llvm::object;
				using namespace llvm::support;
				using namespace llvm::support::endian;

				using namespace lld;
				using namespace lld::elf2;

				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);
				}
				};
				}

				// The main function of the writer.
				template <class ELFT>
				ruiuUnsubmitted Done Reply Inline Actions Move this above "static const int PageSize...". ruiu: Move this above "static const int PageSize...".
				std::error_code Writer<ELFT>::write(StringRef OutputPath) {
				markLive();
				createSections();
				assignAddresses();
				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())
				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());
				}
				}
				}

				// 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);
				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.
				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 elf2 {
				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 elf2 {
		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/CMakeLists.txt

Show All 16 Lines	add_llvm_library(lldDriver
GnuLdDriver.cpp		GnuLdDriver.cpp
UniversalDriver.cpp		UniversalDriver.cpp
WinLinkDriver.cpp		WinLinkDriver.cpp
WinLinkModuleDef.cpp		WinLinkModuleDef.cpp
LINK_LIBS		LINK_LIBS
lldConfig		lldConfig
lldMachO		lldMachO
lldCOFF		lldCOFF
		lldELF2
lldPECOFF		lldPECOFF
lldELF		lldELF
lldAArch64ELFTarget		lldAArch64ELFTarget
lldARMELFTarget		lldARMELFTarget
lldHexagonELFTarget		lldHexagonELFTarget
lldMipsELFTarget		lldMipsELFTarget
lldX86ELFTarget		lldX86ELFTarget
lldExampleSubTarget		lldExampleSubTarget
Show All 11 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 elf2::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 30404

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/CMakeLists.txt

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 30404

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/CMakeLists.txt

lib/Driver/UniversalDriver.cpp

test/elfv2/basic.test

tools/lld/CMakeLists.txt

unittests/DriverTests/CMakeLists.txt

[LLD] New ELF implementation
ClosedPublic