1 //===- Driver.cpp ---------------------------------------------------------===// 2 // 3 // The LLVM Linker 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "Driver.h" 11 #include "Config.h" 12 #include "Error.h" 13 #include "InputFiles.h" 14 #include "SymbolTable.h" 15 #include "Target.h" 16 #include "Writer.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/StringExtras.h" 19 #include "llvm/Support/raw_ostream.h" 20 #include <utility> 21 22 using namespace llvm; 23 using namespace llvm::ELF; 24 using namespace llvm::object; 25 26 using namespace lld; 27 using namespace lld::elf2; 28 29 Configuration *lld::elf2::Config; 30 LinkerDriver *lld::elf2::Driver; 31 32 void lld::elf2::link(ArrayRef<const char *> Args) { 33 Configuration C; 34 LinkerDriver D; 35 Config = &C; 36 Driver = &D; 37 Driver->main(Args.slice(1)); 38 } 39 40 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef S) { 41 Config->Emulation = S; 42 if (S == "elf32btsmip") 43 return {ELF32BEKind, EM_MIPS}; 44 if (S == "elf32ltsmip") 45 return {ELF32LEKind, EM_MIPS}; 46 if (S == "elf32ppc") 47 return {ELF32BEKind, EM_PPC}; 48 if (S == "elf64ppc") 49 return {ELF64BEKind, EM_PPC64}; 50 if (S == "elf_i386") 51 return {ELF32LEKind, EM_386}; 52 if (S == "elf_x86_64") 53 return {ELF64LEKind, EM_X86_64}; 54 error("Unknown emulation: " + S); 55 } 56 57 // Opens and parses a file. Path has to be resolved already. 58 // Newly created memory buffers are owned by this driver. 59 void LinkerDriver::addFile(StringRef Path) { 60 using namespace llvm::sys::fs; 61 if (Config->Verbose) 62 llvm::outs() << Path << "\n"; 63 auto MBOrErr = MemoryBuffer::getFile(Path); 64 error(MBOrErr, "cannot open " + Path); 65 std::unique_ptr<MemoryBuffer> &MB = *MBOrErr; 66 MemoryBufferRef MBRef = MB->getMemBufferRef(); 67 OwningMBs.push_back(std::move(MB)); // take MB ownership 68 69 switch (identify_magic(MBRef.getBuffer())) { 70 case file_magic::unknown: 71 readLinkerScript(&Alloc, MBRef); 72 return; 73 case file_magic::archive: 74 if (WholeArchive) { 75 auto File = make_unique<ArchiveFile>(MBRef); 76 for (MemoryBufferRef &MB : File->getMembers()) 77 Files.push_back(createELFFile<ObjectFile>(MB)); 78 OwningArchives.emplace_back(std::move(File)); 79 return; 80 } 81 Files.push_back(make_unique<ArchiveFile>(MBRef)); 82 return; 83 case file_magic::elf_shared_object: 84 Files.push_back(createELFFile<SharedFile>(MBRef)); 85 return; 86 default: 87 Files.push_back(createELFFile<ObjectFile>(MBRef)); 88 } 89 } 90 91 static StringRef 92 getString(opt::InputArgList &Args, unsigned Key, StringRef Default = "") { 93 if (auto *Arg = Args.getLastArg(Key)) 94 return Arg->getValue(); 95 return Default; 96 } 97 98 void LinkerDriver::main(ArrayRef<const char *> ArgsArr) { 99 initSymbols(); 100 101 opt::InputArgList Args = parseArgs(&Alloc, ArgsArr); 102 createFiles(Args); 103 104 switch (Config->EKind) { 105 case ELF32LEKind: 106 link<ELF32LE>(Args); 107 return; 108 case ELF32BEKind: 109 link<ELF32BE>(Args); 110 return; 111 case ELF64LEKind: 112 link<ELF64LE>(Args); 113 return; 114 case ELF64BEKind: 115 link<ELF64BE>(Args); 116 return; 117 default: 118 error("-m or at least a .o file required"); 119 } 120 } 121 122 void LinkerDriver::createFiles(opt::InputArgList &Args) { 123 for (auto *Arg : Args.filtered(OPT_L)) 124 Config->SearchPaths.push_back(Arg->getValue()); 125 126 std::vector<StringRef> RPaths; 127 for (auto *Arg : Args.filtered(OPT_rpath)) 128 RPaths.push_back(Arg->getValue()); 129 if (!RPaths.empty()) 130 Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":"); 131 132 if (auto *Arg = Args.getLastArg(OPT_m)) { 133 std::pair<ELFKind, uint16_t> P = parseEmulation(Arg->getValue()); 134 Config->EKind = P.first; 135 Config->EMachine = P.second; 136 } 137 138 Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition); 139 Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic); 140 Config->DiscardAll = Args.hasArg(OPT_discard_all); 141 Config->DiscardLocals = Args.hasArg(OPT_discard_locals); 142 Config->DiscardNone = Args.hasArg(OPT_discard_none); 143 Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags); 144 Config->ExportDynamic = Args.hasArg(OPT_export_dynamic); 145 Config->GcSections = Args.hasArg(OPT_gc_sections); 146 Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec); 147 Config->NoUndefined = Args.hasArg(OPT_no_undefined); 148 Config->Shared = Args.hasArg(OPT_shared); 149 Config->Verbose = Args.hasArg(OPT_verbose); 150 151 Config->DynamicLinker = getString(Args, OPT_dynamic_linker); 152 Config->Entry = getString(Args, OPT_entry); 153 Config->Fini = getString(Args, OPT_fini, "_fini"); 154 Config->Init = getString(Args, OPT_init, "_init"); 155 Config->OutputFile = getString(Args, OPT_o); 156 Config->SoName = getString(Args, OPT_soname); 157 Config->Sysroot = getString(Args, OPT_sysroot); 158 159 if (auto *Arg = Args.getLastArg(OPT_hash_style)) { 160 StringRef S = Arg->getValue(); 161 if (S == "gnu") { 162 Config->GnuHash = true; 163 Config->SysvHash = false; 164 } else if (S == "both") { 165 Config->GnuHash = true; 166 } else if (S != "sysv") 167 error("Unknown hash style: " + S); 168 } 169 170 for (auto *Arg : Args.filtered(OPT_undefined)) 171 Config->Undefined.push_back(Arg->getValue()); 172 173 for (auto *Arg : Args.filtered(OPT_z)) { 174 StringRef S = Arg->getValue(); 175 if (S == "nodelete") 176 Config->ZNodelete = true; 177 else if (S == "now") 178 Config->ZNow = true; 179 else if (S == "origin") 180 Config->ZOrigin = true; 181 } 182 183 for (auto *Arg : Args) { 184 switch (Arg->getOption().getID()) { 185 case OPT_l: 186 addFile(searchLibrary(Arg->getValue())); 187 break; 188 case OPT_INPUT: 189 case OPT_script: 190 addFile(Arg->getValue()); 191 break; 192 case OPT_as_needed: 193 Config->AsNeeded = true; 194 break; 195 case OPT_no_as_needed: 196 Config->AsNeeded = false; 197 break; 198 case OPT_Bstatic: 199 Config->Static = true; 200 break; 201 case OPT_Bdynamic: 202 Config->Static = false; 203 break; 204 case OPT_whole_archive: 205 WholeArchive = true; 206 break; 207 case OPT_no_whole_archive: 208 WholeArchive = false; 209 break; 210 } 211 } 212 213 if (Files.empty()) 214 error("no input files."); 215 } 216 217 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) { 218 SymbolTable<ELFT> Symtab; 219 Target.reset(createTarget()); 220 221 if (!Config->Shared) { 222 // Add entry symbol. 223 if (Config->Entry.empty()) 224 Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start"; 225 226 // Set either EntryAddr (if S is a number) or EntrySym (otherwise). 227 StringRef S = Config->Entry; 228 if (S.getAsInteger(0, Config->EntryAddr)) 229 Config->EntrySym = Symtab.addUndefined(S); 230 231 // In the assembly for 32 bit x86 the _GLOBAL_OFFSET_TABLE_ symbol 232 // is magical and is used to produce a R_386_GOTPC relocation. 233 // The R_386_GOTPC relocation value doesn't actually depend on the 234 // symbol value, so it could use an index of STN_UNDEF which, according 235 // to the spec, means the symbol value is 0. 236 // Unfortunately both gas and MC keep the _GLOBAL_OFFSET_TABLE_ symbol in 237 // the object file. 238 // The situation is even stranger on x86_64 where the assembly doesn't 239 // need the magical symbol, but gas still puts _GLOBAL_OFFSET_TABLE_ as 240 // an undefined symbol in the .o files. 241 // Given that the symbol is effectively unused, we just create a dummy 242 // hidden one to avoid the undefined symbol error. 243 Symtab.addIgnoredSym("_GLOBAL_OFFSET_TABLE_"); 244 } 245 246 for (std::unique_ptr<InputFile> &F : Files) 247 Symtab.addFile(std::move(F)); 248 249 for (StringRef S : Config->Undefined) 250 Symtab.addUndefinedOpt(S); 251 252 if (Config->OutputFile.empty()) 253 Config->OutputFile = "a.out"; 254 255 // Write the result to the file. 256 Symtab.scanShlibUndefined(); 257 if (Config->GcSections) 258 markLive<ELFT>(&Symtab); 259 writeResult<ELFT>(&Symtab); 260 } 261