X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=656d718e385a0934f2f4c6336577a68fefd59fab;hb=05dcf353fc6165cd75beaa5e46abff8d1f23517c;hp=31c0b24144d482618656887a7beeb727abf851a1;hpb=eb5ff8d51785d996c406be8216d3f7c3ebfa6c60;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 31c0b24144d..656d718e385 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -8,27 +8,24 @@ #ifndef PARSER_INTERNALS_H #define PARSER_INTERNALS_H -#include #define __STDC_LIMIT_MACROS - -#include "llvm/InstrTypes.h" #include "llvm/BasicBlock.h" -#include "llvm/ConstPoolVals.h" +#include "llvm/Constants.h" #include "llvm/iOther.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/DerivedTypes.h" #include "llvm/Assembly/Parser.h" -#include "llvm/Support/StringExtras.h" +#include "Support/StringExtras.h" class Module; // Global variables exported from the lexer... -extern FILE *llvmAsmin; +extern std::FILE *llvmAsmin; extern int llvmAsmlineno; // Globals exported by the parser... -extern string CurFilename; -Module *RunVMAsmParser(const string &Filename, FILE *F); +extern std::string CurFilename; +Module *RunVMAsmParser(const std::string &Filename, FILE *F); // UnEscapeLexed - Run through the specified buffer and change \xx codes to the @@ -47,7 +44,7 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false); // This also helps me because I keep typing 'throw new ParseException' instead // of just 'throw ParseException'... sigh... // -static inline void ThrowException(const string &message, +static inline void ThrowException(const std::string &message, int LineNo = -1) { if (LineNo == -1) LineNo = llvmAsmlineno; // TODO: column number in exception @@ -63,9 +60,10 @@ static inline void ThrowException(const string &message, // putting classes with ctor's in unions. :( // struct ValID { - int Type; // 0 = number, 1 = name, 2 = const pool, - // 3 = unsigned const pool, 4 = const string, - // 5 = const fp + enum { + NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal + } Type; + union { int Num; // If it's a numeric reference char *Name; // If it's a named reference. Memory must be free'd. @@ -75,47 +73,66 @@ struct ValID { }; static ValID create(int Num) { - ValID D; D.Type = 0; D.Num = Num; return D; + ValID D; D.Type = NumberVal; D.Num = Num; return D; } static ValID create(char *Name) { - ValID D; D.Type = 1; D.Name = Name; return D; + ValID D; D.Type = NameVal; D.Name = Name; return D; } static ValID create(int64_t Val) { - ValID D; D.Type = 2; D.ConstPool64 = Val; return D; + ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D; } static ValID create(uint64_t Val) { - ValID D; D.Type = 3; D.UConstPool64 = Val; return D; + ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D; } - static ValID create_conststr(char *Name) { - ValID D; D.Type = 4; D.Name = Name; return D; + static ValID create(double Val) { + ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D; } - static ValID create(double Val) { - ValID D; D.Type = 5; D.ConstPoolFP = Val; return D; + static ValID createNull() { + ValID D; D.Type = ConstNullVal; return D; } inline void destroy() const { - if (Type == 1 || Type == 4) free(Name); // Free this strdup'd memory... + if (Type == NameVal) + free(Name); // Free this strdup'd memory... } inline ValID copy() const { - if (Type != 1 && Type != 4) return *this; + if (Type != NameVal) return *this; ValID Result = *this; Result.Name = strdup(Name); return Result; } - inline string getName() const { + inline std::string getName() const { + switch (Type) { + case NumberVal : return std::string("#") + itostr(Num); + case NameVal : return Name; + case ConstFPVal : return ftostr(ConstPoolFP); + case ConstNullVal : return "null"; + case ConstUIntVal : + case ConstSIntVal : return std::string("%") + itostr(ConstPool64); + default: + assert(0 && "Unknown value!"); + abort(); + return ""; + } + } + + bool operator<(const ValID &V) const { + if (Type != V.Type) return Type < V.Type; switch (Type) { - case 0: return string("#") + itostr(Num); - case 1: return Name; - case 4: return string("\"") + Name + string("\""); - case 5: return ftostr(ConstPoolFP); - default: return string("%") + itostr(ConstPool64); + case NumberVal: return Num < V.Num; + case NameVal: return strcmp(Name, V.Name) < 0; + case ConstSIntVal: return ConstPool64 < V.ConstPool64; + case ConstUIntVal: return UConstPool64 < V.UConstPool64; + case ConstFPVal: return ConstPoolFP < V.ConstPoolFP; + case ConstNullVal: return false; + default: assert(0 && "Unknown value type!"); return false; } } }; @@ -134,52 +151,47 @@ public: int getLineNum() const { return LineNum; } }; -struct TypePlaceHolderHelper : public OpaqueType { - TypePlaceHolderHelper(const Type *Ty) : OpaqueType() { - assert(Ty == Type::TypeTy); - } -}; - - struct InstPlaceHolderHelper : public Instruction { InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {} - virtual Instruction *clone() const { abort(); } + virtual Instruction *clone() const { abort(); return 0; } virtual const char *getOpcodeName() const { return "placeholder"; } }; struct BBPlaceHolderHelper : public BasicBlock { BBPlaceHolderHelper(const Type *Ty) : BasicBlock() { - assert(Ty->isLabelType()); + assert(Ty == Type::LabelTy); } }; -struct MethPlaceHolderHelper : public Method { - MethPlaceHolderHelper(const Type *Ty) - : Method((const MethodType*)Ty) { - assert(Ty->isMethodType() && "Method placeholders must be method types!"); - } +struct MethPlaceHolderHelper : public Function { + MethPlaceHolderHelper(const Type *Ty) + : Function(cast(Ty), true) {} }; -typedef PlaceholderValue TypePlaceHolder; typedef PlaceholderValue ValuePlaceHolder; typedef PlaceholderValue BBPlaceHolder; -typedef PlaceholderValue MethPlaceHolder; static inline ValID &getValIDFromPlaceHolder(const Value *Val) { - switch (Val->getType()->getPrimitiveID()) { - case Type::TypeTyID: return ((TypePlaceHolder*)Val)->getDef(); + const Type *Ty = Val->getType(); + if (isa(Ty) && + isa(cast(Ty)->getElementType())) + Ty = cast(Ty)->getElementType(); + + switch (Ty->getPrimitiveID()) { case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getDef(); - case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getDef(); default: return ((ValuePlaceHolder*)Val)->getDef(); } } static inline int getLineNumFromPlaceHolder(const Value *Val) { - switch (Val->getType()->getPrimitiveID()) { - case Type::TypeTyID: return ((TypePlaceHolder*)Val)->getLineNum(); + const Type *Ty = Val->getType(); + if (isa(Ty) && + isa(cast(Ty)->getElementType())) + Ty = cast(Ty)->getElementType(); + + switch (Ty->getPrimitiveID()) { case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getLineNum(); - case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getLineNum(); default: return ((ValuePlaceHolder*)Val)->getLineNum(); } }