llc.cpp revision b8cb0bb08c7f9f2dfcdfa5f7d72a4c56a9c93228 
1//===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This is the llc code generator driver. It provides a convenient
11// command-line interface for generating native assembly-language code
12// or C code, given LLVM bitcode.
13//
14//===----------------------------------------------------------------------===//
15
16#include "llvm/Bitcode/ReaderWriter.h"
17#include "llvm/CodeGen/FileWriters.h"
18#include "llvm/CodeGen/LinkAllCodegenComponents.h"
19#include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
20#include "llvm/Target/SubtargetFeature.h"
21#include "llvm/Target/TargetData.h"
22#include "llvm/Target/TargetMachine.h"
23#include "llvm/Target/TargetMachineRegistry.h"
24#include "llvm/Transforms/Scalar.h"
25#include "llvm/Module.h"
26#include "llvm/ModuleProvider.h"
27#include "llvm/PassManager.h"
28#include "llvm/Pass.h"
29#include "llvm/Support/CommandLine.h"
30#include "llvm/Support/FileUtilities.h"
31#include "llvm/Support/ManagedStatic.h"
32#include "llvm/Support/MemoryBuffer.h"
33#include "llvm/Support/PluginLoader.h"
34#include "llvm/Support/PrettyStackTrace.h"
35#include "llvm/Support/RegistryParser.h"
36#include "llvm/Support/raw_ostream.h"
37#include "llvm/Analysis/Verifier.h"
38#include "llvm/System/Signals.h"
39#include "llvm/Config/config.h"
40#include "llvm/LinkAllVMCore.h"
41#include <fstream>
42#include <iostream>
43#include <memory>
44using namespace llvm;
45
46// General options for llc.  Other pass-specific options are specified
47// within the corresponding llc passes, and target-specific options
48// and back-end code generation options are specified with the target machine.
49//
50static cl::opt<std::string>
51InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
52
53static cl::opt<std::string>
54OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
55
56static cl::opt<bool> Force("f", cl::desc("Overwrite output files"));
57
58// Determine optimization level. Level -O0 is equivalent to "fast" code gen.
59static cl::opt<char>
60OptLevel("O",
61         cl::desc("Optimization level. Similar to llvm-gcc -O."),
62         cl::Prefix,
63         cl::ZeroOrMore,
64         cl::init(' '));
65
66static cl::opt<std::string>
67TargetTriple("mtriple", cl::desc("Override target triple for module"));
68
69static cl::opt<const TargetMachineRegistry::entry*, false,
70               RegistryParser<TargetMachine> >
71MArch("march", cl::desc("Architecture to generate code for:"));
72
73static cl::opt<std::string>
74MCPU("mcpu",
75  cl::desc("Target a specific cpu type (-mcpu=help for details)"),
76  cl::value_desc("cpu-name"),
77  cl::init(""));
78
79static cl::list<std::string>
80MAttrs("mattr",
81  cl::CommaSeparated,
82  cl::desc("Target specific attributes (-mattr=help for details)"),
83  cl::value_desc("a1,+a2,-a3,..."));
84
85cl::opt<TargetMachine::CodeGenFileType>
86FileType("filetype", cl::init(TargetMachine::AssemblyFile),
87  cl::desc("Choose a file type (not all types are supported by all targets):"),
88  cl::values(
89       clEnumValN(TargetMachine::AssemblyFile, "asm",
90                  "Emit an assembly ('.s') file"),
91       clEnumValN(TargetMachine::ObjectFile, "obj",
92                  "Emit a native object ('.o') file [experimental]"),
93       clEnumValN(TargetMachine::DynamicLibrary, "dynlib",
94                  "Emit a native dynamic library ('.so') file"
95                  " [experimental]"),
96       clEnumValEnd));
97
98cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
99                       cl::desc("Do not verify input module"));
100
101
102// GetFileNameRoot - Helper function to get the basename of a filename.
103static inline std::string
104GetFileNameRoot(const std::string &InputFilename) {
105  std::string IFN = InputFilename;
106  std::string outputFilename;
107  int Len = IFN.length();
108  if ((Len > 2) &&
109      IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') {
110    outputFilename = std::string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
111  } else {
112    outputFilename = IFN;
113  }
114  return outputFilename;
115}
116
117static raw_ostream *GetOutputStream(const char *ProgName) {
118  if (OutputFilename != "") {
119    if (OutputFilename == "-")
120      return &outs();
121
122    // Specified an output filename?
123    if (!Force && std::ifstream(OutputFilename.c_str())) {
124      // If force is not specified, make sure not to overwrite a file!
125      std::cerr << ProgName << ": error opening '" << OutputFilename
126                << "': file exists!\n"
127                << "Use -f command line argument to force output\n";
128      return 0;
129    }
130    // Make sure that the Out file gets unlinked from the disk if we get a
131    // SIGINT
132    sys::RemoveFileOnSignal(sys::Path(OutputFilename));
133
134    std::string error;
135    raw_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(), true, error);
136    if (!error.empty()) {
137      std::cerr << error << '\n';
138      delete Out;
139      return 0;
140    }
141
142    return Out;
143  }
144
145  if (InputFilename == "-") {
146    OutputFilename = "-";
147    return &outs();
148  }
149
150  OutputFilename = GetFileNameRoot(InputFilename);
151
152  bool Binary = false;
153  switch (FileType) {
154  case TargetMachine::AssemblyFile:
155    if (MArch->Name[0] == 'c') {
156      if (MArch->Name[1] == 0)
157        OutputFilename += ".cbe.c";
158      else if (MArch->Name[1] == 'p' && MArch->Name[2] == 'p')
159        OutputFilename += ".cpp";
160      else
161        OutputFilename += ".s";
162    } else
163      OutputFilename += ".s";
164    break;
165  case TargetMachine::ObjectFile:
166    OutputFilename += ".o";
167    Binary = true;
168    break;
169  case TargetMachine::DynamicLibrary:
170    OutputFilename += LTDL_SHLIB_EXT;
171    Binary = true;
172    break;
173  }
174
175  if (!Force && std::ifstream(OutputFilename.c_str())) {
176    // If force is not specified, make sure not to overwrite a file!
177    std::cerr << ProgName << ": error opening '" << OutputFilename
178                          << "': file exists!\n"
179                          << "Use -f command line argument to force output\n";
180    return 0;
181  }
182
183  // Make sure that the Out file gets unlinked from the disk if we get a
184  // SIGINT
185  sys::RemoveFileOnSignal(sys::Path(OutputFilename));
186
187  std::string error;
188  raw_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(), Binary, error);
189  if (!error.empty()) {
190    std::cerr << error << '\n';
191    delete Out;
192    return 0;
193  }
194
195  return Out;
196}
197
198// main - Entry point for the llc compiler.
199//
200int main(int argc, char **argv) {
201  sys::PrintStackTraceOnErrorSignal();
202  PrettyStackTraceProgram X(argc, argv);
203  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
204  cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
205
206  // Load the module to be compiled...
207  std::string ErrorMessage;
208  std::auto_ptr<Module> M;
209
210  std::auto_ptr<MemoryBuffer> Buffer(
211                   MemoryBuffer::getFileOrSTDIN(InputFilename, &ErrorMessage));
212  if (Buffer.get())
213    M.reset(ParseBitcodeFile(Buffer.get(), &ErrorMessage));
214  if (M.get() == 0) {
215    std::cerr << argv[0] << ": bitcode didn't read correctly.\n";
216    std::cerr << "Reason: " << ErrorMessage << "\n";
217    return 1;
218  }
219  Module &mod = *M.get();
220
221  // If we are supposed to override the target triple, do so now.
222  if (!TargetTriple.empty())
223    mod.setTargetTriple(TargetTriple);
224
225  // Allocate target machine.  First, check whether the user has
226  // explicitly specified an architecture to compile for.
227  if (MArch == 0) {
228    std::string Err;
229    MArch = TargetMachineRegistry::getClosestStaticTargetForModule(mod, Err);
230    if (MArch == 0) {
231      std::cerr << argv[0] << ": error auto-selecting target for module '"
232                << Err << "'.  Please use the -march option to explicitly "
233                << "pick a target.\n";
234      return 1;
235    }
236  }
237
238  // Package up features to be passed to target/subtarget
239  std::string FeaturesStr;
240  if (MCPU.size() || MAttrs.size()) {
241    SubtargetFeatures Features;
242    Features.setCPU(MCPU);
243    for (unsigned i = 0; i != MAttrs.size(); ++i)
244      Features.AddFeature(MAttrs[i]);
245    FeaturesStr = Features.getString();
246  }
247
248  std::auto_ptr<TargetMachine> target(MArch->CtorFn(mod, FeaturesStr));
249  assert(target.get() && "Could not allocate target machine!");
250  TargetMachine &Target = *target.get();
251
252  // Figure out where we are going to send the output...
253  raw_ostream *Out = GetOutputStream(argv[0]);
254  if (Out == 0) return 1;
255
256  CodeGenOpt::Level OLvl = CodeGenOpt::Aggressive;
257
258  switch (OptLevel) {
259  default:
260  case ' ': break;
261  case '0': OLvl = CodeGenOpt::None; break;
262  case '1': OLvl = CodeGenOpt::One; break;
263  case '2': OLvl = CodeGenOpt::Two; break;
264  case 's': OLvl = CodeGenOpt::Size; break;
265  case '3': OLvl = CodeGenOpt::Aggressive; break;
266  }
267
268  // If this target requires addPassesToEmitWholeFile, do it now.  This is
269  // used by strange things like the C backend.
270  if (Target.WantsWholeFile()) {
271    PassManager PM;
272    PM.add(new TargetData(*Target.getTargetData()));
273    if (!NoVerify)
274      PM.add(createVerifierPass());
275
276    // Ask the target to add backend passes as necessary.
277    if (Target.addPassesToEmitWholeFile(PM, *Out, FileType, OLvl)) {
278      std::cerr << argv[0] << ": target does not support generation of this"
279                << " file type!\n";
280      if (Out != &outs()) delete Out;
281      // And the Out file is empty and useless, so remove it now.
282      sys::Path(OutputFilename).eraseFromDisk();
283      return 1;
284    }
285    PM.run(mod);
286  } else {
287    // Build up all of the passes that we want to do to the module.
288    ExistingModuleProvider Provider(M.release());
289    FunctionPassManager Passes(&Provider);
290    Passes.add(new TargetData(*Target.getTargetData()));
291
292#ifndef NDEBUG
293    if (!NoVerify)
294      Passes.add(createVerifierPass());
295#endif
296
297    // Ask the target to add backend passes as necessary.
298    MachineCodeEmitter *MCE = 0;
299
300    // Override default to generate verbose assembly.
301    Target.setAsmVerbosityDefault(true);
302
303    switch (Target.addPassesToEmitFile(Passes, *Out, FileType, OLvl)) {
304    default:
305      assert(0 && "Invalid file model!");
306      return 1;
307    case FileModel::Error:
308      std::cerr << argv[0] << ": target does not support generation of this"
309                << " file type!\n";
310      if (Out != &outs()) delete Out;
311      // And the Out file is empty and useless, so remove it now.
312      sys::Path(OutputFilename).eraseFromDisk();
313      return 1;
314    case FileModel::AsmFile:
315      break;
316    case FileModel::MachOFile:
317      MCE = AddMachOWriter(Passes, *Out, Target);
318      break;
319    case FileModel::ElfFile:
320      MCE = AddELFWriter(Passes, *Out, Target);
321      break;
322    }
323
324    if (Target.addPassesToEmitFileFinish(Passes, MCE, OLvl)) {
325      std::cerr << argv[0] << ": target does not support generation of this"
326                << " file type!\n";
327      if (Out != &outs()) delete Out;
328      // And the Out file is empty and useless, so remove it now.
329      sys::Path(OutputFilename).eraseFromDisk();
330      return 1;
331    }
332
333    Passes.doInitialization();
334
335    // Run our queue of passes all at once now, efficiently.
336    // TODO: this could lazily stream functions out of the module.
337    for (Module::iterator I = mod.begin(), E = mod.end(); I != E; ++I)
338      if (!I->isDeclaration())
339        Passes.run(*I);
340
341    Passes.doFinalization();
342  }
343
344  // Delete the ostream if it's not a stdout stream
345  if (Out != &outs()) delete Out;
346
347  return 0;
348}
349