blob: f219b6ea16116e783e05d9b9263586d108a5ebfb [file] [log] [blame]
Chris Lattner5b836c42003-06-20 15:49:04 +00001//===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
John Criswell7c0e0222003-10-20 17:47:21 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
Chris Lattnere737c7a2001-09-07 22:20:50 +00009//
Chris Lattner5b836c42003-06-20 15:49:04 +000010// This is the llc code generator.
Chris Lattnere737c7a2001-09-07 22:20:50 +000011//
Chris Lattnerb79757c2001-10-04 01:40:53 +000012//===----------------------------------------------------------------------===//
Vikram S. Advecb465fc2001-07-21 12:42:29 +000013
Vikram S. Advecb465fc2001-07-21 12:42:29 +000014#include "llvm/Bytecode/Reader.h"
Chris Lattner4aba5e32002-10-29 20:45:04 +000015#include "llvm/Target/TargetMachineImpls.h"
Vikram S. Adve805eb962001-09-18 13:10:45 +000016#include "llvm/Target/TargetMachine.h"
Chris Lattner65f1b892002-05-07 20:03:27 +000017#include "llvm/Transforms/Scalar.h"
Chris Lattner46ac43c2001-09-07 21:26:31 +000018#include "llvm/Module.h"
Chris Lattnercd50d3f2002-01-31 00:46:45 +000019#include "llvm/PassManager.h"
Vikram S. Adve7d0ba022002-09-16 16:35:34 +000020#include "llvm/Pass.h"
Chris Lattnercee8f9a2001-11-27 00:03:19 +000021#include "Support/CommandLine.h"
Chris Lattner76d12292002-04-18 19:55:25 +000022#include "Support/Signals.h"
Chris Lattnerda784ee2001-09-18 17:04:18 +000023#include <memory>
Chris Lattner78f7e1a2001-09-19 16:52:09 +000024#include <fstream>
Vikram S. Adve7d0ba022002-09-16 16:35:34 +000025
Brian Gaeked0fde302003-11-11 22:41:34 +000026using namespace llvm;
27
Vikram S. Adve7d0ba022002-09-16 16:35:34 +000028// General options for llc. Other pass-specific options are specified
29// within the corresponding llc passes, and target-specific options
30// and back-end code generation options are specified with the target machine.
31//
Chris Lattnerb5881f12003-04-25 05:26:11 +000032static cl::opt<std::string>
Chris Lattner5ff62e92002-07-22 02:10:13 +000033InputFilename(cl::Positional, cl::desc("<input bytecode>"), cl::init("-"));
34
Chris Lattnerb5881f12003-04-25 05:26:11 +000035static cl::opt<std::string>
Chris Lattner5ff62e92002-07-22 02:10:13 +000036OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
37
38static cl::opt<bool> Force("f", cl::desc("Overwrite output files"));
39
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000040enum ArchName { noarch, x86, Sparc };
Chris Lattner68492722003-04-28 03:28:56 +000041
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000042static cl::opt<ArchName>
43Arch("march", cl::desc("Architecture to generate assembly for:"), cl::Prefix,
44 cl::values(clEnumVal(x86, " IA-32 (Pentium and above)"),
Misha Brukman29abc972003-07-07 22:28:42 +000045 clEnumValN(Sparc, "sparc", " SPARC V9"),
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000046 0),
Misha Brukman5d5bc7b2003-07-30 15:29:55 +000047 cl::init(noarch));
Chris Lattner5ff62e92002-07-22 02:10:13 +000048
Chris Lattner3524fc22001-10-15 17:30:47 +000049// GetFileNameRoot - Helper function to get the basename of a filename...
Chris Lattnerb5881f12003-04-25 05:26:11 +000050static inline std::string
51GetFileNameRoot(const std::string &InputFilename)
Vikram S. Adve7d0ba022002-09-16 16:35:34 +000052{
Chris Lattnerb5881f12003-04-25 05:26:11 +000053 std::string IFN = InputFilename;
54 std::string outputFilename;
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +000055 int Len = IFN.length();
John Criswellb5d09bf2003-08-28 21:42:29 +000056 if ((Len > 2) &&
57 IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') {
Chris Lattnerb5881f12003-04-25 05:26:11 +000058 outputFilename = std::string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +000059 } else {
Chris Lattner3524fc22001-10-15 17:30:47 +000060 outputFilename = IFN;
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +000061 }
62 return outputFilename;
63}
64
Vikram S. Adve805eb962001-09-18 13:10:45 +000065
Chris Lattner5b836c42003-06-20 15:49:04 +000066// main - Entry point for the llc compiler.
67//
68int main(int argc, char **argv) {
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +000069 cl::ParseCommandLineOptions(argc, argv, " llvm system compiler\n");
70
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +000071 // Load the module to be compiled...
Chris Lattner697954c2002-01-20 22:54:45 +000072 std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
Chris Lattner5b836c42003-06-20 15:49:04 +000073 if (M.get() == 0) {
74 std::cerr << argv[0] << ": bytecode didn't read correctly.\n";
75 return 1;
76 }
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000077 Module &mod = *M.get();
78
79 // Allocate target machine. First, check whether the user has
80 // explicitly specified an architecture to compile for.
Chris Lattner62c720a2003-08-24 19:50:12 +000081 TargetMachine* (*TargetMachineAllocator)(const Module&) = 0;
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000082 switch (Arch) {
83 case x86:
84 TargetMachineAllocator = allocateX86TargetMachine;
85 break;
86 case Sparc:
87 TargetMachineAllocator = allocateSparcTargetMachine;
88 break;
89 default:
90 // Decide what the default target machine should be, by looking at
91 // the module. This heuristic (ILP32, LE -> IA32; LP64, BE ->
92 // SPARCV9) is kind of gross, but it will work until we have more
93 // sophisticated target information to work from.
Chris Lattnerbb433502003-08-24 14:02:14 +000094 if (mod.getEndianness() == Module::LittleEndian &&
95 mod.getPointerSize() == Module::Pointer32) {
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000096 TargetMachineAllocator = allocateX86TargetMachine;
Chris Lattnerbb433502003-08-24 14:02:14 +000097 } else if (mod.getEndianness() == Module::BigEndian &&
98 mod.getPointerSize() == Module::Pointer64) {
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +000099 TargetMachineAllocator = allocateSparcTargetMachine;
100 } else {
Chris Lattnerbb433502003-08-24 14:02:14 +0000101 // If the module is target independent, favor a target which matches the
102 // current build system.
103#if defined(i386) || defined(__i386__) || defined(__x86__)
104 TargetMachineAllocator = allocateX86TargetMachine;
105#elif defined(sparc) || defined(__sparc__) || defined(__sparcv9)
106 TargetMachineAllocator = allocateSparcTargetMachine;
107#else
108 std::cerr << argv[0] << ": module does not specify a target to use. "
109 << "You must use the -march option.\n";
110 return 1;
111#endif
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +0000112 }
113 break;
114 }
Chris Lattner62c720a2003-08-24 19:50:12 +0000115 std::auto_ptr<TargetMachine> target(TargetMachineAllocator(mod));
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +0000116 assert(target.get() && "Could not allocate target machine!");
117 TargetMachine &Target = *target.get();
118 const TargetData &TD = Target.getTargetData();
Chris Lattner39fd6592002-05-20 21:20:08 +0000119
Chris Lattner3524fc22001-10-15 17:30:47 +0000120 // Build up all of the passes that we want to do to the module...
Chris Lattnerf4de63f2002-01-21 07:31:50 +0000121 PassManager Passes;
Chris Lattner3524fc22001-10-15 17:30:47 +0000122
Chris Lattner10daaa12003-04-26 20:11:09 +0000123 Passes.add(new TargetData("llc", TD.isLittleEndian(), TD.getPointerSize(),
Chris Lattnerbc194662003-04-25 06:06:13 +0000124 TD.getPointerAlignment(), TD.getDoubleAlignment()));
Chris Lattner2b5f2c12003-04-25 05:22:29 +0000125
Chris Lattnere41576d2002-02-03 23:43:19 +0000126 // Figure out where we are going to send the output...
127 std::ostream *Out = 0;
Chris Lattnercccc28c2003-06-18 18:46:08 +0000128 if (OutputFilename != "") {
Brian Gaeke5ce1a582003-06-18 21:43:33 +0000129 if (OutputFilename != "-") {
130 // Specified an output filename?
131 if (!Force && std::ifstream(OutputFilename.c_str())) {
132 // If force is not specified, make sure not to overwrite a file!
133 std::cerr << argv[0] << ": error opening '" << OutputFilename
134 << "': file exists!\n"
135 << "Use -f command line argument to force output\n";
136 return 1;
137 }
138 Out = new std::ofstream(OutputFilename.c_str());
Chris Lattnercccc28c2003-06-18 18:46:08 +0000139
Misha Brukman452fea92003-10-10 17:56:49 +0000140 // Make sure that the Out file gets unlinked from the disk if we get a
Brian Gaeke5ce1a582003-06-18 21:43:33 +0000141 // SIGINT
142 RemoveFileOnSignal(OutputFilename);
143 } else {
144 Out = &std::cout;
145 }
Chris Lattnercccc28c2003-06-18 18:46:08 +0000146 } else {
147 if (InputFilename == "-") {
148 OutputFilename = "-";
149 Out = &std::cout;
150 } else {
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +0000151 OutputFilename = GetFileNameRoot(InputFilename);
Chris Lattnercccc28c2003-06-18 18:46:08 +0000152 OutputFilename += ".s";
153
Chris Lattner888912d2002-01-22 21:07:24 +0000154 if (!Force && std::ifstream(OutputFilename.c_str())) {
Chris Lattner697954c2002-01-20 22:54:45 +0000155 // If force is not specified, make sure not to overwrite a file!
Chris Lattnerb5881f12003-04-25 05:26:11 +0000156 std::cerr << argv[0] << ": error opening '" << OutputFilename
157 << "': file exists!\n"
158 << "Use -f command line argument to force output\n";
Chris Lattner697954c2002-01-20 22:54:45 +0000159 return 1;
160 }
Chris Lattnercccc28c2003-06-18 18:46:08 +0000161
Chris Lattner697954c2002-01-20 22:54:45 +0000162 Out = new std::ofstream(OutputFilename.c_str());
Chris Lattnercccc28c2003-06-18 18:46:08 +0000163 if (!Out->good()) {
164 std::cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
165 delete Out;
166 return 1;
167 }
168
Misha Brukman452fea92003-10-10 17:56:49 +0000169 // Make sure that the Out file gets unlinked from the disk if we get a
Chris Lattner0f82df42002-09-19 16:06:28 +0000170 // SIGINT
Chris Lattner76d12292002-04-18 19:55:25 +0000171 RemoveFileOnSignal(OutputFilename);
Chris Lattner3524fc22001-10-15 17:30:47 +0000172 }
Chris Lattnercccc28c2003-06-18 18:46:08 +0000173 }
Vikram S. Adve7d0ba022002-09-16 16:35:34 +0000174
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +0000175 // Ask the target to add backend passes as necessary
Chris Lattner63342052002-10-29 21:12:46 +0000176 if (Target.addPassesToEmitAssembly(Passes, *Out)) {
Chris Lattnerb5881f12003-04-25 05:26:11 +0000177 std::cerr << argv[0] << ": target '" << Target.getName()
Brian Gaeke2e2f2dc2003-06-18 21:14:23 +0000178 << "' does not support static compilation!\n";
179 if (Out != &std::cout) delete Out;
180 // And the Out file is empty and useless, so remove it now.
181 std::remove(OutputFilename.c_str());
182 return 1;
Chris Lattner63342052002-10-29 21:12:46 +0000183 } else {
184 // Run our queue of passes all at once now, efficiently.
185 Passes.run(*M.get());
186 }
Chris Lattner05e5e072001-10-18 01:31:22 +0000187
Chris Lattner0f82df42002-09-19 16:06:28 +0000188 // Delete the ostream if it's not a stdout stream
Chris Lattnere41576d2002-02-03 23:43:19 +0000189 if (Out != &std::cout) delete Out;
190
Chris Lattnerd7477ee2001-10-18 20:33:21 +0000191 return 0;
Vikram S. Adve2f64f9f2001-10-14 23:29:28 +0000192}