Change llc command line for register allocators

[oota-llvm.git] / lib / Target / X86 / X86TargetMachine.cpp

diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp
index e316abc5221e301f2fc2b075b756b0d9d49ac00b..8f6829f6de4ad49341048714df9e58e013257e98 100644 (file)
--- a/lib/Target/X86/X86TargetMachine.cpp
+++ b/lib/Target/X86/X86TargetMachine.cpp
@@ -5,47 +5,153 @@
 //===----------------------------------------------------------------------===//
 
 #include "X86TargetMachine.h"
+#include "X86.h"
+#include "llvm/Module.h"
+#include "llvm/PassManager.h"
 #include "llvm/Target/TargetMachineImpls.h"
 #include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/PassManager.h"
-#include "X86.h"
-#include <iostream>
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/Transforms/Scalar.h"
+#include "Support/CommandLine.h"
+#include "Support/Statistic.h"
+
+namespace {
+  cl::opt<RegAllocName>
+  RegAlloc("regalloc",
+           cl::desc("Register allocator to use: (default = simple)"),
+           cl::Prefix,
+           cl::values(clEnumVal(simple, "  simple register allocator"),
+                      clEnumVal(local,  "  local register allocator"),
+                      0),
+           cl::init(local));
+
+  cl::opt<bool> PrintCode("print-machineinstrs",
+                         cl::desc("Print generated machine code"));
+  cl::opt<bool> NoPatternISel("disable-pattern-isel", cl::init(true),
+                        cl::desc("Use the 'simple' X86 instruction selector"));
+}
 
 // allocateX86TargetMachine - Allocate and return a subclass of TargetMachine
 // that implements the X86 backend.
 //
-TargetMachine *allocateX86TargetMachine() { return new X86TargetMachine(); }
+TargetMachine *allocateX86TargetMachine(const Module &M) {
+  return new X86TargetMachine(M);
+}
 
 
 /// X86TargetMachine ctor - Create an ILP32 architecture model
 ///
-X86TargetMachine::X86TargetMachine() : TargetMachine("X86", 1, 4, 4, 4) {
+X86TargetMachine::X86TargetMachine(const Module &M)
+  : TargetMachine("X86", 
+                 M.getEndianness() != Module::BigEndian,
+                  M.getPointerSize() != Module::Pointer64 ? 4 : 8,
+                  M.getPointerSize() != Module::Pointer64 ? 4 : 8,
+                  M.getPointerSize() != Module::Pointer64 ? 4 : 8,
+                  4, M.getPointerSize() != Module::Pointer64 ? 4 : 8),
+    FrameInfo(TargetFrameInfo::StackGrowsDown, 8/*16 for SSE*/, 4) {
 }
 
 
+// addPassesToEmitAssembly - We currently use all of the same passes as the JIT
+// does to emit statically compiled machine code.
+bool X86TargetMachine::addPassesToEmitAssembly(PassManager &PM,
+                                              std::ostream &Out) {
+  // FIXME: Implement the switch instruction in the instruction selector!
+  PM.add(createLowerSwitchPass());
+
+  if (NoPatternISel)
+    PM.add(createX86SimpleInstructionSelector(*this));
+  else
+    PM.add(createX86PatternInstructionSelector(*this));
+
+  // TODO: optional optimizations go here
+
+  // FIXME: Add SSA based peephole optimizer here.
+
+  // Print the instruction selected machine code...
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
+
+  // Perform register allocation to convert to a concrete x86 representation
+  switch (RegAlloc) {
+  case simple:
+    PM.add(createSimpleRegisterAllocator());
+    break;
+  case local:
+    PM.add(createLocalRegisterAllocator());
+    break;
+  default:
+    assert(0 && "no register allocator selected");
+  }
+
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
+
+  PM.add(createX86FloatingPointStackifierPass());
+
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
+
+  // Insert prolog/epilog code.  Eliminate abstract frame index references...
+  PM.add(createPrologEpilogCodeInserter());
+
+  PM.add(createX86PeepholeOptimizerPass());
+
+  if (PrintCode)  // Print the register-allocated code
+    PM.add(createX86CodePrinterPass(std::cerr, *this));
+
+  PM.add(createX86CodePrinterPass(Out, *this));
+  return false; // success!
+}
+
 /// addPassesToJITCompile - Add passes to the specified pass manager to
 /// implement a fast dynamic compiler for this target.  Return true if this is
 /// not supported for this target.
 ///
-bool X86TargetMachine::addPassesToJITCompile(PassManager &PM) {
-  PM.add(createSimpleX86InstructionSelector(*this));
+bool X86TargetMachine::addPassesToJITCompile(FunctionPassManager &PM) {
+  // FIXME: Implement the switch instruction in the instruction selector!
+  PM.add(createLowerSwitchPass());
+
+  if (NoPatternISel)
+    PM.add(createX86SimpleInstructionSelector(*this));
+  else
+    PM.add(createX86PatternInstructionSelector(*this));
 
   // TODO: optional optimizations go here
 
+  // FIXME: Add SSA based peephole optimizer here.
+
   // Print the instruction selected machine code...
-  PM.add(createMachineFunctionPrinterPass());
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
 
   // Perform register allocation to convert to a concrete x86 representation
-  PM.add(createSimpleX86RegisterAllocator(*this));
+  switch (RegAlloc) {
+  case simple:
+    PM.add(createSimpleRegisterAllocator());
+    break;
+  case local:
+    PM.add(createLocalRegisterAllocator());
+    break;
+  default:
+    assert(0 && "no register allocator selected");
+  }
 
-  // Print the instruction selected machine code...
-  // PM.add(createMachineFunctionPrinterPass());
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
+
+  PM.add(createX86FloatingPointStackifierPass());
+
+  if (PrintCode)
+    PM.add(createMachineFunctionPrinterPass());
 
-  // Print the register-allocated code
-  PM.add(createX86CodePrinterPass(*this, std::cerr));
+  // Insert prolog/epilog code.  Eliminate abstract frame index references...
+  PM.add(createPrologEpilogCodeInserter());
 
-  //PM.add(createEmitX86CodeToMemory(*this));
+  PM.add(createX86PeepholeOptimizerPass());
 
+  if (PrintCode)  // Print the register-allocated code
+    PM.add(createX86CodePrinterPass(std::cerr, *this));
   return false; // success!
 }