1 //===- Main.cpp -----------------------------------------------------------===//
2 //
3 //                     The MCLinker Project
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #include <mcld/Environment.h>
10 #include <mcld/IRBuilder.h>
11 #include <mcld/Linker.h>
12 #include <mcld/LinkerConfig.h>
13 #include <mcld/LinkerScript.h>
14 #include <mcld/Module.h>
15 #include <mcld/ADT/StringEntry.h>
16 #include <mcld/MC/InputAction.h>
17 #include <mcld/MC/CommandAction.h>
18 #include <mcld/MC/FileAction.h>
19 #include <mcld/MC/ZOption.h>
20 #include <mcld/Support/raw_ostream.h>
21 #include <mcld/Support/MsgHandling.h>
22 #include <mcld/Support/Path.h>
23 #include <mcld/Support/SystemUtils.h>
24 #include <mcld/Support/TargetRegistry.h>
25 
26 #include <llvm/ADT/ArrayRef.h>
27 #include <llvm/ADT/SmallVector.h>
28 #include <llvm/ADT/STLExtras.h>
29 #include <llvm/ADT/StringRef.h>
30 #include <llvm/ADT/StringSwitch.h>
31 #include <llvm/Option/Arg.h>
32 #include <llvm/Option/ArgList.h>
33 #include <llvm/Option/OptTable.h>
34 #include <llvm/Option/Option.h>
35 #include <llvm/Support/ManagedStatic.h>
36 #include <llvm/Support/Process.h>
37 #include <llvm/Support/Signals.h>
38 
39 #include <cassert>
40 #include <cstdlib>
41 #include <string>
42 
43 #if defined(HAVE_UNISTD_H)
44 #include <unistd.h>
45 #endif
46 
47 #if defined(_MSC_VER) || defined(__MINGW32__)
48 #include <io.h>
49 #ifndef STDIN_FILENO
50 #define STDIN_FILENO 0
51 #endif
52 #ifndef STDOUT_FILENO
53 #define STDOUT_FILENO 1
54 #endif
55 #ifndef STDERR_FILENO
56 #define STDERR_FILENO 2
57 #endif
58 #endif
59 
60 namespace {
61 
62 class Driver {
63  private:
64   enum Option {
65     // This is not an option.
66     kOpt_INVALID = 0,
67 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
68                HELPTEXT, METAVAR) \
69     kOpt_ ## ID,
70 #include "Options.inc"  // NOLINT
71 #undef OPTION
72     kOpt_LastOption
73   };
74 
75   class OptTable : public llvm::opt::OptTable {
76    private:
77 #define PREFIX(NAME, VALUE) \
78     static const char* const NAME[];
79 #include "Options.inc"  // NOLINT
80 #undef PREFIX
81     static const llvm::opt::OptTable::Info InfoTable[];
82 
83    public:
84     OptTable();
85   };
86 
87  private:
Driver(const char * prog_name)88   explicit Driver(const char* prog_name)
89       : prog_name_(prog_name),
90         module_(script_),
91         ir_builder_(module_, config_) {
92     return;
93   }
94 
95  public:
96   static std::unique_ptr<Driver> Create(llvm::ArrayRef<const char*> argv);
97 
98   bool Run();
99 
100  private:
101   bool TranslateArguments(llvm::opt::InputArgList& args);
102 
103  private:
104   const char* prog_name_;
105 
106   mcld::LinkerScript script_;
107 
108   mcld::LinkerConfig config_;
109 
110   mcld::Module module_;
111 
112   mcld::IRBuilder ir_builder_;
113 
114   mcld::Linker linker_;
115 
116  private:
117   DISALLOW_COPY_AND_ASSIGN(Driver);
118 };
119 
120 #define PREFIX(NAME, VALUE) \
121     const char* const Driver::OptTable::NAME[] = VALUE;
122 #include "Options.inc"  // NOLINT
123 #undef PREFIX
124 
125 const llvm::opt::OptTable::Info Driver::OptTable::InfoTable[] = {
126 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
127                HELPTEXT, METAVAR) \
128     { PREFIX, NAME, HELPTEXT, METAVAR, kOpt_ ## ID, \
129       llvm::opt::Option::KIND ## Class, PARAM, FLAGS, kOpt_ ## GROUP, \
130       kOpt_ ## ALIAS, ALIASARGS },
131 #include "Options.inc"  // NOLINT
132 #undef OPTION
133 };
134 
OptTable()135 Driver::OptTable::OptTable()
136     : llvm::opt::OptTable(InfoTable) { }
137 
ShouldColorize()138 inline bool ShouldColorize() {
139   const char* term = getenv("TERM");
140   return term && (0 != strcmp(term, "dumb"));
141 }
142 
143 /// ParseProgName - Parse program name
144 /// This function simplifies cross-compiling by reading triple from the program
145 /// name. For example, if the program name is `arm-linux-eabi-ld.mcld', we can
146 /// get the triple is arm-linux-eabi by the program name.
ParseProgName(const char * prog_name)147 inline std::string ParseProgName(const char* prog_name) {
148   static const char* suffixes[] = {"ld", "ld.mcld"};
149 
150   std::string name(mcld::sys::fs::Path(prog_name).stem().native());
151 
152   for (size_t i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
153     if (name == suffixes[i])
154       return std::string();
155   }
156 
157   llvm::StringRef prog_name_ref(prog_name);
158   llvm::StringRef prefix;
159 
160   for (size_t i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
161     if (!prog_name_ref.endswith(suffixes[i]))
162       continue;
163 
164     llvm::StringRef::size_type last_component =
165         prog_name_ref.rfind('-', prog_name_ref.size() - strlen(suffixes[i]));
166     if (last_component == llvm::StringRef::npos)
167       continue;
168     llvm::StringRef prefix = prog_name_ref.slice(0, last_component);
169     std::string ignored_error;
170     if (!mcld::TargetRegistry::lookupTarget(prefix, ignored_error))
171       continue;
172     return prefix.str();
173   }
174   return std::string();
175 }
176 
ParseEmulation(llvm::Triple & triple,const char * emulation)177 inline void ParseEmulation(llvm::Triple& triple, const char* emulation) {
178   llvm::Triple emu_triple =
179       llvm::StringSwitch<llvm::Triple>(emulation)
180           .Case("aarch64linux", llvm::Triple("aarch64", "", "linux", "gnu"))
181           .Case("armelf_linux_eabi", llvm::Triple("arm", "", "linux", "gnu"))
182           .Case("elf_i386", llvm::Triple("i386", "", "", "gnu"))
183           .Case("elf_x86_64", llvm::Triple("x86_64", "", "", "gnu"))
184           .Case("elf32_x86_64", llvm::Triple("x86_64", "", "", "gnux32"))
185           .Case("elf_i386_fbsd", llvm::Triple("i386", "", "freebsd", "gnu"))
186           .Case("elf_x86_64_fbsd", llvm::Triple("x86_64", "", "freebsd", "gnu"))
187           .Case("elf32ltsmip", llvm::Triple("mipsel", "", "", "gnu"))
188           .Case("elf64ltsmip", llvm::Triple("mips64el", "", "", "gnu"))
189           .Default(llvm::Triple());
190 
191   if (emu_triple.getArch() == llvm::Triple::UnknownArch &&
192       emu_triple.getOS() == llvm::Triple::UnknownOS &&
193       emu_triple.getEnvironment() == llvm::Triple::UnknownEnvironment)
194     mcld::error(mcld::diag::err_invalid_emulation) << emulation << "\n";
195 
196   if (emu_triple.getArch() != llvm::Triple::UnknownArch)
197     triple.setArch(emu_triple.getArch());
198 
199   if (emu_triple.getOS() != llvm::Triple::UnknownOS)
200     triple.setOS(emu_triple.getOS());
201 
202   if (emu_triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
203     triple.setEnvironment(emu_triple.getEnvironment());
204 }
205 
206 /// Configure the output filename.
ConfigureOutputName(llvm::StringRef output_name,mcld::Module & module,mcld::LinkerConfig & config)207 inline bool ConfigureOutputName(llvm::StringRef output_name,
208                                 mcld::Module& module,
209                                 mcld::LinkerConfig& config) {
210   std::string output(output_name.str());
211   if (output.empty()) {
212     if (config.targets().triple().getOS() == llvm::Triple::Win32) {
213       output.assign("_out");
214       switch (config.codeGenType()) {
215         case mcld::LinkerConfig::Object: {
216           output += ".obj";
217           break;
218         }
219         case mcld::LinkerConfig::DynObj: {
220           output += ".dll";
221           break;
222         }
223         case mcld::LinkerConfig::Exec: {
224           output += ".exe";
225           break;
226         }
227         case mcld::LinkerConfig::External:
228           break;
229         default: {
230           return false;
231           break;
232         }
233       }  // switch (config.codeGenType())
234     } else {
235       output.assign("a.out");
236     }
237   }  // if (output.empty())
238 
239   module.setName(output);
240   return true;
241 }
242 
InitializeInputs(mcld::IRBuilder & ir_builder,std::vector<std::unique_ptr<mcld::InputAction>> & input_actions)243 bool InitializeInputs(mcld::IRBuilder& ir_builder,
244     std::vector<std::unique_ptr<mcld::InputAction>>& input_actions) {
245   for (auto& action : input_actions) {
246     assert(action != nullptr);
247     action->activate(ir_builder.getInputBuilder());
248   }
249 
250   if (ir_builder.getInputBuilder().isInGroup()) {
251     mcld::fatal(mcld::diag::fatal_forbid_nest_group);
252     return false;
253   }
254 
255   return true;
256 }
257 
TranslateArguments(llvm::opt::InputArgList & args)258 bool Driver::TranslateArguments(llvm::opt::InputArgList& args) {
259   //===--------------------------------------------------------------------===//
260   // Preference
261   //===--------------------------------------------------------------------===//
262 
263   // --color=mode
264   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Color)) {
265     bool res = llvm::StringSwitch<bool>(arg->getValue())
266                    .Case("never", false)
267                    .Case("always", true)
268                    .Case("auto", ShouldColorize() &&
269                                  llvm::sys::Process::FileDescriptorIsDisplayed(
270                                      STDOUT_FILENO))
271                    .Default(false);
272     config_.options().setColor(res);
273     mcld::outs().setColor(res);
274     mcld::errs().setColor(res);
275   }
276 
277   // --trace
278   config_.options().setTrace(args.hasArg(kOpt_Trace));
279 
280   // --verbose=level
281   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Verbose)) {
282     llvm::StringRef value = arg->getValue();
283     int level;
284     if (value.getAsInteger(0, level)) {
285       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
286                    << ": " << arg->getValue();
287       return false;
288     }
289     config_.options().setVerbose(level);
290   }
291 
292   // --error-limit NUMBER
293   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ErrorLimit)) {
294     llvm::StringRef value = arg->getValue();
295     int num;
296     if (value.getAsInteger(0, num) || (num < 0)) {
297       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
298                    << ": " << arg->getValue();
299       return false;
300     }
301     config_.options().setMaxErrorNum(num);
302   }
303 
304   // --warning-limit NUMBER
305   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_WarningLimit)) {
306     llvm::StringRef value = arg->getValue();
307     int num;
308     if (value.getAsInteger(0, num) || (num < 0)) {
309       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
310                    << ": " << arg->getValue();
311       return false;
312     }
313     config_.options().setMaxWarnNum(num);
314   }
315 
316   // --warn-shared-textrel
317   config_.options().setWarnSharedTextrel(args.hasArg(kOpt_WarnSharedTextrel));
318 
319   //===--------------------------------------------------------------------===//
320   // Target
321   //===--------------------------------------------------------------------===//
322   llvm::Triple triple;
323   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Triple)) {
324     // 1. Use the triple from command.
325     // -mtriple=value
326     triple.setTriple(arg->getValue());
327   } else {
328     std::string prog_triple = ParseProgName(prog_name_);
329     if (!prog_triple.empty()) {
330       // 2. Use the triple from the program name prefix.
331       triple.setTriple(prog_triple);
332     } else {
333       // 3. Use the default target triple.
334       triple.setTriple(mcld::sys::getDefaultTargetTriple());
335     }
336   }
337 
338   // If a specific emulation was requested, apply it now.
339   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Emulation)) {
340     // -m emulation
341     ParseEmulation(triple, arg->getValue());
342   } else if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Arch)) {
343     // -march=value
344     config_.targets().setArch(arg->getValue());
345   }
346 
347   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_CPU)) {
348     config_.targets().setTargetCPU(arg->getValue());
349   }
350 
351   config_.targets().setTriple(triple);
352 
353   // --gpsize=value
354   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_GPSize)) {
355     llvm::StringRef value = arg->getValue();
356     int size;
357     if (value.getAsInteger(0, size) || (size< 0)) {
358       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
359                    << ": " << arg->getValue() << "\n";
360       return false;
361     }
362     config_.targets().setGPSize(size);
363   }
364 
365   // --stub-group-size=value
366   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_StubGroupSize)) {
367     llvm::StringRef value = arg->getValue();
368     int size;
369     if (value.getAsInteger(0, size) || (size< 0)) {
370       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
371                    << ": " << arg->getValue() << "\n";
372       return false;
373     }
374     config_.targets().setStubGroupSize(size);
375   }
376 
377   // --fix-cortex-a53-835769
378   config_.targets().setFixCA53Erratum835769(
379       args.hasArg(kOpt_FixCA53Erratum835769));
380 
381   // --fix-cortex-a53-843419
382   config_.targets().setFixCA53Erratum843419(
383       args.hasArg(kOpt_FixCA53Erratum843419));
384 
385   //===--------------------------------------------------------------------===//
386   // Dynamic
387   //===--------------------------------------------------------------------===//
388 
389   // --entry=entry
390   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Entry)) {
391     script_.setEntry(arg->getValue());
392   }
393 
394   // -Bsymbolic
395   config_.options().setBsymbolic(args.hasArg(kOpt_Bsymbolic));
396 
397   // -Bgroup
398   config_.options().setBgroup(args.hasArg(kOpt_Bgroup));
399 
400   // -soname=name
401   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_SOName)) {
402     config_.options().setSOName(arg->getValue());
403   }
404 
405   // --no-undefined
406   if (args.hasArg(kOpt_NoUndef)) {
407     config_.options().setNoUndefined(true);
408   }
409 
410   // --allow-multiple-definition
411   if (args.hasArg(kOpt_AllowMulDefs)) {
412     config_.options().setMulDefs(true);
413   }
414 
415   // -z options
416   for (llvm::opt::Arg* arg : args.filtered(kOpt_Z)) {
417     llvm::StringRef value = arg->getValue();
418     mcld::ZOption z_opt =
419         llvm::StringSwitch<mcld::ZOption>(value)
420             .Case("combreloc", mcld::ZOption(mcld::ZOption::CombReloc))
421             .Case("nocombreloc", mcld::ZOption(mcld::ZOption::NoCombReloc))
422             .Case("defs", mcld::ZOption(mcld::ZOption::Defs))
423             .Case("execstack", mcld::ZOption(mcld::ZOption::ExecStack))
424             .Case("noexecstack", mcld::ZOption(mcld::ZOption::NoExecStack))
425             .Case("initfirst", mcld::ZOption(mcld::ZOption::InitFirst))
426             .Case("interpose", mcld::ZOption(mcld::ZOption::InterPose))
427             .Case("loadfltr", mcld::ZOption(mcld::ZOption::LoadFltr))
428             .Case("muldefs", mcld::ZOption(mcld::ZOption::MulDefs))
429             .Case("nocopyreloc", mcld::ZOption(mcld::ZOption::NoCopyReloc))
430             .Case("nodefaultlib", mcld::ZOption(mcld::ZOption::NoDefaultLib))
431             .Case("nodelete", mcld::ZOption(mcld::ZOption::NoDelete))
432             .Case("nodlopen", mcld::ZOption(mcld::ZOption::NoDLOpen))
433             .Case("nodump", mcld::ZOption(mcld::ZOption::NoDump))
434             .Case("relro", mcld::ZOption(mcld::ZOption::Relro))
435             .Case("norelro", mcld::ZOption(mcld::ZOption::NoRelro))
436             .Case("lazy", mcld::ZOption(mcld::ZOption::Lazy))
437             .Case("now", mcld::ZOption(mcld::ZOption::Now))
438             .Case("origin", mcld::ZOption(mcld::ZOption::Origin))
439             .Default(mcld::ZOption());
440 
441     if (z_opt.kind() == mcld::ZOption::Unknown) {
442       if (value.startswith("common-page-size=")) {
443         // -z common-page-size=value
444         z_opt.setKind(mcld::ZOption::CommPageSize);
445         long long unsigned size = 0;
446         value.drop_front(17).getAsInteger(0, size);
447         z_opt.setPageSize(static_cast<uint64_t>(size));
448       } else if (value.startswith("max-page-size=")) {
449         // -z max-page-size=value
450         z_opt.setKind(mcld::ZOption::MaxPageSize);
451         long long unsigned size = 0;
452         value.drop_front(14).getAsInteger(0, size);
453         z_opt.setPageSize(static_cast<uint64_t>(size));
454       }
455     }
456     config_.options().addZOption(z_opt);
457   }
458 
459   // --dynamic-linker=file
460   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Dyld)) {
461     config_.options().setDyld(arg->getValue());
462   }
463 
464   // --enable-new-dtags
465   config_.options().setNewDTags(args.hasArg(kOpt_EnableNewDTags));
466 
467   // --spare-dyanmic-tags COUNT
468   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_SpareDTags)) {
469     llvm::StringRef value = arg->getValue();
470     int num;
471     if (value.getAsInteger(0, num) || (num < 0)) {
472       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
473                    << ": " << arg->getValue() << "\n";
474       return false;
475     }
476     config_.options().setNumSpareDTags(num);
477   }
478 
479   //===--------------------------------------------------------------------===//
480   // Output
481   //===--------------------------------------------------------------------===//
482 
483   // Setup the codegen type.
484   if (args.hasArg(kOpt_Shared) || args.hasArg(kOpt_PIE)) {
485     // -shared, -pie
486     config_.setCodeGenType(mcld::LinkerConfig::DynObj);
487   } else if (args.hasArg(kOpt_Relocatable)) {
488     // -r
489     config_.setCodeGenType(mcld::LinkerConfig::Object);
490   } else if (llvm::opt::Arg* arg = args.getLastArg(kOpt_OutputFormat)) {
491     // --oformat=value
492     llvm::StringRef value = arg->getValue();
493     if (value.equals("binary")) {
494       config_.setCodeGenType(mcld::LinkerConfig::Binary);
495     }
496   } else {
497     config_.setCodeGenType(mcld::LinkerConfig::Exec);
498   }
499 
500   // Setup the output filename.
501   llvm::StringRef output_name;
502   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Output)) {
503     output_name = arg->getValue();
504   }
505   if (!ConfigureOutputName(output_name, module_, config_)) {
506     mcld::unreachable(mcld::diag::unrecognized_output_file) << module_.name();
507     return false;
508   } else {
509     if (!args.hasArg(kOpt_SOName)) {
510       config_.options().setSOName(module_.name());
511     }
512   }
513 
514   // --format=value
515   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_InputFormat)) {
516     llvm::StringRef value = arg->getValue();
517     if (value.equals("binary")) {
518       config_.options().setBinaryInput();
519     }
520   }
521 
522   // Setup debug info stripping.
523   config_.options().setStripDebug(args.hasArg(kOpt_StripDebug) ||
524                                   args.hasArg(kOpt_StripAll));
525 
526   // Setup symbol stripping mode.
527   if (args.hasArg(kOpt_StripAll)) {
528     config_.options().setStripSymbols(
529         mcld::GeneralOptions::StripSymbolMode::StripAllSymbols);
530   } else if (args.hasArg(kOpt_DiscardAll)) {
531     config_.options().setStripSymbols(
532         mcld::GeneralOptions::StripSymbolMode::StripLocals);
533   } else if (args.hasArg(kOpt_DiscardLocals)) {
534     config_.options().setStripSymbols(
535         mcld::GeneralOptions::StripSymbolMode::StripTemporaries);
536   } else {
537     config_.options().setStripSymbols(
538         mcld::GeneralOptions::StripSymbolMode::KeepAllSymbols);
539   }
540 
541   // --eh-frame-hdr
542   config_.options().setEhFrameHdr(args.hasArg(kOpt_EHFrameHdr));
543 
544   // -pie
545   config_.options().setPIE(args.hasArg(kOpt_PIE));
546 
547   // --nmagic
548   config_.options().setNMagic(args.hasArg(kOpt_NMagic));
549 
550   // --omagic
551   config_.options().setOMagic(args.hasArg(kOpt_OMagic));
552 
553   // --hash-style=style
554   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_HashStyle)) {
555     mcld::GeneralOptions::HashStyle style =
556         llvm::StringSwitch<mcld::GeneralOptions::HashStyle>(arg->getValue())
557             .Case("sysv", mcld::GeneralOptions::HashStyle::SystemV)
558             .Case("gnu", mcld::GeneralOptions::HashStyle::GNU)
559             .Case("both", mcld::GeneralOptions::HashStyle::Both)
560             .Default(mcld::GeneralOptions::HashStyle::Unknown);
561     if (style != mcld::GeneralOptions::HashStyle::Unknown) {
562       config_.options().setHashStyle(style);
563     }
564   }
565 
566   // --[no]-export-dynamic
567   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ExportDynamic,
568                                               kOpt_NoExportDynamic)) {
569     if (arg->getOption().matches(kOpt_ExportDynamic)) {
570       config_.options().setExportDynamic(true);
571     } else {
572       config_.options().setExportDynamic(false);
573     }
574   }
575 
576   // --no-warn-mismatch
577   config_.options().setWarnMismatch(!args.hasArg(kOpt_NoWarnMismatch));
578 
579   // --exclude-libs
580   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ExcludeLibs)) {
581     llvm::StringRef value = arg->getValue();
582     do {
583       std::pair<llvm::StringRef, llvm::StringRef> res = value.split(',');
584       config_.options().excludeLIBS().insert(res.first.str());
585       value = res.second;
586     } while (!value.empty());
587   }
588 
589   //===--------------------------------------------------------------------===//
590   // Search Path
591   //===--------------------------------------------------------------------===//
592 
593   // --sysroot
594   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Sysroot)) {
595     mcld::sys::fs::Path path(arg->getValue());
596     if (mcld::sys::fs::exists(path) && mcld::sys::fs::is_directory(path)) {
597       script_.setSysroot(path);
598     }
599   }
600 
601   // -L searchdir
602   for (llvm::opt::Arg* arg : args.filtered(kOpt_LibraryPath)) {
603     if (!script_.directories().insert(arg->getValue()))
604       mcld::warning(mcld::diag::warn_cannot_open_search_dir) << arg->getValue();
605   }
606 
607   // -nostdlib
608   config_.options().setNoStdlib(args.hasArg(kOpt_NoStdlib));
609 
610   // -rpath=path
611   for (llvm::opt::Arg* arg : args.filtered(kOpt_RPath)) {
612     config_.options().getRpathList().push_back(arg->getValue());
613   }
614 
615   //===--------------------------------------------------------------------===//
616   // Symbol
617   //===--------------------------------------------------------------------===//
618 
619   // -d/-dc/-dp
620   config_.options().setDefineCommon(args.hasArg(kOpt_DefineCommon));
621 
622   // -u symbol
623   for (llvm::opt::Arg* arg : args.filtered(kOpt_Undefined)) {
624     config_.options().getUndefSymList().push_back(arg->getValue());
625   }
626 
627   //===--------------------------------------------------------------------===//
628   // Script
629   //===--------------------------------------------------------------------===//
630 
631   // --wrap=symbol
632   for (llvm::opt::Arg* arg : args.filtered(kOpt_Wrap)) {
633     bool exist = false;
634     const char* symbol = arg->getValue();
635     // symbol -> __wrap_symbol
636     mcld::StringEntry<llvm::StringRef>* to_wrap =
637         script_.renameMap().insert(symbol, exist);
638 
639     std::string to_wrap_str;
640     to_wrap_str.append("__wrap_")
641                .append(symbol);
642     to_wrap->setValue(to_wrap_str);
643 
644     if (exist)
645       mcld::warning(mcld::diag::rewrap) << symbol << to_wrap_str;
646 
647     // __real_symbol -> symbol
648     std::string from_real_str;
649     to_wrap_str.append("__real_")
650                .append(symbol);
651     mcld::StringEntry<llvm::StringRef>* from_real =
652         script_.renameMap().insert(from_real_str, exist);
653     from_real->setValue(symbol);
654 
655     if (exist)
656       mcld::warning(mcld::diag::rewrap) << symbol << from_real_str;
657   }
658 
659   // --portalbe=symbol
660   for (llvm::opt::Arg* arg : args.filtered(kOpt_Portable)) {
661     bool exist = false;
662     const char* symbol = arg->getValue();
663     // symbol -> symbol_portable
664     mcld::StringEntry<llvm::StringRef>* to_wrap =
665         script_.renameMap().insert(symbol, exist);
666 
667     std::string to_wrap_str;
668     to_wrap_str.append(symbol)
669                .append("_portable");
670     to_wrap->setValue(to_wrap_str);
671 
672     if (exist)
673       mcld::warning(mcld::diag::rewrap) << symbol << to_wrap_str;
674 
675     // __real_symbol -> symbol
676     std::string from_real_str;
677     to_wrap_str.append("__real_")
678                .append(symbol);
679     mcld::StringEntry<llvm::StringRef>* from_real =
680         script_.renameMap().insert(from_real_str, exist);
681     from_real->setValue(symbol);
682 
683     if (exist)
684       mcld::warning(mcld::diag::rewrap) << symbol << from_real_str;
685   }
686 
687   // --section-start=section=addr
688   for (llvm::opt::Arg* arg : args.filtered(kOpt_SectionStart)) {
689     llvm::StringRef value = arg->getValue();
690     const size_t pos = value.find('=');
691     uint64_t addr = 0;
692     value.substr(pos + 1).getAsInteger(0, addr);
693     bool exist = false;
694     mcld::StringEntry<uint64_t>* mapping =
695         script_.addressMap().insert(value.substr(0, pos), exist);
696     mapping->setValue(addr);
697   }
698 
699   // -Tbss=value
700   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Tbss)) {
701     llvm::StringRef value = arg->getValue();
702     uint64_t addr = 0;
703     if (value.getAsInteger(0, addr)) {
704       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
705                    << ": " << arg->getValue() << "\n";
706       return false;
707     }
708     bool exist = false;
709     mcld::StringEntry<uint64_t>* mapping =
710         script_.addressMap().insert(".bss", exist);
711     mapping->setValue(addr);
712   }
713 
714   // -Tdata=value
715   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Tdata)) {
716     llvm::StringRef value = arg->getValue();
717     uint64_t addr = 0;
718     if (value.getAsInteger(0, addr)) {
719       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
720                    << ": " << arg->getValue() << "\n";
721       return false;
722     }
723     bool exist = false;
724     mcld::StringEntry<uint64_t>* mapping =
725         script_.addressMap().insert(".data", exist);
726     mapping->setValue(addr);
727   }
728 
729   // -Ttext=value
730   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Ttext)) {
731     llvm::StringRef value = arg->getValue();
732     uint64_t addr = 0;
733     if (value.getAsInteger(0, addr)) {
734       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
735                    << ": " << arg->getValue() << "\n";
736       return false;
737     }
738     bool exist = false;
739     mcld::StringEntry<uint64_t>* mapping =
740         script_.addressMap().insert(".text", exist);
741     mapping->setValue(addr);
742   }
743 
744   //===--------------------------------------------------------------------===//
745   // Optimization
746   //===--------------------------------------------------------------------===//
747 
748   // --[no-]gc-sections
749   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_GCSections,
750                                               kOpt_NoGCSections)) {
751     if (arg->getOption().matches(kOpt_GCSections)) {
752       config_.options().setGCSections(true);
753     } else {
754       config_.options().setGCSections(false);
755     }
756   }
757 
758   // --[no-]print-gc-sections
759   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_PrintGCSections,
760                                               kOpt_NoPrintGCSections)) {
761     if (arg->getOption().matches(kOpt_PrintGCSections)) {
762       config_.options().setPrintGCSections(true);
763     } else {
764       config_.options().setPrintGCSections(false);
765     }
766   }
767 
768   // --[no-]ld-generated-unwind-info
769   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_LDGeneratedUnwindInfo,
770                                               kOpt_NoLDGeneratedUnwindInfo)) {
771     if (arg->getOption().matches(kOpt_LDGeneratedUnwindInfo)) {
772       config_.options().setGenUnwindInfo(true);
773     } else {
774       config_.options().setGenUnwindInfo(false);
775     }
776   }
777 
778   // --icf=mode
779   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ICF)) {
780     mcld::GeneralOptions::ICF mode =
781         llvm::StringSwitch<mcld::GeneralOptions::ICF>(arg->getValue())
782             .Case("none", mcld::GeneralOptions::ICF::None)
783             .Case("all", mcld::GeneralOptions::ICF::All)
784             .Case("safe", mcld::GeneralOptions::ICF::Safe)
785             .Default(mcld::GeneralOptions::ICF::Unknown);
786     if (mode == mcld::GeneralOptions::ICF::Unknown) {
787       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
788                    << ": " << arg->getValue() << "\n";
789       return false;
790     }
791     config_.options().setICFMode(mode);
792   }
793 
794   // --icf-iterations
795   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ICFIters)) {
796     llvm::StringRef value = arg->getValue();
797     int num;
798     if (value.getAsInteger(0, num) || (num < 0)) {
799       mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
800                    << ": " << arg->getValue() << "\n";
801       return false;
802     }
803     config_.options().setICFIterations(num);
804   }
805 
806   // --[no-]print-icf-sections
807   if (llvm::opt::Arg* arg = args.getLastArg(kOpt_PrintICFSections,
808                                               kOpt_NoPrintICFSections)) {
809     if (arg->getOption().matches(kOpt_PrintICFSections)) {
810       config_.options().setPrintICFSections(true);
811     } else {
812       config_.options().setPrintICFSections(false);
813     }
814   }
815 
816   //===--------------------------------------------------------------------===//
817   // Positional
818   //===--------------------------------------------------------------------===//
819 
820   // # of regular objects, script, and namespec.
821   size_t input_num = 0;
822   typedef std::unique_ptr<mcld::InputAction> Action;
823 
824   std::vector<Action> actions;
825   Action action;
826   actions.reserve(32);
827 
828   for (llvm::opt::Arg* arg : args) {
829     const unsigned index = arg->getIndex();
830 
831     switch (arg->getOption().getID()) {
832       // -T script
833       case kOpt_Script: {
834         const char* value = arg->getValue();
835         config_.options().getScriptList().push_back(value);
836 
837         // FIXME: Let index of script file be 0.
838         action.reset(new mcld::ScriptAction(
839             0x0, value, mcld::ScriptFile::LDScript, script_.directories()));
840         actions.push_back(std::move(action));
841 
842         action.reset(new mcld::ContextAction(0x0));
843         actions.push_back(std::move(action));
844 
845         action.reset(new mcld::MemoryAreaAction(0x0,
846                                                 mcld::FileHandle::ReadOnly));
847         actions.push_back(std::move(action));
848 
849         ++input_num;
850         break;
851       }
852 
853       // --defsym=symbol=expr
854       case kOpt_DefSym: {
855         std::string expr;
856         expr.append(arg->getValue())
857             .append(";");
858         script_.defsyms().push_back(std::move(expr));
859         action.reset(new mcld::DefSymAction(index, script_.defsyms().back()));
860         actions.push_back(std::move(action));
861         break;
862       }
863 
864       // -l namespec
865       case kOpt_Namespec: {
866         action.reset(new mcld::NamespecAction(
867             index, arg->getValue(), script_.directories()));
868         actions.push_back(std::move(action));
869 
870         action.reset(new mcld::ContextAction(index));
871         actions.push_back(std::move(action));
872 
873         action.reset(new mcld::MemoryAreaAction(index,
874                                                 mcld::FileHandle::ReadOnly));
875         actions.push_back(std::move(action));
876 
877         ++input_num;
878         break;
879       }
880 
881       // --whole-archive
882       case kOpt_WholeArchive: {
883         action.reset(new mcld::WholeArchiveAction(index));
884         actions.push_back(std::move(action));
885         break;
886       }
887 
888       // --no-whole-archive
889       case kOpt_NoWholeArchive: {
890         action.reset(new mcld::NoWholeArchiveAction(index));
891         actions.push_back(std::move(action));
892         break;
893       }
894 
895       // --as-needed
896       case kOpt_AsNeeded: {
897         action.reset(new mcld::AsNeededAction(index));
898         actions.push_back(std::move(action));
899         break;
900       }
901 
902       // --no-as-needed
903       case kOpt_NoAsNeeded: {
904         action.reset(new mcld::NoAsNeededAction(index));
905         actions.push_back(std::move(action));
906         break;
907       }
908 
909       // --add-needed
910       // FIXME: This is deprecated. Should be --copy-dt-needed-entries.
911       case kOpt_AddNeeded:
912       case kOpt_CopyDTNeeded: {
913         action.reset(new mcld::AddNeededAction(index));
914         actions.push_back(std::move(action));
915         break;
916       }
917 
918       // --no-add-needed
919       // FIXME: This is deprecated. Should be --no-copy-dt-needed-entries.
920       case kOpt_NoAddNeeded:
921       case kOpt_NoCopyDTNeeded: {
922         action.reset(new mcld::AddNeededAction(index));
923         actions.push_back(std::move(action));
924         break;
925       }
926 
927       // -Bdynamic
928       case kOpt_Bdynamic: {
929         action.reset(new mcld::BDynamicAction(index));
930         actions.push_back(std::move(action));
931         break;
932       }
933 
934       // -Bstatic
935       case kOpt_Bstatic: {
936         action.reset(new mcld::BStaticAction(index));
937         actions.push_back(std::move(action));
938         break;
939       }
940 
941       // --start-group
942       case kOpt_StartGroup: {
943         action.reset(new mcld::StartGroupAction(index));
944         actions.push_back(std::move(action));
945         break;
946       }
947 
948       // --end-group
949       case kOpt_EndGroup: {
950         action.reset(new mcld::EndGroupAction(index));
951         actions.push_back(std::move(action));
952         break;
953       }
954 
955       case kOpt_INPUT: {
956         action.reset(new mcld::InputFileAction(index, arg->getValue()));
957         actions.push_back(std::move(action));
958 
959         action.reset(new mcld::ContextAction(index));
960         actions.push_back(std::move(action));
961 
962         action.reset(new mcld::MemoryAreaAction(index,
963                                                 mcld::FileHandle::ReadOnly));
964         actions.push_back(std::move(action));
965 
966         ++input_num;
967         break;
968       }
969 
970       default:
971         break;
972     }
973   }
974 
975   if (input_num == 0) {
976     mcld::fatal(mcld::diag::err_no_inputs);
977     return false;
978   }
979 
980   // Stable sort
981   std::stable_sort(actions.begin(),
982                    actions.end(),
983                    [] (const Action& X, const Action& Y) {
984                      return X->position() < Y->position();
985                    });
986 
987   if (!InitializeInputs(ir_builder_, actions)) {
988     mcld::errs() << "Failed to initialize input tree!\n";
989     return false;
990   }
991 
992 
993   //===--------------------------------------------------------------------===//
994   // Unknown
995   //===--------------------------------------------------------------------===//
996   std::vector<std::string> unknown_args = args.getAllArgValues(kOpt_UNKNOWN);
997   for (std::string arg : unknown_args)
998     mcld::warning(mcld::diag::warn_unsupported_option) << arg;
999 
1000   return true;
1001 }
1002 
Create(llvm::ArrayRef<const char * > argv)1003 std::unique_ptr<Driver> Driver::Create(llvm::ArrayRef<const char*> argv) {
1004   // Parse command line options.
1005   OptTable opt_table;
1006   unsigned missing_arg_idx;
1007   unsigned missing_arg_count;
1008   llvm::opt::InputArgList args =
1009       opt_table.ParseArgs(argv.slice(1), missing_arg_idx, missing_arg_count);
1010   if (missing_arg_count > 0) {
1011     mcld::errs() << "Argument to '" << args.getArgString(missing_arg_idx)
1012                  << "' is missing (expected " << missing_arg_count
1013                  << ((missing_arg_count > 1) ? " values" : " value") << ")\n";
1014     return nullptr;
1015   }
1016 
1017   std::unique_ptr<Driver> result(new Driver(argv[0]));
1018 
1019   // Return quickly if -help is specified.
1020   if (args.hasArg(kOpt_Help)) {
1021     opt_table.PrintHelp(mcld::outs(), argv[0], "MCLinker",
1022                         /* FlagsToInclude */0, /* FlagsToExclude */0);
1023     return nullptr;
1024   }
1025 
1026   // Print version information if requested.
1027   if (args.hasArg(kOpt_Version)) {
1028     mcld::outs() << result->config_.options().getVersionString() << "\n";
1029   }
1030 
1031   // Setup instance from arguments.
1032   if (!result->TranslateArguments(args)) {
1033     return nullptr;
1034   }
1035 
1036   return result;
1037 }
1038 
Run()1039 bool Driver::Run() {
1040   mcld::Initialize();
1041 
1042   if (!linker_.emulate(script_, config_)) {
1043     mcld::errs() << "Failed to emulate target!\n";
1044     return false;
1045   }
1046 
1047   if (!linker_.link(module_, ir_builder_)) {
1048     mcld::errs() << "Failed to link objects!\n";
1049     return false;
1050   }
1051 
1052   if (!linker_.emit(module_, module_.name())) {
1053     mcld::errs() << "Failed to emit output!\n";
1054     return false;
1055   }
1056 
1057   mcld::Finalize();
1058   return true;
1059 }
1060 
1061 }  // anonymous namespace
1062 
main(int argc,char ** argv)1063 int main(int argc, char** argv) {
1064   std::unique_ptr<Driver> driver =
1065       Driver::Create(llvm::makeArrayRef(argv, argc));
1066 
1067   if ((driver == nullptr) || !driver->Run()) {
1068     return EXIT_FAILURE;
1069   } else {
1070     return EXIT_SUCCESS;
1071   }
1072 }
1073