#include <string>
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
//
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);
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
}
private :
- const ToolCommandLine &Opts;
+ string Filename;
string Message;
int LineNo, ColumnNo; // -1 if not relevant
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.
//---------------------------------------------------------------------------
bool SelectInstructionsForMethod (Method* method,
- CompileContext& ccontext,
- int DebugLevel);
+ CompileContext& ccontext);
// Debugging function to print the generated instructions
+++ /dev/null
-// $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 <string>
-
-
-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 <optArg> 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;
-};
-
-//**************************************************************************/
-
-// -<flag_opt> sets the flag to TRUE
-// -<flag_opt> 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
+++ /dev/null
-// $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 <vector>
-#include <hash_map>
-#include <string>
-
-template <> struct hash<string> {
- size_t operator()(string const &str) const {
- return hash<char const *>()(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<string> 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<string, ProgramOption*>::iterator hp =
- optionRegistry.find(optString);
- return (hp != optionRegistry.end()) ? hp->second : 0;
- }
- inline const ProgramOption* OptionHandler(const string &optString) const {
- hash_map<string, ProgramOption*>::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<string, ProgramOption*> optionRegistry;
- int argc;
- const char** argv;
- const char** envp;
- int argsConsumed;
-};
-
-//**************************************************************************/
-
-#endif
//===-- 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.
//
//===----------------------------------------------------------------------===//
#define LLVM_TOOLS_COMMANDLINE_H
#include <string>
+#include <vector>
+#include <utility>
+#include <stdarg.h>
+
+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<pair<const char *, pair<int, const char *> > > 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 <class E> // 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 <class E> // 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<int> 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 <class E> // 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
//***************************************************************************
-//*************************** User Include Files ***************************/
-
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#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<enum DebugLev> 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 ***************************/
// 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;
// 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";
if (!failed)
{
- if (DebugLevel >= DEBUG_INSTR_TREES)
+ if (DebugLevel.getValue() >= DebugInstTrees)
{
cout << "\n\n*** Instruction trees for method "
<< (method->hasName()? method->getName() : "")
instrForest.dump();
}
- if (DebugLevel >= DEBUG_TREES_NONE)
+ if (DebugLevel.getValue() > NoDebugInfo)
PrintMachineInstructions(method);
}
LIBRARYNAME = support
-## List source files in link order
-Source = \
- ProgramOption.o \
- ProgramOptions.o
-
include $(LEVEL)/Makefile.common
//***************************************************************************
-//*************************** User Include Files ***************************/
-
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Method.h"
#include "llvm/BasicBlock.h"
#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<enum DebugLev> 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 ***************************/
// 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;
// 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";
if (!failed)
{
- if (DebugLevel >= DEBUG_INSTR_TREES)
+ if (DebugLevel.getValue() >= DebugInstTrees)
{
cout << "\n\n*** Instruction trees for method "
<< (method->hasName()? method->getName() : "")
instrForest.dump();
}
- if (DebugLevel >= DEBUG_TREES_NONE)
+ if (DebugLevel.getValue() > NoDebugInfo)
PrintMachineInstructions(method);
}
LIBRARYNAME = support
-## List source files in link order
-Source = \
- ProgramOption.o \
- ProgramOptions.o
-
include $(LEVEL)/Makefile.common
+++ /dev/null
-// $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 <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-//**************************************************************************/
-
-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;
-}
-
-
+++ /dev/null
-// $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 <iostream.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string>
-#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<string>
-ProgramOptions::GetDescription() const
-{
- vector<string> optDesc;
-
- if (optDesc.size() < (unsigned) argc)
- {
- for (hash_map<string,ProgramOption*>::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: "
- << "-<flag_opt> 0" << endl << endl;
-
- for (hash_map<string,ProgramOption*>::const_iterator iter = optionRegistry.begin();
- iter != optionRegistry.end(); ++iter) {
- const ProgramOption* handler = (*iter).second;
-
- stream << "\t-" << handler->ArgString();
-
- const char* const showarg = " <arg>";
- 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);
-}
-
-
-//**************************************************************************/
analyze : $(ObjectsG) Debug/.dir Depend/.dir $(LIBDEPS)
$(LinkG) -o $@ $(ObjectsG) -lopt -lasmparser \
- -lbcreader -lvmcore -lasmwriter -lanalysis -lopt
+ -lbcreader -lvmcore -lasmwriter -lanalysis \
+ -lopt -lsupport
cout << cfg::DominanceFrontier(cfg::DominatorSet(M, true));
}
+enum Ans {
+ print, intervals, exprclassify,
+ domset, idom, domtree, domfrontier,
+ postdomset, postidom, postdomtree, postdomfrontier,
+};
+
+cl::String InputFilename ("", "Load <arg> file to analyze", 0, "-");
+cl::Flag Quiet ("q", "Don't print analysis pass names", 0, false);
+cl::EnumList<enum Ans> 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;
}
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";
}
}
rm -f as
as : $(ObjectsG)
- $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore
+ $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore -lsupport
#include "llvm/Bytecode/Writer.h"
#include "llvm/Tools/CommandLine.h"
+cl::String InputFilename ("", "Parse <arg> 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 <x.ll> 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;
}
rm -f dis
dis : $(ObjectsG)
- $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore
+ $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore -lsupport
#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 <arg> file, print as assembly", 0, "-");
+cl::String OutputFilename("o", "Override output filename", 0, "");
+cl::Flag Force ("f", "Overwrite output files", 0, false);
+cl::EnumFlags<enum OutputMode> 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 <x.bc> 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
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<BasicBlock*>(*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<BasicBlock*>(*Out, "\n"));
break;
- case PostOrder: // Post Order
+ case po: // Post Order
copy(cfg::po_begin(M), cfg::po_end(M),
ostream_iterator<BasicBlock*>(*Out, "\n"));
break;
- case ReversePostOrder: { // Reverse Post Order
+ case rpo: { // Reverse Post Order
cfg::ReversePostOrderTraversal RPOT(M);
copy(RPOT.begin(), RPOT.end(),
ostream_iterator<BasicBlock*>(*Out, "\n"));
+++ /dev/null
-// $Id$
-//**************************************************************************/
-// File:
-// LLCOptions.cpp
-//
-// Purpose:
-// Options for the llc compiler.
-//
-// History:
-// 7/15/01 - Vikram Adve - Created
-//
-//**************************************************************************/
-
-//************************** System Include Files **************************/
-
-#include <iostream.h>
-#include <unistd.h>
-
-
-//*************************** 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);
-}
-
-
+++ /dev/null
-// $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
LEVEL = ../..
-
-## List source files in link order
-Source = \
- llc.o \
- LLCOptions.o
-
include $(LEVEL)/Makefile.common
all:: llc
#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
{
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 "
// 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;
rm -f as
as : $(ObjectsG)
- $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore
+ $(LinkG) -o as $(ObjectsG) -lasmparser -lbcwriter -lasmwriter -lanalysis -lvmcore -lsupport
#include "llvm/Bytecode/Writer.h"
#include "llvm/Tools/CommandLine.h"
+cl::String InputFilename ("", "Parse <arg> 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 <x.ll> 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;
}
#include "llvm/Bytecode/Writer.h"
#include "llvm/Tools/CommandLine.h"
+cl::String InputFilename ("", "Parse <arg> 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 <x.ll> 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;
}
rm -f dis
dis : $(ObjectsG)
- $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore
+ $(LinkG) -o $@ $(ObjectsG) -lbcreader -lasmwriter -lanalysis -lvmcore -lsupport
#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 <arg> file, print as assembly", 0, "-");
+cl::String OutputFilename("o", "Override output filename", 0, "");
+cl::Flag Force ("f", "Overwrite output files", 0, false);
+cl::EnumFlags<enum OutputMode> 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 <x.bc> 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
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<BasicBlock*>(*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<BasicBlock*>(*Out, "\n"));
break;
- case PostOrder: // Post Order
+ case po: // Post Order
copy(cfg::po_begin(M), cfg::po_end(M),
ostream_iterator<BasicBlock*>(*Out, "\n"));
break;
- case ReversePostOrder: { // Reverse Post Order
+ case rpo: { // Reverse Post Order
cfg::ReversePostOrderTraversal RPOT(M);
copy(RPOT.begin(), RPOT.end(),
ostream_iterator<BasicBlock*>(*Out, "\n"));
#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 <arg> file, print as assembly", 0, "-");
+cl::String OutputFilename("o", "Override output filename", 0, "");
+cl::Flag Force ("f", "Overwrite output files", 0, false);
+cl::EnumFlags<enum OutputMode> 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 <x.bc> 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
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<BasicBlock*>(*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<BasicBlock*>(*Out, "\n"));
break;
- case PostOrder: // Post Order
+ case po: // Post Order
copy(cfg::po_begin(M), cfg::po_end(M),
ostream_iterator<BasicBlock*>(*Out, "\n"));
break;
- case ReversePostOrder: { // Reverse Post Order
+ case rpo: { // Reverse Post Order
cfg::ReversePostOrderTraversal RPOT(M);
copy(RPOT.begin(), RPOT.end(),
ostream_iterator<BasicBlock*>(*Out, "\n"));
opt : $(ObjectsG) ../../lib/Optimizations/Debug/libopt.a
$(LinkG) -o $@ $(ObjectsG) -lopt -lbcreader -lbcwriter \
- -lasmwriter -lanalysis -lvmcore
+ -lasmwriter -lanalysis -lvmcore -lsupport
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 <arg> 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<enum Opts> 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;
}
+++ /dev/null
-#!/bin/sh
-
-../as/as < ../../test/$1 | ./opt -constprop -dce | ../dis/dis
-
+++ /dev/null
-#!/bin/sh
-
-../as/as < ../../test/$1 | ./opt -inline -constprop -dce | dis
+++ /dev/null
-#!/bin/sh
-
-../as/as < ../../test/$1 | ./opt -strip | dis
projects / oota-llvm.git / commitdiff