From: Chris Lattner Date: Mon, 23 Jul 2001 02:35:57 +0000 (+0000) Subject: Large scale changes to implement new command line argument facility X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=8f367bd3c0f56b7b318c46cee04f77735f617777;p=oota-llvm.git Large scale changes to implement new command line argument facility git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@272 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Assembly/Parser.h b/include/llvm/Assembly/Parser.h index 5ac6ec20fa1..4dc2bfb0597 100644 --- a/include/llvm/Assembly/Parser.h +++ b/include/llvm/Assembly/Parser.h @@ -10,14 +10,13 @@ #include class Module; -class ToolCommandLine; class ParseException; // The useful interface defined by this file... Parse an ascii file, and return // the internal representation in a nice slice'n'dice'able representation. // -Module *ParseAssemblyFile(const ToolCommandLine &Opts) throw (ParseException); +Module *ParseAssemblyFile(const string &Filename) throw (ParseException); //===------------------------------------------------------------------------=== // Helper Classes @@ -28,7 +27,7 @@ Module *ParseAssemblyFile(const ToolCommandLine &Opts) throw (ParseException); // class ParseException { public: - ParseException(const ToolCommandLine &Opts, const string &message, + ParseException(const string &filename, const string &message, int LineNo = -1, int ColNo = -1); ParseException(const ParseException &E); @@ -42,8 +41,8 @@ public: return Message; } - inline const ToolCommandLine &getOptions() const { - return Opts; // Get the options obj used to parse. + inline const string &getFilename() const { + return Filename; } // getErrorLocation - Return the line and column number of the error in the @@ -56,7 +55,7 @@ public: } private : - const ToolCommandLine &Opts; + string Filename; string Message; int LineNo, ColumnNo; // -1 if not relevant diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h index 0873003baf5..e5a93b4727d 100644 --- a/include/llvm/CodeGen/InstrSelection.h +++ b/include/llvm/CodeGen/InstrSelection.h @@ -22,8 +22,6 @@ class InstructionNode; class TmpInstruction; class ConstPoolVal; -enum { DEBUG_TREES_NONE = 0, DEBUG_INSTR_TREES = 1, DEBUG_BURG_TREES = 5 }; - //--------------------------------------------------------------------------- // GLOBAL data and an external function that must be implemented // for each architecture. @@ -53,8 +51,7 @@ extern bool ThisIsAChainRule (int eruleno); //--------------------------------------------------------------------------- bool SelectInstructionsForMethod (Method* method, - CompileContext& ccontext, - int DebugLevel); + CompileContext& ccontext); // Debugging function to print the generated instructions diff --git a/include/llvm/Support/ProgramOption.h b/include/llvm/Support/ProgramOption.h deleted file mode 100644 index 83eeac60a83..00000000000 --- a/include/llvm/Support/ProgramOption.h +++ /dev/null @@ -1,142 +0,0 @@ -// $Id$ -*-c++-*- -//*************************************************************************** -// -// File: -// ProgramOption.h -// -// Purpose: -// General representations for a program option. -// -// History: -// 08/08/95 - adve - created in the dHPF compiler -// 11/26/96 - adve - EvalOpt now returns #args consumed, or -1 for error -// 07/15/01 - vadve - Copied to LLVM system and modified -// -//**************************************************************************/ - -#ifndef LLVM_SUPPORT_PROGRAMOPTION_H -#define LLVM_SUPPORT_PROGRAMOPTION_H - -#include "llvm/Support/Unique.h" -#include - - -class ProgramOption: public Unique { -public: - /*ctor*/ ProgramOption (const string &_argString, - const string &_helpMesg, - int _minExpectedArgs = 1) - : optionSpecified(false), - argString(_argString), - helpMesg(_helpMesg), - minExpectedArgs(_minExpectedArgs) {} - - /*dtor*/ virtual ~ProgramOption() {} - - // Pure virtual function for an option with 0 or more arguments. - // `optarg' points to the start of the next word in argv[]. - // It will be NULL if there are no more words. - // The return value indicates the number of words of argv[] that - // were consumed by EvalOpt and should be discarded. - // A return value of -1 indicates an error. - // - virtual int EvalOpt (const string &) = 0; - - // Returns the value associated with the option as a human-readable - // string. - virtual string GetTextValue () const = 0; - - // Inline accessor functions for common option information - // - bool OptionSpecified () const { return optionSpecified; } - const string ArgString () const { return argString; } - const string HelpMesg () const { return helpMesg; } - int MinExpectedArgs () const { return minExpectedArgs; } - -protected: - bool optionSpecified; - string argString; - string helpMesg; - int minExpectedArgs; -}; - -//**************************************************************************/ - -class StringOption : public ProgramOption { -public: - /*ctor*/ StringOption (const string &argString, - const string &helpMesg, - const string &initValue = "", - bool append = false); - // append = false: EvalOpt will overwrite preexisting value - // append = true : EvalOpt will append to value - - /*dtor*/ virtual ~StringOption () {} - - virtual int EvalOpt (const string &optarg); - - const string &Value() const { return value; } - virtual string GetTextValue() const { return value; } - -protected: - string value; - bool append; -}; - -//**************************************************************************/ - -// - sets the flag to TRUE -// - 0 sets the flag to FALSE -// -// To provide an actual argument (not option) of "0", mark the -// end of the options with "--" (see getopt(1)). - -class FlagOption : public ProgramOption { -public: - FlagOption(const string &argString, const string &helpMesg, - bool initValue = false); - - virtual ~FlagOption() {} - - virtual int EvalOpt (const string &optarg); - - bool Value () const { return value; } - virtual string GetTextValue() const { return value ? "true" : "false";} -private: - bool value; -}; - -//**************************************************************************/ - -class RealValuedOption : public ProgramOption { -public: - /*ctor*/ RealValuedOption(const string &argString, - const string &helpMesg, - double initValue = 0.0); - /*dtor*/ virtual ~RealValuedOption() {} - - virtual int EvalOpt (const string &optarg); - - double Value () const { return value; } - virtual string GetTextValue() const; - -private: - double value; -}; - -//**************************************************************************/ - -class IntegerValuedOption : public RealValuedOption { -public: - /*ctor*/ IntegerValuedOption(const string &argString, - const string &helpMesg, - int initValue = 0); - /*ctor*/ virtual ~IntegerValuedOption() {} - - int Value() const; - virtual string GetTextValue() const; -}; - -//**************************************************************************/ - -#endif diff --git a/include/llvm/Support/ProgramOptions.h b/include/llvm/Support/ProgramOptions.h deleted file mode 100644 index 9ebc975c469..00000000000 --- a/include/llvm/Support/ProgramOptions.h +++ /dev/null @@ -1,145 +0,0 @@ -// $Id$ -*-c++-*- -//*************************************************************************** -// -// File: -// ProgramOptions.h -// -// Purpose: -// A representation of options for any program. -// -// History: -// 08/08/95 - adve - Created in the dHPF compiler -// 10/10/96 - mpal, dbaker - converted to const member functions. -// 10/19/96 - meven - slightly changed interface to accomodate -// arguments other than -X type options -// 07/15/01 - vadve - Copied to LLVM system and modified -// -//**************************************************************************/ - -#ifndef LLVM_SUPPORT_PROGRAMOPTIONS_H -#define LLVM_SUPPORT_PROGRAMOPTIONS_H - -#include "llvm/Support/Unique.h" -#include -#include -#include - -template <> struct hash { - size_t operator()(string const &str) const { - return hash()(str.c_str()); - } -}; - -class ProgramOption; - -//--------------------------------------------------------------------------- -// -// Class: ProgramOptions -// -// Base Classes: none -// -// Class Data Members: -// ProgramOptionsRepr* Internal representation of program options, -// accessible to derived classes. -// Purpose: -// Base class for representing the set of options for a program. -// -//--------------------------------------------------------------------------- - -class ProgramOptions: public Unique { -public: - /*ctor*/ ProgramOptions (int _argc, - const char* _argv[], - const char* _envp[]); - /*dtor*/ ~ProgramOptions () {} - - //-------------------------------------------------------------------- - // Retrieving different kinds of arguments. - // The required argument is specified by the optionString. - //-------------------------------------------------------------------- - - string StringOptionValue(const string &optionString) const; - bool FlagOptionValue (const string &optionString) const; - double RealOptionValue (const string &optionString) const; - int IntOptionValue (const string &optionString) const; - - bool OptionSpecified (const string &optionString) const; - - //-------------------------------------------------------------------- - // The name used to invoke this program. - //-------------------------------------------------------------------- - const char* ProgramName () const; - - //-------------------------------------------------------------------- - // Access to unparsed arguments - //-------------------------------------------------------------------- - int NumberOfOtherOptions() const; - const char* OtherOption(int i) const; - - //-------------------------------------------------------------------- - // Access to the original arguments - //-------------------------------------------------------------------- - const char** GetOriginalArgs() const; - void PrintArgs(ostream &out) const; - - //-------------------------------------------------------------------- - // Derived classes may use PrintOptions in their own PrintUsage() fct - // to print information about optional, required, or additional - // arguments - //-------------------------------------------------------------------- - virtual void PrintOptions (ostream& stream) const; - virtual void Usage () const; - - //-------------------------------------------------------------------- - // Generate a human-friendly description of the options actually set. - // The vector returned contains a multiple of 3 of entries, entry 3n is - // the name of the option, entry 3n + 1 contains the description of - // the option and entry 3n + 2 contains the ascii value of the option. - // All entries are allocated using malloc and can be freed with 'free'. - //-------------------------------------------------------------------- - virtual vector GetDescription () const; - -protected: - //-------------------------------------------------------------------- - // Called by the subclass to register each possible option - // used by the program. Assumes ownership of the ProgramOption. - //-------------------------------------------------------------------- - void Register (ProgramOption* option); - - //-------------------------------------------------------------------- - // Parses the options. - //-------------------------------------------------------------------- - void ParseArgs (int argc, - const char* argv[], - const char* envp[]); - - inline ProgramOption* OptionHandler(const string &optString) { - hash_map::iterator hp = - optionRegistry.find(optString); - return (hp != optionRegistry.end()) ? hp->second : 0; - } - inline const ProgramOption* OptionHandler(const string &optString) const { - hash_map::const_iterator hp = - optionRegistry.find(optString); - return (hp != optionRegistry.end()) ? hp->second : 0; - } -protected: - //-------------------------------------------------------------------- - // Functions that must be overridden by the subclass. - //-------------------------------------------------------------------- - - virtual void ParseExtraArgs () = 0; // called after successful ParseArgs - - virtual void PrintUsage (ostream& stream) const = 0; - -protected: - hash_map optionRegistry; - int argc; - const char** argv; - const char** envp; - int argsConsumed; -}; - -//**************************************************************************/ - -#endif diff --git a/include/llvm/Tools/CommandLine.h b/include/llvm/Tools/CommandLine.h index 76b4e97989c..35d96d49229 100644 --- a/include/llvm/Tools/CommandLine.h +++ b/include/llvm/Tools/CommandLine.h @@ -1,12 +1,8 @@ //===-- llvm/Tools/CommandLine.h - Command line parser for tools -*- C++ -*--=// // // This class implements a command line argument processor that is useful when -// creating a tool. -// -// This class is defined entirely inline so that you don't have to link to any -// libraries to use this. -// -// TODO: make this extensible by passing in arguments to be read. +// creating a tool. It provides a simple, minimalistic interface that is easily +// extensible and supports nonlocal (library) command line options. // //===----------------------------------------------------------------------===// @@ -14,113 +10,275 @@ #define LLVM_TOOLS_COMMANDLINE_H #include +#include +#include +#include + +namespace cl { // Short namespace to make usage concise + +//===----------------------------------------------------------------------===// +// ParseCommandLineOptions - Minimalistic command line option processing entry +// +void cl::ParseCommandLineOptions(int &argc, char **argv, + const char *Overview = 0); + + +//===----------------------------------------------------------------------===// +// Global flags permitted to be passed to command line arguments + +enum FlagsOptions { + NoFlags = 0x00, // Marker to make explicit that we have no flags + + // Flags for the number of occurances allowed... + Optional = 0x00, // Zero or One occurance + ZeroOrMore = 0x01, // Zero or more occurances allowed + Required = 0x02, // One occurance required + OneOrMore = 0x03, // One or more occurances required + OccurancesMask = 0x07, + + // Number of arguments to a value expected... + //Optional = 0x00, // The value can oppear... or not + ValueRequired = 0x08, // The value is required to appear! + ValueDisallowed = 0x10, // A value may not be specified (for flags) + ValueMask = 0x18, + + // Control whether -help shows the command line option... + Hidden = 0x20, // -help doesn't -help-hidden does + ReallyHidden = 0x60, // Neither -help nor -help-hidden show this arg + HiddenMask = 0x60, +}; + + +//===----------------------------------------------------------------------===// +// Option Base class +// +class Option { + friend void cl::ParseCommandLineOptions(int &, char **, const char *Overview); + + // handleOccurances - Overriden by subclasses to handle the value passed into + // an argument. Should return true if there was an error processing the + // argument and the program should exit. + // + virtual bool handleOccurance(const char *ArgName, const string &Arg) = 0; + + int NumOccurances; // The number of times specified +public: + const char * const ArgStr; // The argument string itself (ex: "help", "o") + const char * const HelpStr; // The descriptive text message for --help + const int Flags; // Flags for the argument + +protected: + Option(const char *ArgStr, const char *Message, int Flags); + Option(int flags) : ArgStr(""), HelpStr(""), Flags(flags) {} + + // Prints option name followed by message. Always returns true. + bool error(string Message, const char *ArgName = 0); + + // addOccurance - Wrapper around handleOccurance that enforces Flags + // + bool addOccurance(const char *ArgName, const string &Value); + +public: + // Return the width of the option tag for printing... + virtual unsigned getOptionWidth() const; + + // printOptionInfo - Print out information about this option. The + // to-be-maintained width is specified. + // + virtual void printOptionInfo(unsigned GlobalWidth) const; + +public: + inline int getNumOccurances() const { return NumOccurances; } + virtual ~Option() {} +}; + + +//===----------------------------------------------------------------------===// +// Boolean/flag command line option +// +class Flag : public Option { + bool Value; + virtual bool handleOccurance(const char *ArgName, const string &Arg); +public: + inline Flag(const char *ArgStr, const char *Message, int Flags = 0, + bool DefaultVal = 0) : Option(ArgStr, Message, Flags), + Value(DefaultVal) {} + operator bool() const { return Value; } + inline bool getValue() const { return Value; } + inline void setValue(bool Val) { Value = Val; } +}; + + + +//===----------------------------------------------------------------------===// +// Integer valued command line option +// +class Int : public Option { + int Value; + virtual bool handleOccurance(const char *ArgName, const string &Arg); +public: + inline Int(const char *ArgStr, const char *Help, int Flags = 0, + int DefaultVal = 0) : Option(ArgStr, Help, Flags | ValueRequired), + Value(DefaultVal) {} + inline operator int() const { return Value; } + inline int getValue() const { return Value; } + inline void setValue(int Val) { Value = Val; } +}; + -class ToolCommandLine { +//===----------------------------------------------------------------------===// +// String valued command line option +// +class String : public Option { + string Value; + virtual bool handleOccurance(const char *ArgName, const string &Arg); +public: + inline String(const char *ArgStr, const char *Help, int Flags = 0, + const char *DefaultVal = "") + : Option(ArgStr, Help, Flags | ValueRequired), Value(DefaultVal) {} + + inline const string &getValue() const { return Value; } + inline void setValue(const string &Val) { Value = Val; } +}; + + +//===----------------------------------------------------------------------===// +// Enum valued command line option +// +#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, ENUMVAL, DESC +#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, ENUMVAL, DESC + +// EnumBase - Base class for all enum/varargs related argument types... +class EnumBase : public Option { +protected: + // Use a vector instead of a map, because the lists should be short, + // the overhead is less, and most importantly, it keeps them in the order + // inserted so we can print our option out nicely. + vector > > ValueMap; + + inline EnumBase(const char *ArgStr, const char *Help, int Flags) + : Option(ArgStr, Help, Flags) {} + inline EnumBase(int Flags) : Option(Flags) {} + + // processValues - Incorporate the specifed varargs arglist into the + // ValueMap. + // + void processValues(va_list Vals); + + // registerArgs - notify the system about these new arguments + void registerArgs(); + +public: + // Turn an enum into the arg name that activates it + const char *getArgName(int ID) const; + const char *getArgDescription(int ID) const; +}; + +class EnumValueBase : public EnumBase { +protected: + int Value; + inline EnumValueBase(const char *ArgStr, const char *Help, int Flags) + : EnumBase(ArgStr, Help, Flags) {} + inline EnumValueBase(int Flags) : EnumBase(Flags) {} + + // handleOccurance - Set Value to the enum value specified by Arg + virtual bool handleOccurance(const char *ArgName, const string &Arg); + + // Return the width of the option tag for printing... + virtual unsigned getOptionWidth() const; + + // printOptionInfo - Print out information about this option. The + // to-be-maintained width is specified. + // + virtual void printOptionInfo(unsigned GlobalWidth) const; +}; + +template // The enum we are representing +class Enum : public EnumValueBase { public: - inline ToolCommandLine(int &argc, char **argv, bool OutputBytecode = true); - inline ToolCommandLine(const string &infn, const string &outfn = "-"); - inline ToolCommandLine(const ToolCommandLine &O); - inline ToolCommandLine &operator=(const ToolCommandLine &O); - - inline bool getForce() const { return Force; } - inline const string getInputFilename() const { return InputFilename; } - inline const string getOutputFilename() const { return OutputFilename; } - -private: - void calculateOutputFilename(bool OutputBytecode) { - OutputFilename = InputFilename; - unsigned Len = OutputFilename.length(); - - if (Len <= 3) { - OutputFilename += (OutputBytecode ? ".bc" : ".ll"); - return; - } - - if (OutputBytecode) { - if (OutputFilename[Len-3] == '.' && - OutputFilename[Len-2] == 'l' && - OutputFilename[Len-1] == 'l') { // .ll -> .bc - OutputFilename[Len-2] = 'b'; - OutputFilename[Len-1] = 'c'; - } else { - OutputFilename += ".bc"; - } - } else { - if (OutputFilename[Len-3] == '.' && - OutputFilename[Len-2] == 'b' && - OutputFilename[Len-1] == 'c') { // .ll -> .bc - OutputFilename[Len-2] = 'l'; - OutputFilename[Len-1] = 'l'; - } else { - OutputFilename += ".ll"; - } - } + inline Enum(const char *ArgStr, int Flags, const char *Help, ...) + : EnumValueBase(ArgStr, Help, Flags | ValueRequired) { + va_list Values; + va_start(Values, Help); + processValues(Values); + va_end(Values); + Value = ValueMap.front().second.first; // Grab default value } -private: - string InputFilename; // Filename to read from. If "-", use stdin. - string OutputFilename; // Filename to write to. If "-", use stdout. - bool Force; // Force output (-f argument) + inline E getValue() const { return (E)Value; } + inline void setValue(E Val) { Value = (E)Val; } }; -inline ToolCommandLine::ToolCommandLine(int &argc, char **argv, bool OutBC) - : InputFilename("-"), OutputFilename("-"), Force(false) { - bool FoundInputFN = false; - bool FoundOutputFN = false; - bool FoundForce = false; - - for (int i = 1; i < argc; i++) { - int RemoveArg = 0; - - if (argv[i][0] == '-') { - if (!FoundInputFN && argv[i][1] == 0) { // Is the current argument '-' - InputFilename = argv[i]; - FoundInputFN = true; - RemoveArg = 1; - } else if (!FoundOutputFN && (argv[i][1] == 'o' && argv[i][2] == 0)) { - // Is the argument -o? - if (i+1 < argc) { // Next arg is output fn - OutputFilename = argv[i+1]; - FoundOutputFN = true; - RemoveArg = 2; - } - } else if (!FoundForce && (argv[i][1] == 'f' && argv[i][2] == 0)) { - Force = true; - FoundForce = true; - RemoveArg = 1; - } - } else if (!FoundInputFN) { // Is the current argument '[^-].*'? - InputFilename = argv[i]; - FoundInputFN = true; - RemoveArg = 1; - } - - if (RemoveArg) { - argc -= RemoveArg; // Shift args over... - memmove(argv+i, argv+i+RemoveArg, (argc-i)*sizeof(char*)); - i--; // Reprocess this argument... - } + +//===----------------------------------------------------------------------===// +// Enum flags command line option +// +class EnumFlagsBase : public EnumValueBase { +protected: + virtual bool handleOccurance(const char *ArgName, const string &Arg); + inline EnumFlagsBase(int Flags) : EnumValueBase(Flags | ValueDisallowed) {} + + // Return the width of the option tag for printing... + virtual unsigned getOptionWidth() const; + + // printOptionInfo - Print out information about this option. The + // to-be-maintained width is specified. + // + virtual void printOptionInfo(unsigned GlobalWidth) const; +}; + +template // The enum we are representing +class EnumFlags : public EnumFlagsBase { +public: + inline EnumFlags(int Flags, ...) : EnumFlagsBase(Flags) { + va_list Values; + va_start(Values, Flags); + processValues(Values); + va_end(Values); + registerArgs(); + Value = ValueMap.front().second.first; // Grab default value + } + inline E getValue() const { return (E)Value; } + inline void setValue(E Val) { Value = (E)Val; } +}; + + +//===----------------------------------------------------------------------===// +// Enum list command line option +// +class EnumListBase : public EnumBase { +protected: + vector Values; // The options specified so far. + + inline EnumListBase(int Flags) + : EnumBase(Flags | ValueDisallowed | ZeroOrMore) {} + virtual bool handleOccurance(const char *ArgName, const string &Arg); + + // Return the width of the option tag for printing... + virtual unsigned getOptionWidth() const; + + // printOptionInfo - Print out information about this option. The + // to-be-maintained width is specified. + // + virtual void printOptionInfo(unsigned GlobalWidth) const; +public: + inline unsigned size() { return Values.size(); } +}; + +template // The enum we are representing +class EnumList : public EnumListBase { +public: + inline EnumList(int Flags, ...) : EnumListBase(Flags) { + va_list Values; + va_start(Values, Flags); + processValues(Values); + va_end(Values); + registerArgs(); } + inline E getValue(unsigned i) const { return (E)Values[i]; } + inline E operator[](unsigned i) const { return (E)Values[i]; } +}; - if (!FoundOutputFN && InputFilename != "-") - calculateOutputFilename(OutBC); -} - -inline ToolCommandLine::ToolCommandLine(const string &inf, - const string &outf) - : InputFilename(inf), OutputFilename(outf), Force(false) { -} - -inline ToolCommandLine::ToolCommandLine(const ToolCommandLine &Opts) - : InputFilename(Opts.InputFilename), OutputFilename(Opts.OutputFilename), - Force(Opts.Force) { -} - -inline ToolCommandLine &ToolCommandLine::operator=(const ToolCommandLine &Opts){ - InputFilename = Opts.InputFilename; - OutputFilename = Opts.OutputFilename; - Force = Opts.Force; - return *this; -} +} // End namespace cl #endif diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp index 4843a70dce7..0ad1dbdb547 100644 --- a/lib/CodeGen/InstrSelection/InstrSelection.cpp +++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp @@ -10,8 +10,6 @@ //*************************************************************************** -//*************************** User Include Files ***************************/ - #include "llvm/CodeGen/InstrSelection.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" @@ -20,7 +18,20 @@ #include "llvm/Instruction.h" #include "llvm/LLC/CompileContext.h" #include "llvm/CodeGen/MachineInstr.h" +#include "llvm/Tools/CommandLine.h" + +enum DebugLev { + NoDebugInfo, + DebugInstTrees, + DebugBurgTrees, +}; +// Enable Debug Options to be specified on the command line +cl::Enum DebugLevel("debug_select", cl::NoFlags, // cl::Hidden + "enable instruction selection debugging information", + clEnumVal(NoDebugInfo , "disable debug output"), + clEnumVal(DebugInstTrees, "print instruction trees"), + clEnumVal(DebugBurgTrees, "print burg trees"), 0); //************************* Forward Declarations ***************************/ @@ -36,8 +47,7 @@ static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt, // Returns true if instruction selection failed, false otherwise. //--------------------------------------------------------------------------- -bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, - int DebugLevel) { +bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) { bool failed = false; InstrForest instrForest; @@ -59,7 +69,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, // Invoke BURM to label each tree node with a state (void) burm_label(basicNode); - if (DebugLevel >= DEBUG_BURG_TREES) + if (DebugLevel.getValue() >= DebugBurgTrees) { printcover(basicNode, 1, 0); cerr << "\nCover cost == " << treecost(basicNode, 1, 0) << "\n\n"; @@ -76,7 +86,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, if (!failed) { - if (DebugLevel >= DEBUG_INSTR_TREES) + if (DebugLevel.getValue() >= DebugInstTrees) { cout << "\n\n*** Instruction trees for method " << (method->hasName()? method->getName() : "") @@ -84,7 +94,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, instrForest.dump(); } - if (DebugLevel >= DEBUG_TREES_NONE) + if (DebugLevel.getValue() > NoDebugInfo) PrintMachineInstructions(method); } diff --git a/lib/Support/Makefile b/lib/Support/Makefile index 7a41c62b04e..c7eb8adcb19 100644 --- a/lib/Support/Makefile +++ b/lib/Support/Makefile @@ -4,9 +4,4 @@ DIRS = LIBRARYNAME = support -## List source files in link order -Source = \ - ProgramOption.o \ - ProgramOptions.o - include $(LEVEL)/Makefile.common diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp index 4843a70dce7..0ad1dbdb547 100644 --- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp +++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp @@ -10,8 +10,6 @@ //*************************************************************************** -//*************************** User Include Files ***************************/ - #include "llvm/CodeGen/InstrSelection.h" #include "llvm/Method.h" #include "llvm/BasicBlock.h" @@ -20,7 +18,20 @@ #include "llvm/Instruction.h" #include "llvm/LLC/CompileContext.h" #include "llvm/CodeGen/MachineInstr.h" +#include "llvm/Tools/CommandLine.h" + +enum DebugLev { + NoDebugInfo, + DebugInstTrees, + DebugBurgTrees, +}; +// Enable Debug Options to be specified on the command line +cl::Enum DebugLevel("debug_select", cl::NoFlags, // cl::Hidden + "enable instruction selection debugging information", + clEnumVal(NoDebugInfo , "disable debug output"), + clEnumVal(DebugInstTrees, "print instruction trees"), + clEnumVal(DebugBurgTrees, "print burg trees"), 0); //************************* Forward Declarations ***************************/ @@ -36,8 +47,7 @@ static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt, // Returns true if instruction selection failed, false otherwise. //--------------------------------------------------------------------------- -bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, - int DebugLevel) { +bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) { bool failed = false; InstrForest instrForest; @@ -59,7 +69,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, // Invoke BURM to label each tree node with a state (void) burm_label(basicNode); - if (DebugLevel >= DEBUG_BURG_TREES) + if (DebugLevel.getValue() >= DebugBurgTrees) { printcover(basicNode, 1, 0); cerr << "\nCover cost == " << treecost(basicNode, 1, 0) << "\n\n"; @@ -76,7 +86,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, if (!failed) { - if (DebugLevel >= DEBUG_INSTR_TREES) + if (DebugLevel.getValue() >= DebugInstTrees) { cout << "\n\n*** Instruction trees for method " << (method->hasName()? method->getName() : "") @@ -84,7 +94,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext, instrForest.dump(); } - if (DebugLevel >= DEBUG_TREES_NONE) + if (DebugLevel.getValue() > NoDebugInfo) PrintMachineInstructions(method); } diff --git a/support/lib/Support/Makefile b/support/lib/Support/Makefile index 7a41c62b04e..c7eb8adcb19 100644 --- a/support/lib/Support/Makefile +++ b/support/lib/Support/Makefile @@ -4,9 +4,4 @@ DIRS = LIBRARYNAME = support -## List source files in link order -Source = \ - ProgramOption.o \ - ProgramOptions.o - include $(LEVEL)/Makefile.common diff --git a/support/lib/Support/ProgramOption.cpp b/support/lib/Support/ProgramOption.cpp deleted file mode 100644 index 6b391bc7145..00000000000 --- a/support/lib/Support/ProgramOption.cpp +++ /dev/null @@ -1,114 +0,0 @@ -// $Id$ -//*************************************************************************** -// -// File: -// ProgramOption.C -// -// Purpose: -// General representations for a program option. -// -// History: -// 08/08/95 - adve - created in the dHPF compiler -// 11/26/96 - adve - EvalOpt now returns #args consumed, or -1 for error -// 07/15/01 - vadve - Copied to LLVM system and modified -// -//**************************************************************************/ - -#include "llvm/Support/ProgramOption.h" -#include -#include -#include - -//**************************************************************************/ - -StringOption::StringOption(const string &_argString, - const string &_helpMesg, - const string &_initValue, - bool _append) - : ProgramOption(_argString, _helpMesg), - value(_initValue), - append(_append) -{} - -int StringOption::EvalOpt(const string &optarg) { - if (optarg == (char*) NULL) - return -1; // flag the error - - if (this->append) - value += optarg; - else - value = optarg; - - optionSpecified = true; - return 1; // one additional argument consumed -} - - -//**************************************************************************/ - -FlagOption::FlagOption(const string &_argString, - const string &_helpMesg, - bool _initValue) - : ProgramOption(_argString, _helpMesg, 0), - value(_initValue) -{} - -int FlagOption::EvalOpt(const string &optarg) { - if (optarg == "0") { - value = false; - return 1; // one additional argument consumed - } - else { - value = true; - return 0; // zero ... consumed - } -} - -//**************************************************************************/ - -RealValuedOption::RealValuedOption(const string &_argString, - const string &_helpMesg, - double _initValue) - : ProgramOption(_argString, _helpMesg), - value(_initValue) -{} - -int RealValuedOption::EvalOpt(const string &optarg) { - if (optarg == "") return -1; - - char* lastCharScanned = NULL; - value = strtod(optarg.c_str(), &lastCharScanned); - if (! (*lastCharScanned == '\0')) // look for incorrect or partially - return -1; // correct numerical argument - - optionSpecified = true; - return 1; -} - -string RealValuedOption::GetTextValue() const { - char buffer[40]; - sprintf(buffer, "%f", value); - return buffer; -} - -//**************************************************************************/ - -IntegerValuedOption::IntegerValuedOption(const string &_argString, - const string &_helpMesg, - int _initValue) - : RealValuedOption(_argString, _helpMesg, (double) _initValue) -{} - -int IntegerValuedOption::Value() const { - double realValue = RealValuedOption::Value(); - assert(realValue == (int) realValue); - return (int) realValue; -} - -string IntegerValuedOption::GetTextValue() const { - char buffer[40]; - sprintf(buffer, "%d", Value()); - return buffer; -} - - diff --git a/support/lib/Support/ProgramOptions.cpp b/support/lib/Support/ProgramOptions.cpp deleted file mode 100644 index fc50ddcbbb3..00000000000 --- a/support/lib/Support/ProgramOptions.cpp +++ /dev/null @@ -1,243 +0,0 @@ -// $Id$ -//*************************************************************************** -// -// File: -// ProgramOptions.C -// -// Purpose: -// General options processing for any program. -// -// History: -// 08/08/95 - adve - created in the dHPF compiler -// 10/10/96 - mpal, dbaker - converted to const member functions. -// 11/26/96 - adve - fixed to handle options that consume 0+ arguments -// 07/15/01 - vadve - Copied to LLVM system and modified -// -//**************************************************************************/ - -//************************** System Include Files **************************/ - -#include -#include -#include -#include -#include -#ifndef MAXINT -#define MAXINT ((1 << sizeof(int)-1) - 1) -#endif - -//*************************** User Include Files ***************************/ - -#include "llvm/Support/ProgramOptions.h" -#include "llvm/Support/ProgramOption.h" - - -//************************** Method Definitions ****************************/ - -ProgramOptions::ProgramOptions(int _argc, - const char* _argv[], - const char* _envp[]) - : optionRegistry(), - argc(_argc), - argv(_argv), - envp(_envp), - argsConsumed(0) -{} - -string ProgramOptions::StringOptionValue(const string &optString) const { - const StringOption* handler = (const StringOption*)OptionHandler(optString); - return (handler == NULL) ? string("") : handler->Value(); -} - -bool -ProgramOptions::FlagOptionValue(const string &optString) const -{ - const FlagOption* handler = (const FlagOption*) OptionHandler(optString); - return (handler == NULL) ? false : handler->Value(); -} - -double -ProgramOptions::RealOptionValue(const string &optString) const -{ - const RealValuedOption* handler = - (const RealValuedOption*) OptionHandler(optString); - return (handler == NULL) ? MAXFLOAT : handler->Value(); -} - -int -ProgramOptions::IntOptionValue(const string &optString) const -{ - const IntegerValuedOption* handler = - (const IntegerValuedOption*) OptionHandler(optString); - return (handler == NULL) ? MAXINT : handler->Value(); -} - -bool -ProgramOptions::OptionSpecified(const string &optString) const -{ - const ProgramOption* handler = OptionHandler(optString); - return handler->OptionSpecified(); -} - -const char* -ProgramOptions::ProgramName() const -{ - return argv[0]; -} - -int -ProgramOptions::NumberOfOtherOptions() const -{ - return argc - argsConsumed; -} - -const char* -ProgramOptions::OtherOption(int i) const -{ - i += argsConsumed; - assert(i >= 0 && i < argc); - return argv[i]; -} - -const char** -ProgramOptions::GetOriginalArgs() const -{ - return argv; -} - -vector -ProgramOptions::GetDescription() const -{ - vector optDesc; - - if (optDesc.size() < (unsigned) argc) - { - for (hash_map::const_iterator iter=optionRegistry.begin(); - ! (iter == optionRegistry.end()); - ++iter) - { - const ProgramOption* handler = iter->second; - optDesc.push_back(handler->ArgString()); // 1st - optDesc.push_back(handler->HelpMesg()); // 2nd - optDesc.push_back(handler->GetTextValue()); // 3rd - } - } - - return optDesc; -} - -void -ProgramOptions::Register(ProgramOption* option) -{ - optionRegistry[option->ArgString()] = option; -} - -//---------------------------------------------------------------------- -// function ProgramOptions::ParseArgs -// -// Parse command-line options until you run out of options or see -// an unrecognized option. `getopt' is a standard package to do this, -// but incredibly, it limited to single-letter options. -// -// -- Each option can consume zero or one additional arguments of argv -// -- "--" can be used to mark the end of options -// so that a program argument can also start with "-". -//---------------------------------------------------------------------/ - -void -ProgramOptions::ParseArgs(int argc, - const char* argv[], - const char* envp[]) -{ - if (argc == 0) { - Usage(); - } - // consume the program name - argsConsumed = 1; - - while (argsConsumed < argc) - { - const char* arg = argv[argsConsumed]; - if (arg[0] == '-') - { - if (strcmp(arg, "--") == 0) { // "--" marks end of options - argsConsumed++; // consume and - break; // discontinue the for loop - } - ProgramOption* handler = OptionHandler(arg+1); - if (handler == NULL) { - cerr << "Unrecognized option: " << arg+1 << endl; - Usage(); - } - - if (argc - argsConsumed < handler->MinExpectedArgs()) { - cerr << "Option " << (char*) arg+1 << " needs " - << handler->MinExpectedArgs() << " arguments" << endl; - Usage(); - } - - argsConsumed++; // consumed the option - - const char* nextArg = (argsConsumed < argc)? argv[argsConsumed] - : ""; - int numAdditionalArgsConsumed = handler->EvalOpt(nextArg); - if (numAdditionalArgsConsumed < 0) - Usage(); - argsConsumed += numAdditionalArgsConsumed; - } - else - { - break; // quit the while loop - } - } - - ParseExtraArgs(); -} - -void -ProgramOptions::PrintArgs(ostream& stream) const -{ - for (int i = 0; i < argc; i++) { - stream << argv[i] << " "; - } - stream << endl; -} - - -void -ProgramOptions::PrintOptions(ostream& stream) const -{ - stream << "OPTIONS:" << endl; - stream << "\tUse argument 0 to turn OFF a flag option: " - << "- 0" << endl << endl; - - for (hash_map::const_iterator iter = optionRegistry.begin(); - iter != optionRegistry.end(); ++iter) { - const ProgramOption* handler = (*iter).second; - - stream << "\t-" << handler->ArgString(); - - const char* const showarg = " "; - int i = 1; - for (i=1; i <= handler->MinExpectedArgs(); i++) - stream << showarg; - - int numCharsPrinted = 1 + handler->ArgString().length() - + 6 * handler->MinExpectedArgs(); - for (i=1; i > numCharsPrinted / 8; i--) - stream << "\t"; - - stream << "\t" << handler->HelpMesg() - << endl; - } -} - -void -ProgramOptions::Usage() const -{ - PrintUsage(cerr); - exit(1); -} - - -//**************************************************************************/ diff --git a/tools/analyze/Makefile b/tools/analyze/Makefile index b33d40bd690..1ff0e53fd8f 100644 --- a/tools/analyze/Makefile +++ b/tools/analyze/Makefile @@ -9,4 +9,5 @@ LIBDEPS = ../../lib/Optimizations/Debug/libopt.a ../../lib/Analysis/Debug/liba analyze : $(ObjectsG) Debug/.dir Depend/.dir $(LIBDEPS) $(LinkG) -o $@ $(ObjectsG) -lopt -lasmparser \ - -lbcreader -lvmcore -lasmwriter -lanalysis -lopt + -lbcreader -lvmcore -lasmwriter -lanalysis \ + -lopt -lsupport diff --git a/tools/analyze/analyze.cpp b/tools/analyze/analyze.cpp index cf93ea9d8ed..4dc00b2c579 100644 --- a/tools/analyze/analyze.cpp +++ b/tools/analyze/analyze.cpp @@ -86,47 +86,54 @@ static void PrintPostDomFrontier(Method *M) { cout << cfg::DominanceFrontier(cfg::DominatorSet(M, true)); } +enum Ans { + print, intervals, exprclassify, + domset, idom, domtree, domfrontier, + postdomset, postidom, postdomtree, postdomfrontier, +}; + +cl::String InputFilename ("", "Load file to analyze", 0, "-"); +cl::Flag Quiet ("q", "Don't print analysis pass names", 0, false); +cl::EnumList AnalysesList(cl::NoFlags, + clEnumVal(print , "Print each Method"), + clEnumVal(intervals , "Print Interval Partitions"), + clEnumVal(exprclassify , "Classify Expressions"), + + clEnumVal(domset , "Print Dominator Sets"), + clEnumVal(idom , "Print Immediate Dominators"), + clEnumVal(domtree , "Print Dominator Tree"), + clEnumVal(domfrontier , "Print Dominance Frontier"), + + clEnumVal(postdomset , "Print Postdominator Sets"), + clEnumVal(postidom , "Print Immediate Postdominators"), + clEnumVal(postdomtree , "Print Post Dominator Tree"), + clEnumVal(postdomfrontier, "Print Postdominance Frontier"), +0); + struct { - const string ArgName, Name; + enum Ans AnID; void (*AnPtr)(Method *M); } AnTable[] = { - { "-print" , "Print each Method" , PrintMethod }, - { "-intervals" , "Interval Partition" , PrintIntervalPartition }, - { "-exprclassify" , "Classify Expressions" , PrintClassifiedExprs }, - - { "-domset" , "Dominator Sets" , PrintDominatorSets }, - { "-idom" , "Immediate Dominators" , PrintImmediateDominators }, - { "-domtree" , "Dominator Tree" , PrintDominatorTree }, - { "-domfrontier" , "Dominance Frontier" , PrintDominanceFrontier }, - - { "-postdomset" , "Postdominator Sets" , PrintPostDominatorSets }, - { "-postidom" , "Immediate Postdominators", PrintImmediatePostDoms }, - { "-postdomtree" , "Post Dominator Tree" , PrintPostDomTree }, - { "-postdomfrontier", "Postdominance Frontier" , PrintPostDomFrontier }, + { print , PrintMethod }, + { intervals , PrintIntervalPartition }, + { exprclassify , PrintClassifiedExprs }, + + { domset , PrintDominatorSets }, + { idom , PrintImmediateDominators }, + { domtree , PrintDominatorTree }, + { domfrontier , PrintDominanceFrontier }, + + { postdomset , PrintPostDominatorSets }, + { postidom , PrintImmediatePostDoms }, + { postdomtree , PrintPostDomTree }, + { postdomfrontier, PrintPostDomFrontier }, }; int main(int argc, char **argv) { - ToolCommandLine Options(argc, argv, false); - bool Quiet = false; - - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << " " << argv[0] << " --help\t - Print this usage information\n" - << "\t --quiet\t - Do not print analysis name before output\n"; - for (unsigned j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); ++j) { - cerr << "\t " << AnTable[j].ArgName << "\t - Print " - << AnTable[j].Name << endl; - } - return 1; - } else if (string(argv[i]) == string("-q") || - string(argv[i]) == string("--quiet")) { - Quiet = true; argv[i] = 0; - } - } - - Module *C = ParseBytecodeFile(Options.getInputFilename()); - if (!C && !(C = ParseAssemblyFile(Options))) { + cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\n"); + + Module *C = ParseBytecodeFile(InputFilename.getValue()); + if (!C && !(C = ParseAssemblyFile(InputFilename.getValue()))) { cerr << "Input file didn't read correctly.\n"; return 1; } @@ -136,22 +143,22 @@ int main(int argc, char **argv) { Method *M = *I; if (M->isExternal()) continue; - // Loop over all of the analyses to be run... - for (int i = 1; i < argc; i++) { - if (argv[i] == 0) continue; + for (unsigned i = 0; i < AnalysesList.size(); ++i) { + enum Ans AnalysisPass = AnalysesList[i]; + + // Loop over all of the analyses to be run... unsigned j; - for (j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); j++) { - if (string(argv[i]) == AnTable[j].ArgName) { + for (j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); ++j) { + if (AnalysisPass == AnTable[j].AnID) { if (!Quiet) - cerr << "Running: " << AnTable[j].Name << " analysis on '" - << ((Value*)M)->getName() << "'!\n"; + cerr << "Running: " << AnalysesList.getArgDescription(AnalysisPass) + << " analysis on '" << ((Value*)M)->getName() << "'!\n"; AnTable[j].AnPtr(M); break; } } - if (j == sizeof(AnTable)/sizeof(AnTable[0])) - cerr << "'" << argv[i] << "' argument unrecognized: ignored\n"; + cerr << "Analysis tables inconsistent!\n"; } } diff --git a/tools/as/Makefile b/tools/as/Makefile index 9d36cc1d007..fcb92935721 100644 --- a/tools/as/Makefile +++ b/tools/as/Makefile @@ -6,4 +6,4 @@ clean:: rm -f as as : $(ObjectsG) - $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore + $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore -lsupport diff --git a/tools/as/as.cpp b/tools/as/as.cpp index 2c319a08491..da05a36f7fc 100644 --- a/tools/as/as.cpp +++ b/tools/as/as.cpp @@ -18,54 +18,49 @@ #include "llvm/Bytecode/Writer.h" #include "llvm/Tools/CommandLine.h" +cl::String InputFilename ("", "Parse file, compile to bytecode", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::Flag DumpAsm ("d", "Print assembly as parsed", cl::Hidden, false); int main(int argc, char **argv) { - ToolCommandLine Opts(argc, argv); - bool DumpAsm = false; + cl::ParseCommandLineOptions(argc, argv, " llvm .ll -> .bc assembler\n"); - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("-d")) { - argv[i] = 0; DumpAsm = true; - } - } - - bool PrintMessage = false; - for (int i = 1; i < argc; i++) { - if (argv[i] == 0) continue; - - if (string(argv[i]) == string("--help")) { - PrintMessage = true; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - - if (PrintMessage) { - cerr << argv[0] << " usage:\n" - << " " << argv[0] << " --help - Print this usage information\n" - << " " << argv[0] << " x.ll - Parse file and output " - << "bytecodes to x.bc\n" - << " " << argv[0] << " - Parse stdin and write to stdout.\n"; - return 1; - } - - ostream *Out = &cout; // Default to output to stdout... + ostream *Out = 0; try { // Parse the file now... - Module *C = ParseAssemblyFile(Opts); + Module *C = ParseAssemblyFile(InputFilename.getValue()); if (C == 0) { cerr << "assembly didn't read correctly.\n"; return 1; } - if (DumpAsm) + if (DumpAsm.getValue()) cerr << "Here's the assembly:\n" << C; + + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); + Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') { + // Source ends in .ll + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .bc to it + } + OutputFilename.setValue(OutputFilename.getValue() + ".bc"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() << "!\n"; + cerr << "Error opening " << OutputFilename.getValue() << "!\n"; delete C; return 1; } diff --git a/tools/dis/Makefile b/tools/dis/Makefile index e6624ab5442..8ce3e2161c2 100644 --- a/tools/dis/Makefile +++ b/tools/dis/Makefile @@ -6,5 +6,5 @@ clean :: rm -f dis dis : $(ObjectsG) - $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore + $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore -lsupport diff --git a/tools/dis/dis.cpp b/tools/dis/dis.cpp index deaf3a28fd5..f243baadb0e 100644 --- a/tools/dis/dis.cpp +++ b/tools/dis/dis.cpp @@ -25,69 +25,67 @@ #include "llvm/Method.h" #include "llvm/CFG.h" -int main(int argc, char **argv) { - // WriteMode - The different orderings to print basic blocks in... - enum { - Default = 0, // Method Order (list order) - DepthFirst, // Depth First ordering - ReverseDepthFirst, // Reverse Depth First ordering - PostOrder, // Post Order - ReversePostOrder // Reverse Post Order - } WriteMode = Default; +// OutputMode - The different orderings to print basic blocks in... +enum OutputMode { + Default = 0, // Method Order (list order) + dfo, // Depth First ordering + rdfo, // Reverse Depth First ordering + po, // Post Order + rpo, // Reverse Post Order +}; - ToolCommandLine Opts(argc, argv, false); +cl::String InputFilename ("", "Load file, print as assembly", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::EnumFlags WriteMode(cl::NoFlags, + clEnumVal(Default, "Write bb's in bytecode order"), + clEnumVal(dfo , "Write bb's in depth first order"), + clEnumVal(rdfo , "Write bb's in reverse DFO"), + clEnumVal(po , "Write bb's in postorder"), + clEnumVal(rpo , "Write bb's in reverse postorder"), 0); - // We only support the options that the system parser does... if it left any - // then we don't know what to do. - // - if (argc > 1) { - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << "\tx.bc - Parse file and output to x.ll\n" - << "\tno .bc file - Parse stdin and write to stdout.\n" - << "\t-dfo - Write basic blocks in depth first order.\n" - << "\t-rdfo - Write basic blocks in reverse DFO.\n" - << "\t-po - Write basic blocks in postorder.\n" - << "\t-rpo - Write basic blocks in reverse postorder.\n" - << "\t--help - Print this usage information\n\n"; - return 1; - } else if (string(argv[i]) == string("-dfo")) { - WriteMode = DepthFirst; - } else if (string(argv[i]) == string("-rdfo")) { - WriteMode = ReverseDepthFirst; - } else if (string(argv[i]) == string("-po")) { - WriteMode = PostOrder; - } else if (string(argv[i]) == string("-rpo")) { - WriteMode = ReversePostOrder; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - } - +int main(int argc, char **argv) { + cl::ParseCommandLineOptions(argc, argv, " llvm .bc -> .ll disassembler\n"); ostream *Out = &cout; // Default to printing to stdout... - Module *C = ParseBytecodeFile(Opts.getInputFilename()); + Module *C = ParseBytecodeFile(InputFilename.getValue()); if (C == 0) { cerr << "bytecode didn't read correctly.\n"; return 1; } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); - if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() - << ": sending to stdout instead!\n"; + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { + // Source ends in .bc + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .ll to it } + OutputFilename.setValue(OutputFilename.getValue() + ".ll"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } } - + + if (!Out->good()) { + cerr << "Error opening " << OutputFilename.getValue() + << ": sending to stdout instead!\n"; + Out = &cout; + } + // All that dis does is write the assembly out to a file... which is exactly // what the writer library is supposed to do... // - if (WriteMode == Default) { + if (WriteMode.getValue() == Default) { (*Out) << C; // Print out in list order } else { // TODO: This does not print anything other than the basic blocks in the @@ -98,20 +96,20 @@ int main(int argc, char **argv) { Method *M = *I; (*Out) << "-------------- Method: " << M->getName() << " -------------\n"; - switch (WriteMode) { - case DepthFirst: // Depth First ordering + switch (WriteMode.getValue()) { + case dfo: // Depth First ordering copy(cfg::df_begin(M), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case ReverseDepthFirst: // Reverse Depth First ordering + case rdfo: // Reverse Depth First ordering copy(cfg::df_begin(M, true), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case PostOrder: // Post Order + case po: // Post Order copy(cfg::po_begin(M), cfg::po_end(M), ostream_iterator(*Out, "\n")); break; - case ReversePostOrder: { // Reverse Post Order + case rpo: { // Reverse Post Order cfg::ReversePostOrderTraversal RPOT(M); copy(RPOT.begin(), RPOT.end(), ostream_iterator(*Out, "\n")); diff --git a/tools/llc/LLCOptions.cpp b/tools/llc/LLCOptions.cpp deleted file mode 100644 index 1f367a2d183..00000000000 --- a/tools/llc/LLCOptions.cpp +++ /dev/null @@ -1,125 +0,0 @@ -// $Id$ -//**************************************************************************/ -// File: -// LLCOptions.cpp -// -// Purpose: -// Options for the llc compiler. -// -// History: -// 7/15/01 - Vikram Adve - Created -// -//**************************************************************************/ - -//************************** System Include Files **************************/ - -#include -#include - - -//*************************** User Include Files ***************************/ - -#include "llvm/Support/ProgramOptions.h" -#include "llvm/Support/ProgramOption.h" -#include "LLCOptions.h" - - -//--------------------------------------------------------------------------- -// class LLCOptions -//--------------------------------------------------------------------------- - -/*ctor*/ -LLCOptions::LLCOptions (int _argc, - const char* _argv[], - const char* _envp[]) - : ProgramOptions(_argc, _argv, _envp) -{ - InitializeOptions(); - ParseArgs(argc, argv, envp); - CheckParse(); -} - -/*dtor*/ -LLCOptions::~LLCOptions() -{} - -//-------------------------------------------------------------------- -// Initialize all our compiler options -//-------------------------------------------------------------------- - -void -LLCOptions::InitializeOptions() -{ - Register(new FlagOption(HELP_OPT, - "print usage message", - false /*initValue*/)); - - Register(new FlagOption(DEBUG_OPT, - "turn on default debugging options", - false /*initValue*/)); - - Register(new FlagOption(DEBUG_OPT, - "turn off all diagnostic messages", - false /*initValue*/)); - - Register(new StringOption(OUTFILENAME_OPT, - "output file name", - "" /*initValue*/)); - - Register(new IntegerValuedOption(DEBUG_INSTR_SELECT_OPT, - "control amount of debugging information for instruction selection", - 0 /*initValue*/)); -} - - -void -LLCOptions::ParseExtraArgs() -{ - if (argsConsumed != argc-1) - Usage(); - - // input file name should be the last argument - inputFileName = argv[argc-1]; - - // output file name may be specified with -o option; - // otherwise create it from the input file name by replace ".ll" with ".o" - const string &outfilenameOpt = StringOptionValue(OUTFILENAME_OPT); - if (outfilenameOpt.length()) - {// "-o" option was used - outputFileName = outfilenameOpt; - } - else - { - outputFileName = inputFileName; - unsigned int suffixPos = outputFileName.rfind(".bc"); - - if (suffixPos >= outputFileName.length()) - suffixPos = outputFileName.rfind(".ll"); - - if (suffixPos >= outputFileName.length()) - { - cerr << "Unrecognized suffix in file name " << inputFileName << endl; - Usage(); - } - - outputFileName.replace(suffixPos, 3, ".o"); - } -} - -//-------------------------------------------------------------------- -// Functions that must be overridden in subclass of ProgramOptions -//-------------------------------------------------------------------- - -void -LLCOptions::CheckParse() -{} - -void -LLCOptions::PrintUsage(ostream& stream) const -{ - stream << "\nUSAGE:\n\t" << ProgramName() << " [options] " - << "llvm-file" << endl << endl; - PrintOptions(stream); -} - - diff --git a/tools/llc/LLCOptions.h b/tools/llc/LLCOptions.h deleted file mode 100644 index cad1d4f9353..00000000000 --- a/tools/llc/LLCOptions.h +++ /dev/null @@ -1,74 +0,0 @@ -// $Id$ -*-c++-*- -//**************************************************************************/ -// File: -// LLCOptions.h -// -// Purpose: -// Options for the llc compiler. -// -// History: -// 7/15/01 - Vikram Adve - Created -// -//**************************************************************************/ - -#ifndef LLVM_LLC_LLCOPTIONS_H -#define LLVM_LLC_LLCOPTIONS_H - -#include "llvm/Support/ProgramOptions.h" -#include "llvm/Support/ProgramOption.h" - -const char* const HELP_OPT = "help"; -const char* const DEBUG_OPT = "d"; -const char* const QUIET_OPT = "q"; -const char* const DEBUG_INSTR_SELECT_OPT= "debug_select"; -const char* const OUTFILENAME_OPT = "o"; - - -//--------------------------------------------------------------------------- -// class LLCOptions -//--------------------------------------------------------------------------- - -class LLCOptions : public ProgramOptions { -public: - /*ctor*/ LLCOptions (int _argc, - const char* _argv[], - const char* _envp[]); - /*dtor*/ virtual ~LLCOptions (); - - const string& getInputFileName() const { return inputFileName; } - - const string& getOutputFileName() const { return outputFileName; } - -protected: - - //-------------------------------------------------------------------- - // Initialize for all our compiler options (called by constructors). - //-------------------------------------------------------------------- - void InitializeOptions(); - - //-------------------------------------------------------------------- - // Make sure the parse went ok. - //-------------------------------------------------------------------- - void CheckParse(); - - //-------------------------------------------------------------------- - // Parse arguments after all options are consumed. - // This is called after a successful ParseArgs. - //-------------------------------------------------------------------- - virtual void ParseExtraArgs(); - - //-------------------------------------------------------------------- - // Print message describing which arguments and options are - // required, optional, mutually exclusive, ... - // called in ProgramOptions::Usage() method - //-------------------------------------------------------------------- - virtual void PrintUsage(ostream& stream) const; - -private: - string inputFileName; - string outputFileName; -}; - -//**************************************************************************/ - -#endif diff --git a/tools/llc/Makefile b/tools/llc/Makefile index a5b098c0736..adfd9c822bf 100644 --- a/tools/llc/Makefile +++ b/tools/llc/Makefile @@ -1,10 +1,4 @@ LEVEL = ../.. - -## List source files in link order -Source = \ - llc.o \ - LLCOptions.o - include $(LEVEL)/Makefile.common all:: llc diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp index 4bf26d5a16f..1ebfb5037e8 100644 --- a/tools/llc/llc.cpp +++ b/tools/llc/llc.cpp @@ -18,12 +18,15 @@ #include "llvm/CodeGen/InstrSelection.h" #include "llvm/LLC/CompileContext.h" #include "llvm/CodeGen/Sparc.h" -#include "LLCOptions.h" +#include "llvm/Tools/CommandLine.h" + +cl::String InputFilename ("", "Input filename", cl::NoFlags, ""); +cl::String OutputFilename("o", "Output filename", cl::NoFlags, ""); + CompileContext::~CompileContext() { delete targetMachine; } -static bool CompileModule(Module *module, CompileContext& ccontext, - LLCOptions &Options) { +static bool CompileModule(Module *module, CompileContext& ccontext) { bool failed = false; for (Module::MethodListType::const_iterator @@ -33,8 +36,7 @@ static bool CompileModule(Module *module, CompileContext& ccontext, { Method* method = *methodIter; - if (SelectInstructionsForMethod(method, ccontext, - Options.IntOptionValue(DEBUG_INSTR_SELECT_OPT))) + if (SelectInstructionsForMethod(method, ccontext)) { failed = true; cerr << "Instruction selection failed for method " @@ -52,28 +54,28 @@ static bool CompileModule(Module *module, CompileContext& ccontext, // Entry point for the driver. //--------------------------------------------------------------------------- -int main(int argc, const char** argv, const char** envp) { - LLCOptions Options(argc, argv, envp); +int main(int argc, char** argv) { + cl::ParseCommandLineOptions(argc, argv, " llvm system compiler\n"); CompileContext compileContext(new UltraSparc()); - - Module *module = ParseBytecodeFile(Options.getInputFileName()); + + Module *module = ParseBytecodeFile(InputFilename.getValue()); if (module == 0) { cerr << "bytecode didn't read correctly.\n"; return 1; } - bool failure = CompileModule(module, compileContext, Options); + bool failure = CompileModule(module, compileContext); if (failure) { cerr << "Error compiling " - << Options.getInputFileName() << "!\n"; + << InputFilename.getValue() << "!\n"; delete module; return 1; } // Okay, we're done now... write out result... // WriteBytecodeToFile(module, - // compileContext.getOptions().getOutputFileName); + // OutputFilename.getValue()); // Clean up and exit delete module; diff --git a/tools/llvm-as/Makefile b/tools/llvm-as/Makefile index 9d36cc1d007..fcb92935721 100644 --- a/tools/llvm-as/Makefile +++ b/tools/llvm-as/Makefile @@ -6,4 +6,4 @@ clean:: rm -f as as : $(ObjectsG) - $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore + $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore -lsupport diff --git a/tools/llvm-as/as.cpp b/tools/llvm-as/as.cpp index 2c319a08491..da05a36f7fc 100644 --- a/tools/llvm-as/as.cpp +++ b/tools/llvm-as/as.cpp @@ -18,54 +18,49 @@ #include "llvm/Bytecode/Writer.h" #include "llvm/Tools/CommandLine.h" +cl::String InputFilename ("", "Parse file, compile to bytecode", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::Flag DumpAsm ("d", "Print assembly as parsed", cl::Hidden, false); int main(int argc, char **argv) { - ToolCommandLine Opts(argc, argv); - bool DumpAsm = false; + cl::ParseCommandLineOptions(argc, argv, " llvm .ll -> .bc assembler\n"); - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("-d")) { - argv[i] = 0; DumpAsm = true; - } - } - - bool PrintMessage = false; - for (int i = 1; i < argc; i++) { - if (argv[i] == 0) continue; - - if (string(argv[i]) == string("--help")) { - PrintMessage = true; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - - if (PrintMessage) { - cerr << argv[0] << " usage:\n" - << " " << argv[0] << " --help - Print this usage information\n" - << " " << argv[0] << " x.ll - Parse file and output " - << "bytecodes to x.bc\n" - << " " << argv[0] << " - Parse stdin and write to stdout.\n"; - return 1; - } - - ostream *Out = &cout; // Default to output to stdout... + ostream *Out = 0; try { // Parse the file now... - Module *C = ParseAssemblyFile(Opts); + Module *C = ParseAssemblyFile(InputFilename.getValue()); if (C == 0) { cerr << "assembly didn't read correctly.\n"; return 1; } - if (DumpAsm) + if (DumpAsm.getValue()) cerr << "Here's the assembly:\n" << C; + + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); + Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') { + // Source ends in .ll + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .bc to it + } + OutputFilename.setValue(OutputFilename.getValue() + ".bc"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() << "!\n"; + cerr << "Error opening " << OutputFilename.getValue() << "!\n"; delete C; return 1; } diff --git a/tools/llvm-as/llvm-as.cpp b/tools/llvm-as/llvm-as.cpp index 2c319a08491..da05a36f7fc 100644 --- a/tools/llvm-as/llvm-as.cpp +++ b/tools/llvm-as/llvm-as.cpp @@ -18,54 +18,49 @@ #include "llvm/Bytecode/Writer.h" #include "llvm/Tools/CommandLine.h" +cl::String InputFilename ("", "Parse file, compile to bytecode", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::Flag DumpAsm ("d", "Print assembly as parsed", cl::Hidden, false); int main(int argc, char **argv) { - ToolCommandLine Opts(argc, argv); - bool DumpAsm = false; + cl::ParseCommandLineOptions(argc, argv, " llvm .ll -> .bc assembler\n"); - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("-d")) { - argv[i] = 0; DumpAsm = true; - } - } - - bool PrintMessage = false; - for (int i = 1; i < argc; i++) { - if (argv[i] == 0) continue; - - if (string(argv[i]) == string("--help")) { - PrintMessage = true; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - - if (PrintMessage) { - cerr << argv[0] << " usage:\n" - << " " << argv[0] << " --help - Print this usage information\n" - << " " << argv[0] << " x.ll - Parse file and output " - << "bytecodes to x.bc\n" - << " " << argv[0] << " - Parse stdin and write to stdout.\n"; - return 1; - } - - ostream *Out = &cout; // Default to output to stdout... + ostream *Out = 0; try { // Parse the file now... - Module *C = ParseAssemblyFile(Opts); + Module *C = ParseAssemblyFile(InputFilename.getValue()); if (C == 0) { cerr << "assembly didn't read correctly.\n"; return 1; } - if (DumpAsm) + if (DumpAsm.getValue()) cerr << "Here's the assembly:\n" << C; + + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); + Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') { + // Source ends in .ll + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .bc to it + } + OutputFilename.setValue(OutputFilename.getValue() + ".bc"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() << "!\n"; + cerr << "Error opening " << OutputFilename.getValue() << "!\n"; delete C; return 1; } diff --git a/tools/llvm-dis/Makefile b/tools/llvm-dis/Makefile index e6624ab5442..8ce3e2161c2 100644 --- a/tools/llvm-dis/Makefile +++ b/tools/llvm-dis/Makefile @@ -6,5 +6,5 @@ clean :: rm -f dis dis : $(ObjectsG) - $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore + $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore -lsupport diff --git a/tools/llvm-dis/dis.cpp b/tools/llvm-dis/dis.cpp index deaf3a28fd5..f243baadb0e 100644 --- a/tools/llvm-dis/dis.cpp +++ b/tools/llvm-dis/dis.cpp @@ -25,69 +25,67 @@ #include "llvm/Method.h" #include "llvm/CFG.h" -int main(int argc, char **argv) { - // WriteMode - The different orderings to print basic blocks in... - enum { - Default = 0, // Method Order (list order) - DepthFirst, // Depth First ordering - ReverseDepthFirst, // Reverse Depth First ordering - PostOrder, // Post Order - ReversePostOrder // Reverse Post Order - } WriteMode = Default; +// OutputMode - The different orderings to print basic blocks in... +enum OutputMode { + Default = 0, // Method Order (list order) + dfo, // Depth First ordering + rdfo, // Reverse Depth First ordering + po, // Post Order + rpo, // Reverse Post Order +}; - ToolCommandLine Opts(argc, argv, false); +cl::String InputFilename ("", "Load file, print as assembly", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::EnumFlags WriteMode(cl::NoFlags, + clEnumVal(Default, "Write bb's in bytecode order"), + clEnumVal(dfo , "Write bb's in depth first order"), + clEnumVal(rdfo , "Write bb's in reverse DFO"), + clEnumVal(po , "Write bb's in postorder"), + clEnumVal(rpo , "Write bb's in reverse postorder"), 0); - // We only support the options that the system parser does... if it left any - // then we don't know what to do. - // - if (argc > 1) { - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << "\tx.bc - Parse file and output to x.ll\n" - << "\tno .bc file - Parse stdin and write to stdout.\n" - << "\t-dfo - Write basic blocks in depth first order.\n" - << "\t-rdfo - Write basic blocks in reverse DFO.\n" - << "\t-po - Write basic blocks in postorder.\n" - << "\t-rpo - Write basic blocks in reverse postorder.\n" - << "\t--help - Print this usage information\n\n"; - return 1; - } else if (string(argv[i]) == string("-dfo")) { - WriteMode = DepthFirst; - } else if (string(argv[i]) == string("-rdfo")) { - WriteMode = ReverseDepthFirst; - } else if (string(argv[i]) == string("-po")) { - WriteMode = PostOrder; - } else if (string(argv[i]) == string("-rpo")) { - WriteMode = ReversePostOrder; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - } - +int main(int argc, char **argv) { + cl::ParseCommandLineOptions(argc, argv, " llvm .bc -> .ll disassembler\n"); ostream *Out = &cout; // Default to printing to stdout... - Module *C = ParseBytecodeFile(Opts.getInputFilename()); + Module *C = ParseBytecodeFile(InputFilename.getValue()); if (C == 0) { cerr << "bytecode didn't read correctly.\n"; return 1; } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); - if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() - << ": sending to stdout instead!\n"; + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { + // Source ends in .bc + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .ll to it } + OutputFilename.setValue(OutputFilename.getValue() + ".ll"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } } - + + if (!Out->good()) { + cerr << "Error opening " << OutputFilename.getValue() + << ": sending to stdout instead!\n"; + Out = &cout; + } + // All that dis does is write the assembly out to a file... which is exactly // what the writer library is supposed to do... // - if (WriteMode == Default) { + if (WriteMode.getValue() == Default) { (*Out) << C; // Print out in list order } else { // TODO: This does not print anything other than the basic blocks in the @@ -98,20 +96,20 @@ int main(int argc, char **argv) { Method *M = *I; (*Out) << "-------------- Method: " << M->getName() << " -------------\n"; - switch (WriteMode) { - case DepthFirst: // Depth First ordering + switch (WriteMode.getValue()) { + case dfo: // Depth First ordering copy(cfg::df_begin(M), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case ReverseDepthFirst: // Reverse Depth First ordering + case rdfo: // Reverse Depth First ordering copy(cfg::df_begin(M, true), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case PostOrder: // Post Order + case po: // Post Order copy(cfg::po_begin(M), cfg::po_end(M), ostream_iterator(*Out, "\n")); break; - case ReversePostOrder: { // Reverse Post Order + case rpo: { // Reverse Post Order cfg::ReversePostOrderTraversal RPOT(M); copy(RPOT.begin(), RPOT.end(), ostream_iterator(*Out, "\n")); diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp index deaf3a28fd5..f243baadb0e 100644 --- a/tools/llvm-dis/llvm-dis.cpp +++ b/tools/llvm-dis/llvm-dis.cpp @@ -25,69 +25,67 @@ #include "llvm/Method.h" #include "llvm/CFG.h" -int main(int argc, char **argv) { - // WriteMode - The different orderings to print basic blocks in... - enum { - Default = 0, // Method Order (list order) - DepthFirst, // Depth First ordering - ReverseDepthFirst, // Reverse Depth First ordering - PostOrder, // Post Order - ReversePostOrder // Reverse Post Order - } WriteMode = Default; +// OutputMode - The different orderings to print basic blocks in... +enum OutputMode { + Default = 0, // Method Order (list order) + dfo, // Depth First ordering + rdfo, // Reverse Depth First ordering + po, // Post Order + rpo, // Reverse Post Order +}; - ToolCommandLine Opts(argc, argv, false); +cl::String InputFilename ("", "Load file, print as assembly", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::EnumFlags WriteMode(cl::NoFlags, + clEnumVal(Default, "Write bb's in bytecode order"), + clEnumVal(dfo , "Write bb's in depth first order"), + clEnumVal(rdfo , "Write bb's in reverse DFO"), + clEnumVal(po , "Write bb's in postorder"), + clEnumVal(rpo , "Write bb's in reverse postorder"), 0); - // We only support the options that the system parser does... if it left any - // then we don't know what to do. - // - if (argc > 1) { - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << "\tx.bc - Parse file and output to x.ll\n" - << "\tno .bc file - Parse stdin and write to stdout.\n" - << "\t-dfo - Write basic blocks in depth first order.\n" - << "\t-rdfo - Write basic blocks in reverse DFO.\n" - << "\t-po - Write basic blocks in postorder.\n" - << "\t-rpo - Write basic blocks in reverse postorder.\n" - << "\t--help - Print this usage information\n\n"; - return 1; - } else if (string(argv[i]) == string("-dfo")) { - WriteMode = DepthFirst; - } else if (string(argv[i]) == string("-rdfo")) { - WriteMode = ReverseDepthFirst; - } else if (string(argv[i]) == string("-po")) { - WriteMode = PostOrder; - } else if (string(argv[i]) == string("-rpo")) { - WriteMode = ReversePostOrder; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } - } - } - +int main(int argc, char **argv) { + cl::ParseCommandLineOptions(argc, argv, " llvm .bc -> .ll disassembler\n"); ostream *Out = &cout; // Default to printing to stdout... - Module *C = ParseBytecodeFile(Opts.getInputFilename()); + Module *C = ParseBytecodeFile(InputFilename.getValue()); if (C == 0) { cerr << "bytecode didn't read correctly.\n"; return 1; } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); - if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() - << ": sending to stdout instead!\n"; + if (OutputFilename.getValue() != "") { // Specified an output filename? + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } else { + if (InputFilename.getValue() == "-") { + OutputFilename.setValue("-"); Out = &cout; + } else { + string IFN = InputFilename.getValue(); + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { + // Source ends in .bc + OutputFilename.setValue(string(IFN.begin(), IFN.end()-3)); + } else { + OutputFilename.setValue(IFN); // Append a .ll to it } + OutputFilename.setValue(OutputFilename.getValue() + ".ll"); + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); + } } - + + if (!Out->good()) { + cerr << "Error opening " << OutputFilename.getValue() + << ": sending to stdout instead!\n"; + Out = &cout; + } + // All that dis does is write the assembly out to a file... which is exactly // what the writer library is supposed to do... // - if (WriteMode == Default) { + if (WriteMode.getValue() == Default) { (*Out) << C; // Print out in list order } else { // TODO: This does not print anything other than the basic blocks in the @@ -98,20 +96,20 @@ int main(int argc, char **argv) { Method *M = *I; (*Out) << "-------------- Method: " << M->getName() << " -------------\n"; - switch (WriteMode) { - case DepthFirst: // Depth First ordering + switch (WriteMode.getValue()) { + case dfo: // Depth First ordering copy(cfg::df_begin(M), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case ReverseDepthFirst: // Reverse Depth First ordering + case rdfo: // Reverse Depth First ordering copy(cfg::df_begin(M, true), cfg::df_end(M), ostream_iterator(*Out, "\n")); break; - case PostOrder: // Post Order + case po: // Post Order copy(cfg::po_begin(M), cfg::po_end(M), ostream_iterator(*Out, "\n")); break; - case ReversePostOrder: { // Reverse Post Order + case rpo: { // Reverse Post Order cfg::ReversePostOrderTraversal RPOT(M); copy(RPOT.begin(), RPOT.end(), ostream_iterator(*Out, "\n")); diff --git a/tools/opt/Makefile b/tools/opt/Makefile index 4a14d372e5a..658b2998ec8 100644 --- a/tools/opt/Makefile +++ b/tools/opt/Makefile @@ -7,4 +7,4 @@ clean :: opt : $(ObjectsG) ../../lib/Optimizations/Debug/libopt.a $(LinkG) -o $@ $(ObjectsG) -lopt -lbcreader -lbcwriter \ - -lasmwriter -lanalysis -lvmcore + -lasmwriter -lanalysis -lvmcore -lsupport diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index 70c2efeff84..2b5b0691065 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -29,70 +29,81 @@ using namespace opt; +enum Opts { + // Basic optimizations + dce, constprop, inlining, strip, mstrip, + + // More powerful optimizations + indvars, sccp, cpm, adce, raise, +}; + struct { - const string ArgName, Name; + enum Opts OptID; bool (*OptPtr)(Module *C); } OptTable[] = { - { "-dce" , "Dead Code Elimination", DoDeadCodeElimination }, - { "-constprop" , "Constant Propogation", DoConstantPropogation }, - { "-inline" , "Method Inlining", DoMethodInlining }, - { "-strip" , "Strip Symbols", DoSymbolStripping }, - { "-mstrip" , "Strip Module Symbols", DoFullSymbolStripping }, - { "-indvars" , "Simplify Induction Vars",DoInductionVariableCannonicalize }, - { "-sccp" , "Sparse Conditional Constant Prop", DoSCCP }, - { "-cpm" , "Constant Pool Merging", DoConstantPoolMerging }, - { "-adce" , "Agressive DCE", DoADCE }, - { "-raise" , "Raise to Higher Level", DoRaiseRepresentation }, + { dce , DoDeadCodeElimination }, + { constprop, DoConstantPropogation }, + { inlining , DoMethodInlining }, + { strip , DoSymbolStripping }, + { mstrip , DoFullSymbolStripping }, + { indvars , DoInductionVariableCannonicalize }, + { sccp , DoSCCP }, + { cpm , DoConstantPoolMerging }, + { adce , DoADCE }, + { raise , DoRaiseRepresentation }, }; -int main(int argc, char **argv) { - ToolCommandLine Opts(argc, argv, false); - bool Quiet = false; +cl::String InputFilename ("", "Load file to optimize", 0, "-"); +cl::String OutputFilename("o", "Override output filename", 0, ""); +cl::Flag Force ("f", "Overwrite output files", 0, false); +cl::Flag Quiet ("q", "Don't print modifying pass names", 0, false); +cl::EnumList OptimizationList(cl::NoFlags, + clEnumVal(dce , "Dead Code Elimination"), + clEnumVal(constprop, "Simple Constant Propogation"), + clEnumValN(inlining , "inline", "Method Inlining"), + clEnumVal(strip , "Strip Symbols"), + clEnumVal(mstrip , "Strip Module Symbols"), + clEnumVal(indvars , "Simplify Induction Variables"), + clEnumVal(sccp , "Sparse Conditional Constant Propogation"), + clEnumVal(cpm , "Constant Pool Merging"), + clEnumVal(adce , "Agressive DCE"), + clEnumVal(raise , "Raise to Higher Level"), +0); - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << " " << argv[0] << " --help - Print this usage information\n"; - for (unsigned j = 0; j < sizeof(OptTable)/sizeof(OptTable[0]); ++j) { - cerr << "\t" << OptTable[j].ArgName << "\t - Enable " - << OptTable[j].Name << endl; - } - return 1; - } else if (string(argv[i]) == string("-q")) { - Quiet = true; argv[i] = 0; - } - } - - ostream *Out = &cout; // Default to printing to stdout... - Module *C = ParseBytecodeFile(Opts.getInputFilename()); +int main(int argc, char **argv) { + cl::ParseCommandLineOptions(argc, argv, + " llvm .bc -> .bc modular optimizer\n"); + + Module *C = ParseBytecodeFile(InputFilename.getValue()); if (C == 0) { cerr << "bytecode didn't read correctly.\n"; return 1; } + for (unsigned i = 0; i < OptimizationList.size(); ++i) { + enum Opts Opt = OptimizationList[i]; - for (int i = 1; i < argc; i++) { - if (argv[i] == 0) continue; unsigned j; - for (j = 0; j < sizeof(OptTable)/sizeof(OptTable[0]); j++) { - if (string(argv[i]) == OptTable[j].ArgName) { + for (j = 0; j < sizeof(OptTable)/sizeof(OptTable[0]); ++j) { + if (Opt == OptTable[j].OptID) { if (OptTable[j].OptPtr(C) && !Quiet) - cerr << OptTable[j].Name << " pass made modifications!\n"; + cerr << OptimizationList.getArgName(Opt) + << " pass made modifications!\n"; break; } } if (j == sizeof(OptTable)/sizeof(OptTable[0])) - cerr << "'" << argv[i] << "' argument unrecognized: ignored\n"; + cerr << "Optimization tables inconsistent!!\n"; } - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); + ostream *Out = &cout; // Default to printing to stdout... + if (OutputFilename.getValue() != "") { + Out = new ofstream(OutputFilename.getValue().c_str(), + (Force.getValue() ? 0 : ios::noreplace)|ios::out); if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() - << "!\n"; + cerr << "Error opening " << OutputFilename.getValue() << "!\n"; delete C; return 1; } diff --git a/tools/opt/test.sh b/tools/opt/test.sh deleted file mode 100755 index b6d13f44672..00000000000 --- a/tools/opt/test.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/sh - -../as/as < ../../test/$1 | ./opt -constprop -dce | ../dis/dis - diff --git a/tools/opt/testinline.sh b/tools/opt/testinline.sh deleted file mode 100755 index ff16a666f5c..00000000000 --- a/tools/opt/testinline.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh - -../as/as < ../../test/$1 | ./opt -inline -constprop -dce | dis diff --git a/tools/opt/teststrip.sh b/tools/opt/teststrip.sh deleted file mode 100755 index 2cff3bfd6ab..00000000000 --- a/tools/opt/teststrip.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh - -../as/as < ../../test/$1 | ./opt -strip | dis