Add some basic checks of CallInst's.

[oota-llvm.git] / tools / gccas / gccas.cpp

diff --git a/tools/gccas/gccas.cpp b/tools/gccas/gccas.cpp
index ae0320c27163554b45def4b371af92ade29d3b8a..02d7cfe827f8904f8bf3019d186960d1a419f0a3 100644 (file)
--- a/tools/gccas/gccas.cpp
+++ b/tools/gccas/gccas.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Module.h"
+#include "llvm/PassManager.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Transforms/CleanupGCCOutput.h"
 #include "llvm/Transforms/LevelChange.h"
@@ -16,8 +17,10 @@
 #include "llvm/Transforms/Scalar/DCE.h"
 #include "llvm/Transforms/Scalar/IndVarSimplify.h"
 #include "llvm/Transforms/Scalar/InstructionCombining.h"
+#include "llvm/Transforms/Scalar/PromoteMemoryToRegister.h"
 #include "llvm/Bytecode/WriteBytecodePass.h"
 #include "Support/CommandLine.h"
+#include "Support/Signals.h"
 #include <memory>
 #include <fstream>
 #include <string>
@@ -25,6 +28,8 @@
 cl::String InputFilename ("", "Parse <arg> file, compile to bytecode",
                           cl::Required, "");
 cl::String OutputFilename("o", "Override output filename", cl::NoFlags, "");
+cl::Flag   StopAtLevelRaise("stopraise", "Stop optimization before level raise",
+                            cl::Hidden);
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm .s -> .o assembler for GCC\n");
@@ -60,19 +65,26 @@ int main(int argc, char **argv) {
     return 1;
   }
 
+  // Make sure that the Out file gets unlink'd from the disk if we get a SIGINT
+  RemoveFileOnSignal(OutputFilename);
+
   // In addition to just parsing the input from GCC, we also want to spiff it up
   // a little bit.  Do this now.
   //
   PassManager Passes;
-  Passes.add(new DeadCodeElimination());       // Remove Dead code/vars
-  Passes.add(new RaiseAllocations());          // call %malloc -> malloc inst
-  Passes.add(new CleanupGCCOutput());          // Fix gccisms
-  Passes.add(new InductionVariableSimplify()); // Simplify indvars
-  Passes.add(new RaisePointerReferences());    // Eliminate casts
-  Passes.add(new ConstantMerge());             // Merge dup global consts
-  Passes.add(new InstructionCombining());      // Combine silly seq's
-  Passes.add(new DeadCodeElimination());       // Remove Dead code/vars
-  Passes.add(new WriteBytecodePass(&Out));     // Write bytecode to file...
+  Passes.add(createFunctionResolvingPass());      // Resolve (...) functions
+  Passes.add(createDeadInstEliminationPass());    // Remove Dead code/vars
+  Passes.add(createRaiseAllocationsPass());       // call %malloc -> malloc inst
+  Passes.add(createCleanupGCCOutputPass());       // Fix gccisms
+  Passes.add(createIndVarSimplifyPass());         // Simplify indvars
+  if (!StopAtLevelRaise) {
+    Passes.add(createRaisePointerReferencesPass()); // Eliminate casts
+    Passes.add(createPromoteMemoryToRegister());    // Promote alloca's to regs
+    Passes.add(createConstantMergePass());          // Merge dup global consts
+    Passes.add(createInstructionCombiningPass());   // Combine silly seq's
+    Passes.add(createDeadCodeEliminationPass());    // Remove Dead code/vars
+  }
+  Passes.add(new WriteBytecodePass(&Out));        // Write bytecode to file...
 
   // Run our queue of passes all at once now, efficiently.
   Passes.run(M.get());