X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fgccas%2Fgccas.cpp;h=dd2b307d3b8ffc40490e98f15afe89d9fcbf521d;hb=2c7b430bc0831227f8c77478c1bda597f8f9fe29;hp=376aff083a4322d4288091916f77ea99f8768009;hpb=9c6f2ac665bbf0a95536ce473d5daf40bf5cd3db;p=oota-llvm.git diff --git a/tools/gccas/gccas.cpp b/tools/gccas/gccas.cpp index 376aff083a4..dd2b307d3b8 100644 --- a/tools/gccas/gccas.cpp +++ b/tools/gccas/gccas.cpp @@ -1,80 +1,184 @@ -//===------------------------------------------------------------------------=== -// LLVM 'GCCAS' UTILITY +//===-- gccas.cpp - The "optimizing assembler" used by the GCC frontend ---===// +// +// The LLVM Compiler Infrastructure // -// This utility is designed to be used by the GCC frontend for creating -// bytecode files from it's intermediate llvm assembly. The requirements for -// this utility are thus slightly different than that of the standard as util. +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // -//===------------------------------------------------------------------------=== +// This utility is designed to be used by the GCC frontend for creating bytecode +// files from its intermediate LLVM assembly. The requirements for this utility +// are thus slightly different than that of the standard `as' util. +// +//===----------------------------------------------------------------------===// #include "llvm/Module.h" +#include "llvm/PassManager.h" +#include "llvm/Analysis/LoadValueNumbering.h" +#include "llvm/Analysis/Verifier.h" #include "llvm/Assembly/Parser.h" -#include "llvm/Transforms/CleanupGCCOutput.h" -#include "llvm/Transforms/LevelChange.h" -#include "llvm/Optimizations/ConstantProp.h" -#include "llvm/Optimizations/DCE.h" -#include "llvm/Transforms/ConstantMerge.h" -#include "llvm/Transforms/Scalar/IndVarSimplify.h" -#include "llvm/Bytecode/Writer.h" +#include "llvm/Bytecode/WriteBytecodePass.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Transforms/Scalar.h" #include "Support/CommandLine.h" +#include "Support/Signals.h" #include #include -#include -cl::String InputFilename ("", "Parse file, compile to bytecode", - cl::Required, ""); -cl::String OutputFilename("o", "Override output filename", cl::NoFlags, ""); +using namespace llvm; + +namespace { + cl::opt + InputFilename(cl::Positional,cl::desc(""),cl::init("-")); + + cl::opt + OutputFilename("o", cl::desc("Override output filename"), + cl::value_desc("filename")); + + cl::opt + Verify("verify", cl::desc("Verify each pass result")); + + cl::opt + DisableInline("disable-inlining", cl::desc("Do not run the inliner pass")); + + cl::opt + DisableOptimizations("disable-opt", + cl::desc("Do not run any optimization passes")); +} + + +static inline void addPass(PassManager &PM, Pass *P) { + // Add the pass to the pass manager... + PM.add(P); + + // If we are verifying all of the intermediate steps, add the verifier... + if (Verify) PM.add(createVerifierPass()); +} + + +void AddConfiguredTransformationPasses(PassManager &PM) { + PM.add(createVerifierPass()); // Verify that input is correct + addPass(PM, createLowerSetJmpPass()); // Lower llvm.setjmp/.longjmp + addPass(PM, createFunctionResolvingPass()); // Resolve (...) functions + + if (DisableOptimizations) return; + + addPass(PM, createRaiseAllocationsPass()); // call %malloc -> malloc inst + addPass(PM, createCFGSimplificationPass()); // Clean up disgusting code + addPass(PM, createPromoteMemoryToRegister()); // Kill useless allocas + addPass(PM, createGlobalConstifierPass()); // Mark read-only globals const + addPass(PM, createGlobalDCEPass()); // Remove unused globals + addPass(PM, createIPConstantPropagationPass());// IP Constant Propagation + addPass(PM, createDeadArgEliminationPass()); // Dead argument elimination + addPass(PM, createInstructionCombiningPass()); // Clean up after IPCP & DAE + addPass(PM, createCFGSimplificationPass()); // Clean up after IPCP & DAE + + addPass(PM, createPruneEHPass()); // Remove dead EH info + + if (!DisableInline) + addPass(PM, createFunctionInliningPass()); // Inline small functions + addPass(PM, createArgumentPromotionPass()); // Scalarize uninlined fn args + + addPass(PM, createRaisePointerReferencesPass());// Recover type information + addPass(PM, createTailDuplicationPass()); // Simplify cfg by copying code + addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs + addPass(PM, createScalarReplAggregatesPass()); // Break up aggregate allocas + addPass(PM, createInstructionCombiningPass()); // Combine silly seq's + + addPass(PM, createReassociatePass()); // Reassociate expressions + addPass(PM, createInstructionCombiningPass()); // Combine silly seq's + addPass(PM, createTailCallEliminationPass()); // Eliminate tail calls + addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs + addPass(PM, createLICMPass()); // Hoist loop invariants + addPass(PM, createLoadValueNumberingPass()); // GVN for load instructions + addPass(PM, createGCSEPass()); // Remove common subexprs + addPass(PM, createSCCPPass()); // Constant prop with SCCP + + // Run instcombine after redundancy elimination to exploit opportunities + // opened up by them. + addPass(PM, createInstructionCombiningPass()); + addPass(PM, createIndVarSimplifyPass()); // Canonicalize indvars + addPass(PM, createAggressiveDCEPass()); // SSA based 'Aggressive DCE' + addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs + addPass(PM, createDeadTypeEliminationPass()); // Eliminate dead types + addPass(PM, createConstantMergePass()); // Merge dup global constants +} + int main(int argc, char **argv) { cl::ParseCommandLineOptions(argc, argv, " llvm .s -> .o assembler for GCC\n"); + PrintStackTraceOnErrorSignal(); - ostream *Out = 0; std::auto_ptr M; try { // Parse the file now... M.reset(ParseAssemblyFile(InputFilename)); } catch (const ParseException &E) { - cerr << E.getMessage() << endl; + std::cerr << argv[0] << ": " << E.getMessage() << "\n"; return 1; } if (M.get() == 0) { - cerr << "assembly didn't read correctly.\n"; + std::cerr << argv[0] << ": assembly didn't read correctly.\n"; return 1; } - + + std::ostream *Out = 0; if (OutputFilename == "") { // Didn't specify an output filename? - string IFN = InputFilename; - int Len = IFN.length(); - if (IFN[Len-2] == '.' && IFN[Len-1] == 's') { // Source ends in .s? - OutputFilename = string(IFN.begin(), IFN.end()-2); + if (InputFilename == "-") { + OutputFilename = "-"; } else { - OutputFilename = IFN; // Append a .o to it + std::string IFN = InputFilename; + int Len = IFN.length(); + if (IFN[Len-2] == '.' && IFN[Len-1] == 's') { // Source ends in .s? + OutputFilename = std::string(IFN.begin(), IFN.end()-2); + } else { + OutputFilename = IFN; // Append a .o to it + } + OutputFilename += ".o"; } - OutputFilename += ".o"; } - Out = new ofstream(OutputFilename.c_str(), ios::out); + if (OutputFilename == "-") + Out = &std::cout; + else { + Out = new std::ofstream(OutputFilename.c_str(), std::ios::out); + + // Make sure that the Out file gets unlinked from the disk if we get a + // signal + RemoveFileOnSignal(OutputFilename); + } + + if (!Out->good()) { - cerr << "Error opening " << OutputFilename << "!\n"; + std::cerr << argv[0] << ": error opening " << OutputFilename << "!\n"; return 1; } // In addition to just parsing the input from GCC, we also want to spiff it up // a little bit. Do this now. // - vector Passes; - Passes.push_back(new CleanupGCCOutput()); // Fix gccisms - Passes.push_back(new InductionVariableSimplify()); // Simplify indvars - Passes.push_back(new RaisePointerReferences()); // Fix general low level code - Passes.push_back(new ConstantMerge()); // Merge dup global constants - - // Run our queue of passes all at once now, efficiently. This form of - // runAllPasses frees the Pass objects after runAllPasses completes. + PassManager Passes; + + // Add an appropriate TargetData instance for this module... + Passes.add(new TargetData("gccas", M.get())); + + // Add all of the transformation passes to the pass manager to do the cleanup + // and optimization of the GCC output. // - Pass::runAllPassesAndFree(M.get(), Passes); + AddConfiguredTransformationPasses(Passes); - WriteBytecodeToFile(M.get(), *Out); + // Make sure everything is still good. + Passes.add(createVerifierPass()); + + // Write bytecode to file... + Passes.add(new WriteBytecodePass(Out)); + + // Run our queue of passes all at once now, efficiently. + Passes.run(*M.get()); + + if (Out != &std::cout) delete Out; return 0; } -