Chris Lattner | 67e0842 | 2003-06-20 15:49:04 +0000 | [diff] [blame] | 1 | //===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===// |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 09344dc | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 345353d | 2007-12-29 20:44:31 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 09344dc | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 2cf137b | 2001-09-07 22:20:50 +0000 | [diff] [blame] | 9 | // |
Brian Gaeke | 33e83b6 | 2004-03-16 21:47:20 +0000 | [diff] [blame] | 10 | // This is the llc code generator driver. It provides a convenient |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 11 | // command-line interface for generating native assembly-language code |
Gabor Greif | e16561c | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 12 | // or C code, given LLVM bitcode. |
Chris Lattner | 2cf137b | 2001-09-07 22:20:50 +0000 | [diff] [blame] | 13 | // |
Chris Lattner | b27d474 | 2001-10-04 01:40:53 +0000 | [diff] [blame] | 14 | //===----------------------------------------------------------------------===// |
Vikram S. Adve | 2d94a34 | 2001-07-21 12:42:29 +0000 | [diff] [blame] | 15 | |
Owen Anderson | 6773d38 | 2009-07-01 16:58:40 +0000 | [diff] [blame] | 16 | #include "llvm/LLVMContext.h" |
Chris Lattner | ed22606 | 2001-09-07 21:26:31 +0000 | [diff] [blame] | 17 | #include "llvm/Module.h" |
Chris Lattner | 7139f28 | 2002-01-31 00:46:45 +0000 | [diff] [blame] | 18 | #include "llvm/PassManager.h" |
Vikram S. Adve | eb81869 | 2002-09-16 16:35:34 +0000 | [diff] [blame] | 19 | #include "llvm/Pass.h" |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/Triple.h" |
Dan Gohman | c76bfb7 | 2009-09-02 19:35:19 +0000 | [diff] [blame] | 21 | #include "llvm/Support/IRReader.h" |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 22 | #include "llvm/CodeGen/LinkAllAsmWriterComponents.h" |
| 23 | #include "llvm/CodeGen/LinkAllCodegenComponents.h" |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 24 | #include "llvm/Config/config.h" |
Evan Cheng | 8264e27 | 2011-06-29 01:14:12 +0000 | [diff] [blame] | 25 | #include "llvm/MC/SubtargetFeature.h" |
Reid Spencer | 7c16caa | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 26 | #include "llvm/Support/CommandLine.h" |
David Greene | 6e55be6 | 2010-01-05 01:30:21 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Debug.h" |
David Greene | a31f96c | 2009-07-14 20:18:05 +0000 | [diff] [blame] | 28 | #include "llvm/Support/FormattedStream.h" |
Chris Lattner | 76d4632 | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 29 | #include "llvm/Support/ManagedStatic.h" |
Reid Spencer | 7c16caa | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 30 | #include "llvm/Support/PluginLoader.h" |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 31 | #include "llvm/Support/PrettyStackTrace.h" |
Dan Gohman | 0df7ea4 | 2010-10-07 20:32:40 +0000 | [diff] [blame] | 32 | #include "llvm/Support/ToolOutputFile.h" |
Michael J. Spencer | 447762d | 2010-11-29 18:16:10 +0000 | [diff] [blame] | 33 | #include "llvm/Support/Host.h" |
| 34 | #include "llvm/Support/Signals.h" |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 35 | #include "llvm/Target/TargetData.h" |
| 36 | #include "llvm/Target/TargetMachine.h" |
| 37 | #include "llvm/Target/TargetRegistry.h" |
Chris Lattner | 5dcc4f6 | 2009-06-17 16:42:19 +0000 | [diff] [blame] | 38 | #include "llvm/Target/TargetSelect.h" |
Reid Spencer | f0ebb25 | 2004-07-04 12:20:55 +0000 | [diff] [blame] | 39 | #include <memory> |
Brian Gaeke | 960707c | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 40 | using namespace llvm; |
| 41 | |
Vikram S. Adve | eb81869 | 2002-09-16 16:35:34 +0000 | [diff] [blame] | 42 | // General options for llc. Other pass-specific options are specified |
| 43 | // within the corresponding llc passes, and target-specific options |
| 44 | // and back-end code generation options are specified with the target machine. |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 45 | // |
Chris Lattner | d64b2de | 2003-04-25 05:26:11 +0000 | [diff] [blame] | 46 | static cl::opt<std::string> |
Gabor Greif | e16561c | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 47 | InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-")); |
Chris Lattner | f5cad15 | 2002-07-22 02:10:13 +0000 | [diff] [blame] | 48 | |
Chris Lattner | d64b2de | 2003-04-25 05:26:11 +0000 | [diff] [blame] | 49 | static cl::opt<std::string> |
Chris Lattner | f5cad15 | 2002-07-22 02:10:13 +0000 | [diff] [blame] | 50 | OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename")); |
| 51 | |
Evan Cheng | 09bd0b1 | 2009-05-04 23:05:19 +0000 | [diff] [blame] | 52 | // Determine optimization level. |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 53 | static cl::opt<char> |
Bill Wendling | 084669a | 2009-04-29 00:15:41 +0000 | [diff] [blame] | 54 | OptLevel("O", |
Evan Cheng | 09bd0b1 | 2009-05-04 23:05:19 +0000 | [diff] [blame] | 55 | cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] " |
| 56 | "(default = '-O2')"), |
Bill Wendling | 084669a | 2009-04-29 00:15:41 +0000 | [diff] [blame] | 57 | cl::Prefix, |
| 58 | cl::ZeroOrMore, |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 59 | cl::init(' ')); |
Chris Lattner | 731055e | 2005-11-08 02:12:17 +0000 | [diff] [blame] | 60 | |
Chris Lattner | e568b88 | 2005-12-16 04:59:57 +0000 | [diff] [blame] | 61 | static cl::opt<std::string> |
Chris Lattner | 08a04cb | 2005-12-16 05:19:55 +0000 | [diff] [blame] | 62 | TargetTriple("mtriple", cl::desc("Override target triple for module")); |
Chris Lattner | 731055e | 2005-11-08 02:12:17 +0000 | [diff] [blame] | 63 | |
Daniel Dunbar | d370645 | 2009-07-16 02:23:53 +0000 | [diff] [blame] | 64 | static cl::opt<std::string> |
| 65 | MArch("march", cl::desc("Architecture to generate code for (see --version)")); |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 66 | |
Jim Laskey | 19058c3 | 2005-09-01 21:38:21 +0000 | [diff] [blame] | 67 | static cl::opt<std::string> |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 68 | MCPU("mcpu", |
Chris Lattner | 0b2bf4c | 2005-10-23 22:35:42 +0000 | [diff] [blame] | 69 | cl::desc("Target a specific cpu type (-mcpu=help for details)"), |
Jim Laskey | 19058c3 | 2005-09-01 21:38:21 +0000 | [diff] [blame] | 70 | cl::value_desc("cpu-name"), |
| 71 | cl::init("")); |
| 72 | |
| 73 | static cl::list<std::string> |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 74 | MAttrs("mattr", |
Jim Laskey | 19058c3 | 2005-09-01 21:38:21 +0000 | [diff] [blame] | 75 | cl::CommaSeparated, |
Chris Lattner | 0b2bf4c | 2005-10-23 22:35:42 +0000 | [diff] [blame] | 76 | cl::desc("Target specific attributes (-mattr=help for details)"), |
Chris Lattner | 4154848 | 2005-10-23 22:37:13 +0000 | [diff] [blame] | 77 | cl::value_desc("a1,+a2,-a3,...")); |
Jim Laskey | 19058c3 | 2005-09-01 21:38:21 +0000 | [diff] [blame] | 78 | |
Evan Cheng | 2129f59 | 2011-07-19 06:37:02 +0000 | [diff] [blame] | 79 | static cl::opt<Reloc::Model> |
| 80 | RelocModel("relocation-model", |
| 81 | cl::desc("Choose relocation model"), |
| 82 | cl::init(Reloc::Default), |
| 83 | cl::values( |
| 84 | clEnumValN(Reloc::Default, "default", |
| 85 | "Target default relocation model"), |
| 86 | clEnumValN(Reloc::Static, "static", |
| 87 | "Non-relocatable code"), |
| 88 | clEnumValN(Reloc::PIC_, "pic", |
| 89 | "Fully relocatable, position independent code"), |
| 90 | clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", |
| 91 | "Relocatable external references, non-relocatable code"), |
| 92 | clEnumValEnd)); |
| 93 | |
Evan Cheng | efd9b42 | 2011-07-20 07:51:56 +0000 | [diff] [blame^] | 94 | static cl::opt<llvm::CodeModel::Model> |
| 95 | CMModel("code-model", |
| 96 | cl::desc("Choose code model"), |
| 97 | cl::init(CodeModel::Default), |
| 98 | cl::values(clEnumValN(CodeModel::Default, "default", |
| 99 | "Target default code model"), |
| 100 | clEnumValN(CodeModel::Small, "small", |
| 101 | "Small code model"), |
| 102 | clEnumValN(CodeModel::Kernel, "kernel", |
| 103 | "Kernel code model"), |
| 104 | clEnumValN(CodeModel::Medium, "medium", |
| 105 | "Medium code model"), |
| 106 | clEnumValN(CodeModel::Large, "large", |
| 107 | "Large code model"), |
| 108 | clEnumValEnd)); |
| 109 | |
Michael J. Spencer | f695f8f | 2010-07-31 19:57:02 +0000 | [diff] [blame] | 110 | static cl::opt<bool> |
Michael J. Spencer | 4f50b97 | 2010-08-06 21:37:45 +0000 | [diff] [blame] | 111 | RelaxAll("mc-relax-all", |
| 112 | cl::desc("When used with filetype=obj, " |
Michael J. Spencer | 4c08958 | 2010-08-08 23:26:49 +0000 | [diff] [blame] | 113 | "relax all fixups in the emitted object file")); |
Michael J. Spencer | f695f8f | 2010-07-31 19:57:02 +0000 | [diff] [blame] | 114 | |
Chris Lattner | 06fcc4c | 2005-06-25 03:32:05 +0000 | [diff] [blame] | 115 | cl::opt<TargetMachine::CodeGenFileType> |
Chris Lattner | f0cb12a | 2010-02-02 21:06:45 +0000 | [diff] [blame] | 116 | FileType("filetype", cl::init(TargetMachine::CGFT_AssemblyFile), |
Chris Lattner | 06fcc4c | 2005-06-25 03:32:05 +0000 | [diff] [blame] | 117 | cl::desc("Choose a file type (not all types are supported by all targets):"), |
| 118 | cl::values( |
Chris Lattner | f0cb12a | 2010-02-02 21:06:45 +0000 | [diff] [blame] | 119 | clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm", |
Dan Gohman | 9c4b7d5 | 2008-10-14 20:25:08 +0000 | [diff] [blame] | 120 | "Emit an assembly ('.s') file"), |
Chris Lattner | f0cb12a | 2010-02-02 21:06:45 +0000 | [diff] [blame] | 121 | clEnumValN(TargetMachine::CGFT_ObjectFile, "obj", |
Dan Gohman | 9c4b7d5 | 2008-10-14 20:25:08 +0000 | [diff] [blame] | 122 | "Emit a native object ('.o') file [experimental]"), |
Chris Lattner | edcf065 | 2010-02-03 05:55:08 +0000 | [diff] [blame] | 123 | clEnumValN(TargetMachine::CGFT_Null, "null", |
| 124 | "Emit nothing, for performance testing"), |
Chris Lattner | 06fcc4c | 2005-06-25 03:32:05 +0000 | [diff] [blame] | 125 | clEnumValEnd)); |
| 126 | |
Reid Spencer | 8e3830d | 2005-07-28 02:25:30 +0000 | [diff] [blame] | 127 | cl::opt<bool> NoVerify("disable-verify", cl::Hidden, |
Jeff Cohen | 546fd59 | 2005-07-30 18:33:25 +0000 | [diff] [blame] | 128 | cl::desc("Do not verify input module")); |
Reid Spencer | 8e3830d | 2005-07-28 02:25:30 +0000 | [diff] [blame] | 129 | |
Devang Patel | 85df0cc | 2010-12-01 15:36:49 +0000 | [diff] [blame] | 130 | cl::opt<bool> DisableDotLoc("disable-dot-loc", cl::Hidden, |
| 131 | cl::desc("Do not use .loc entries")); |
Chris Lattner | 06fcc4c | 2005-06-25 03:32:05 +0000 | [diff] [blame] | 132 | |
Rafael Espindola | a3181d1 | 2011-04-30 03:44:37 +0000 | [diff] [blame] | 133 | cl::opt<bool> DisableCFI("disable-cfi", cl::Hidden, |
| 134 | cl::desc("Do not use .cfi_* directives")); |
| 135 | |
Devang Patel | 72a4d2f | 2009-06-04 22:05:33 +0000 | [diff] [blame] | 136 | static cl::opt<bool> |
| 137 | DisableRedZone("disable-red-zone", |
| 138 | cl::desc("Do not emit code that uses the red zone."), |
| 139 | cl::init(false)); |
| 140 | |
Chris Lattner | 06fcc4c | 2005-06-25 03:32:05 +0000 | [diff] [blame] | 141 | // GetFileNameRoot - Helper function to get the basename of a filename. |
Chris Lattner | d64b2de | 2003-04-25 05:26:11 +0000 | [diff] [blame] | 142 | static inline std::string |
Chris Lattner | 6142ca8 | 2004-07-11 04:03:24 +0000 | [diff] [blame] | 143 | GetFileNameRoot(const std::string &InputFilename) { |
Chris Lattner | d64b2de | 2003-04-25 05:26:11 +0000 | [diff] [blame] | 144 | std::string IFN = InputFilename; |
| 145 | std::string outputFilename; |
Vikram S. Adve | 2f084b2 | 2001-10-14 23:29:28 +0000 | [diff] [blame] | 146 | int Len = IFN.length(); |
John Criswell | a289abf | 2003-08-28 21:42:29 +0000 | [diff] [blame] | 147 | if ((Len > 2) && |
Dan Gohman | e8d0150 | 2009-09-16 19:18:41 +0000 | [diff] [blame] | 148 | IFN[Len-3] == '.' && |
| 149 | ((IFN[Len-2] == 'b' && IFN[Len-1] == 'c') || |
| 150 | (IFN[Len-2] == 'l' && IFN[Len-1] == 'l'))) { |
Chris Lattner | d64b2de | 2003-04-25 05:26:11 +0000 | [diff] [blame] | 151 | outputFilename = std::string(IFN.begin(), IFN.end()-3); // s/.bc/.s/ |
Vikram S. Adve | 2f084b2 | 2001-10-14 23:29:28 +0000 | [diff] [blame] | 152 | } else { |
Chris Lattner | 97fd6c4 | 2001-10-15 17:30:47 +0000 | [diff] [blame] | 153 | outputFilename = IFN; |
Vikram S. Adve | 2f084b2 | 2001-10-14 23:29:28 +0000 | [diff] [blame] | 154 | } |
| 155 | return outputFilename; |
| 156 | } |
| 157 | |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 158 | static tool_output_file *GetOutputStream(const char *TargetName, |
| 159 | Triple::OSType OS, |
| 160 | const char *ProgName) { |
Dan Gohman | 7ba6f22 | 2010-08-18 17:55:15 +0000 | [diff] [blame] | 161 | // If we don't yet have an output filename, make one. |
| 162 | if (OutputFilename.empty()) { |
| 163 | if (InputFilename == "-") |
| 164 | OutputFilename = "-"; |
| 165 | else { |
| 166 | OutputFilename = GetFileNameRoot(InputFilename); |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 167 | |
Dan Gohman | 7ba6f22 | 2010-08-18 17:55:15 +0000 | [diff] [blame] | 168 | switch (FileType) { |
| 169 | default: assert(0 && "Unknown file type"); |
| 170 | case TargetMachine::CGFT_AssemblyFile: |
| 171 | if (TargetName[0] == 'c') { |
| 172 | if (TargetName[1] == 0) |
| 173 | OutputFilename += ".cbe.c"; |
| 174 | else if (TargetName[1] == 'p' && TargetName[2] == 'p') |
| 175 | OutputFilename += ".cpp"; |
| 176 | else |
| 177 | OutputFilename += ".s"; |
| 178 | } else |
| 179 | OutputFilename += ".s"; |
| 180 | break; |
| 181 | case TargetMachine::CGFT_ObjectFile: |
| 182 | if (OS == Triple::Win32) |
| 183 | OutputFilename += ".obj"; |
| 184 | else |
| 185 | OutputFilename += ".o"; |
| 186 | break; |
| 187 | case TargetMachine::CGFT_Null: |
| 188 | OutputFilename += ".null"; |
| 189 | break; |
| 190 | } |
Dan Gohman | f3e13bb | 2008-08-21 15:33:45 +0000 | [diff] [blame] | 191 | } |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 192 | } |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 193 | |
Dan Gohman | 7ba6f22 | 2010-08-18 17:55:15 +0000 | [diff] [blame] | 194 | // Decide if we need "binary" output. |
Daniel Dunbar | ed90e70 | 2008-11-13 05:01:07 +0000 | [diff] [blame] | 195 | bool Binary = false; |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 196 | switch (FileType) { |
Chris Lattner | f0cb12a | 2010-02-02 21:06:45 +0000 | [diff] [blame] | 197 | default: assert(0 && "Unknown file type"); |
| 198 | case TargetMachine::CGFT_AssemblyFile: |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 199 | break; |
Chris Lattner | f0cb12a | 2010-02-02 21:06:45 +0000 | [diff] [blame] | 200 | case TargetMachine::CGFT_ObjectFile: |
Chris Lattner | edcf065 | 2010-02-03 05:55:08 +0000 | [diff] [blame] | 201 | case TargetMachine::CGFT_Null: |
Daniel Dunbar | ed90e70 | 2008-11-13 05:01:07 +0000 | [diff] [blame] | 202 | Binary = true; |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 203 | break; |
| 204 | } |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 205 | |
Dan Gohman | 7ba6f22 | 2010-08-18 17:55:15 +0000 | [diff] [blame] | 206 | // Open the file. |
Owen Anderson | 9371964 | 2008-08-21 00:14:44 +0000 | [diff] [blame] | 207 | std::string error; |
Chris Lattner | 9e6f1f1 | 2009-08-23 02:51:22 +0000 | [diff] [blame] | 208 | unsigned OpenFlags = 0; |
Chris Lattner | 9e6f1f1 | 2009-08-23 02:51:22 +0000 | [diff] [blame] | 209 | if (Binary) OpenFlags |= raw_fd_ostream::F_Binary; |
Dan Gohman | 268b0f4 | 2010-08-20 01:07:01 +0000 | [diff] [blame] | 210 | tool_output_file *FDOut = new tool_output_file(OutputFilename.c_str(), error, |
| 211 | OpenFlags); |
Owen Anderson | 9371964 | 2008-08-21 00:14:44 +0000 | [diff] [blame] | 212 | if (!error.empty()) { |
Dan Gohman | d8db376 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 213 | errs() << error << '\n'; |
Dan Gohman | 607818a | 2009-07-15 17:29:42 +0000 | [diff] [blame] | 214 | delete FDOut; |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 215 | return 0; |
| 216 | } |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 217 | |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 218 | return FDOut; |
Chris Lattner | 12e9730 | 2006-09-04 04:14:57 +0000 | [diff] [blame] | 219 | } |
Vikram S. Adve | 9d40935 | 2001-09-18 13:10:45 +0000 | [diff] [blame] | 220 | |
Chris Lattner | 67e0842 | 2003-06-20 15:49:04 +0000 | [diff] [blame] | 221 | // main - Entry point for the llc compiler. |
| 222 | // |
| 223 | int main(int argc, char **argv) { |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 224 | sys::PrintStackTraceOnErrorSignal(); |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 225 | PrettyStackTraceProgram X(argc, argv); |
David Greene | 6e55be6 | 2010-01-05 01:30:21 +0000 | [diff] [blame] | 226 | |
| 227 | // Enable debug stream buffering. |
| 228 | EnableDebugBuffering = true; |
| 229 | |
Owen Anderson | 19251ec | 2009-07-15 22:16:10 +0000 | [diff] [blame] | 230 | LLVMContext &Context = getGlobalContext(); |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 231 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
Chris Lattner | 69e896b | 2004-02-19 20:32:39 +0000 | [diff] [blame] | 232 | |
Daniel Dunbar | 76628de | 2009-09-03 05:47:22 +0000 | [diff] [blame] | 233 | // Initialize targets first, so that --version shows registered targets. |
Chris Lattner | 5dcc4f6 | 2009-06-17 16:42:19 +0000 | [diff] [blame] | 234 | InitializeAllTargets(); |
Evan Cheng | 1705ab0 | 2011-07-14 23:50:31 +0000 | [diff] [blame] | 235 | InitializeAllMCAsmInfos(); |
Evan Cheng | 2129f59 | 2011-07-19 06:37:02 +0000 | [diff] [blame] | 236 | InitializeAllMCCodeGenInfos(); |
Evan Cheng | 91111d2 | 2011-07-09 05:47:46 +0000 | [diff] [blame] | 237 | InitializeAllMCSubtargetInfos(); |
Chris Lattner | 5dcc4f6 | 2009-06-17 16:42:19 +0000 | [diff] [blame] | 238 | InitializeAllAsmPrinters(); |
Chris Lattner | 8900ef1 | 2010-04-05 23:11:24 +0000 | [diff] [blame] | 239 | InitializeAllAsmParsers(); |
Daniel Dunbar | 3d92d93 | 2009-07-16 02:04:54 +0000 | [diff] [blame] | 240 | |
| 241 | cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n"); |
Andrew Trick | b826ae8 | 2011-04-05 18:41:31 +0000 | [diff] [blame] | 242 | |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 243 | // Load the module to be compiled... |
Dan Gohman | c76bfb7 | 2009-09-02 19:35:19 +0000 | [diff] [blame] | 244 | SMDiagnostic Err; |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 245 | std::auto_ptr<Module> M; |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 246 | |
Dan Gohman | c76bfb7 | 2009-09-02 19:35:19 +0000 | [diff] [blame] | 247 | M.reset(ParseIRFile(InputFilename, Err, Context)); |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 248 | if (M.get() == 0) { |
Dan Gohman | c76bfb7 | 2009-09-02 19:35:19 +0000 | [diff] [blame] | 249 | Err.Print(argv[0], errs()); |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 250 | return 1; |
| 251 | } |
| 252 | Module &mod = *M.get(); |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 253 | |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 254 | // If we are supposed to override the target triple, do so now. |
| 255 | if (!TargetTriple.empty()) |
Duncan Sands | 3bd97fe | 2010-08-28 01:30:02 +0000 | [diff] [blame] | 256 | mod.setTargetTriple(Triple::normalize(TargetTriple)); |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 257 | |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 258 | Triple TheTriple(mod.getTargetTriple()); |
| 259 | if (TheTriple.getTriple().empty()) |
| 260 | TheTriple.setTriple(sys::getHostTriple()); |
| 261 | |
| 262 | // Allocate target machine. First, check whether the user has explicitly |
| 263 | // specified an architecture to compile for. If so we have to look it up by |
| 264 | // name, because it might be a backend that has no mapping to a target triple. |
Daniel Dunbar | d370645 | 2009-07-16 02:23:53 +0000 | [diff] [blame] | 265 | const Target *TheTarget = 0; |
| 266 | if (!MArch.empty()) { |
| 267 | for (TargetRegistry::iterator it = TargetRegistry::begin(), |
| 268 | ie = TargetRegistry::end(); it != ie; ++it) { |
| 269 | if (MArch == it->getName()) { |
| 270 | TheTarget = &*it; |
| 271 | break; |
| 272 | } |
| 273 | } |
| 274 | |
| 275 | if (!TheTarget) { |
| 276 | errs() << argv[0] << ": error: invalid target '" << MArch << "'.\n"; |
| 277 | return 1; |
Daniel Dunbar | 0f16ea5 | 2009-08-03 04:03:51 +0000 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | // Adjust the triple to match (if known), otherwise stick with the |
| 281 | // module/host triple. |
| 282 | Triple::ArchType Type = Triple::getArchTypeForLLVMName(MArch); |
| 283 | if (Type != Triple::UnknownArch) |
| 284 | TheTriple.setArch(Type); |
Daniel Dunbar | e833810 | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 285 | } else { |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 286 | std::string Err; |
Daniel Dunbar | 719d235 | 2009-08-03 04:20:57 +0000 | [diff] [blame] | 287 | TheTarget = TargetRegistry::lookupTarget(TheTriple.getTriple(), Err); |
Daniel Dunbar | e833810 | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 288 | if (TheTarget == 0) { |
Dan Gohman | d8db376 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 289 | errs() << argv[0] << ": error auto-selecting target for module '" |
| 290 | << Err << "'. Please use the -march option to explicitly " |
| 291 | << "pick a target.\n"; |
Chris Lattner | b149240 | 2003-08-24 14:02:14 +0000 | [diff] [blame] | 292 | return 1; |
Chris Lattner | 6142ca8 | 2004-07-11 04:03:24 +0000 | [diff] [blame] | 293 | } |
Chris Lattner | 5667f0e | 2002-10-29 21:12:46 +0000 | [diff] [blame] | 294 | } |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 295 | |
| 296 | // Package up features to be passed to target/subtarget |
| 297 | std::string FeaturesStr; |
Evan Cheng | fe6e405 | 2011-06-30 01:53:36 +0000 | [diff] [blame] | 298 | if (MAttrs.size()) { |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 299 | SubtargetFeatures Features; |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 300 | for (unsigned i = 0; i != MAttrs.size(); ++i) |
| 301 | Features.AddFeature(MAttrs[i]); |
| 302 | FeaturesStr = Features.getString(); |
| 303 | } |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 304 | |
Andrew Trick | b826ae8 | 2011-04-05 18:41:31 +0000 | [diff] [blame] | 305 | std::auto_ptr<TargetMachine> |
Evan Cheng | efd9b42 | 2011-07-20 07:51:56 +0000 | [diff] [blame^] | 306 | target(TheTarget->createTargetMachine(TheTriple.getTriple(), |
| 307 | MCPU, FeaturesStr, |
| 308 | RelocModel, CMModel)); |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 309 | assert(target.get() && "Could not allocate target machine!"); |
| 310 | TargetMachine &Target = *target.get(); |
| 311 | |
Devang Patel | 85df0cc | 2010-12-01 15:36:49 +0000 | [diff] [blame] | 312 | if (DisableDotLoc) |
| 313 | Target.setMCUseLoc(false); |
Daniel Dunbar | ed3d549 | 2011-04-19 20:46:13 +0000 | [diff] [blame] | 314 | |
Rafael Espindola | a3181d1 | 2011-04-30 03:44:37 +0000 | [diff] [blame] | 315 | if (DisableCFI) |
| 316 | Target.setMCUseCFI(false); |
| 317 | |
Daniel Dunbar | ed3d549 | 2011-04-19 20:46:13 +0000 | [diff] [blame] | 318 | // Disable .loc support for older OS X versions. |
Daniel Dunbar | cd01ed5 | 2011-04-20 00:14:25 +0000 | [diff] [blame] | 319 | if (TheTriple.isMacOSX() && |
Daniel Dunbar | c7f2f14 | 2011-04-20 00:47:19 +0000 | [diff] [blame] | 320 | TheTriple.isMacOSXVersionLT(10, 6)) |
Daniel Dunbar | ed3d549 | 2011-04-19 20:46:13 +0000 | [diff] [blame] | 321 | Target.setMCUseLoc(false); |
Devang Patel | 85df0cc | 2010-12-01 15:36:49 +0000 | [diff] [blame] | 322 | |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 323 | // Figure out where we are going to send the output... |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 324 | OwningPtr<tool_output_file> Out |
Dan Gohman | 268b0f4 | 2010-08-20 01:07:01 +0000 | [diff] [blame] | 325 | (GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0])); |
| 326 | if (!Out) return 1; |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 327 | |
Evan Cheng | 09bd0b1 | 2009-05-04 23:05:19 +0000 | [diff] [blame] | 328 | CodeGenOpt::Level OLvl = CodeGenOpt::Default; |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 329 | switch (OptLevel) { |
| 330 | default: |
Dan Gohman | d8db376 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 331 | errs() << argv[0] << ": invalid optimization level.\n"; |
Bill Wendling | dad9919 | 2009-04-29 23:46:43 +0000 | [diff] [blame] | 332 | return 1; |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 333 | case ' ': break; |
| 334 | case '0': OLvl = CodeGenOpt::None; break; |
Evan Cheng | 5a28638 | 2009-10-16 21:02:20 +0000 | [diff] [blame] | 335 | case '1': OLvl = CodeGenOpt::Less; break; |
Bill Wendling | aeaf5a5 | 2009-04-30 00:57:51 +0000 | [diff] [blame] | 336 | case '2': OLvl = CodeGenOpt::Default; break; |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 337 | case '3': OLvl = CodeGenOpt::Aggressive; break; |
Bill Wendling | 026e5d7 | 2009-04-29 23:29:43 +0000 | [diff] [blame] | 338 | } |
| 339 | |
Dan Gohman | 4cfccb8 | 2010-05-11 19:57:55 +0000 | [diff] [blame] | 340 | // Build up all of the passes that we want to do to the module. |
| 341 | PassManager PM; |
Daniel Dunbar | c0deed3 | 2009-08-03 17:34:19 +0000 | [diff] [blame] | 342 | |
Dan Gohman | 4cfccb8 | 2010-05-11 19:57:55 +0000 | [diff] [blame] | 343 | // Add the target data from the target machine, if it exists, or the module. |
| 344 | if (const TargetData *TD = Target.getTargetData()) |
| 345 | PM.add(new TargetData(*TD)); |
| 346 | else |
| 347 | PM.add(new TargetData(&mod)); |
Daniel Dunbar | c0deed3 | 2009-08-03 17:34:19 +0000 | [diff] [blame] | 348 | |
Dan Gohman | 4cfccb8 | 2010-05-11 19:57:55 +0000 | [diff] [blame] | 349 | // Override default to generate verbose assembly. |
| 350 | Target.setAsmVerbosityDefault(true); |
Daniel Dunbar | c0deed3 | 2009-08-03 17:34:19 +0000 | [diff] [blame] | 351 | |
Michael J. Spencer | f695f8f | 2010-07-31 19:57:02 +0000 | [diff] [blame] | 352 | if (RelaxAll) { |
| 353 | if (FileType != TargetMachine::CGFT_ObjectFile) |
| 354 | errs() << argv[0] |
| 355 | << ": warning: ignoring -mc-relax-all because filetype != obj"; |
| 356 | else |
| 357 | Target.setMCRelaxAll(true); |
| 358 | } |
| 359 | |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 360 | { |
| 361 | formatted_raw_ostream FOS(Out->os()); |
Mikhail Glushenkov | b2f9a73 | 2009-01-16 06:53:46 +0000 | [diff] [blame] | 362 | |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 363 | // Ask the target to add backend passes as necessary. |
| 364 | if (Target.addPassesToEmitFile(PM, FOS, FileType, OLvl, NoVerify)) { |
| 365 | errs() << argv[0] << ": target does not support generation of this" |
| 366 | << " file type!\n"; |
| 367 | return 1; |
| 368 | } |
| 369 | |
Andrew Trick | 1200401 | 2011-04-05 18:54:36 +0000 | [diff] [blame] | 370 | // Before executing passes, print the final values of the LLVM options. |
| 371 | cl::PrintOptionValues(); |
| 372 | |
Dan Gohman | a2233f2 | 2010-09-01 14:20:41 +0000 | [diff] [blame] | 373 | PM.run(mod); |
| 374 | } |
Dan Gohman | 4cfccb8 | 2010-05-11 19:57:55 +0000 | [diff] [blame] | 375 | |
Dan Gohman | 268b0f4 | 2010-08-20 01:07:01 +0000 | [diff] [blame] | 376 | // Declare success. |
| 377 | Out->keep(); |
Chris Lattner | 6dd290a | 2007-05-06 04:55:19 +0000 | [diff] [blame] | 378 | |
| 379 | return 0; |
Vikram S. Adve | 2f084b2 | 2001-10-14 23:29:28 +0000 | [diff] [blame] | 380 | } |