X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=750833fae83cde59b9dd020333840aa10d3d5a9c;hb=7a1767520611d9ff6face702068de858e1cadf2c;hp=5d97bc605d56dcbdff5fa59ebbe6380f1e0e0639;hpb=a28504313d4c3fe87173a71b511dd4c8e25c3312;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 5d97bc605d5..750833fae83 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -13,12 +13,12 @@ #include "llvm/InstrTypes.h" #include "llvm/BasicBlock.h" -#include "llvm/ConstPoolVals.h" +#include "llvm/ConstantVals.h" #include "llvm/iOther.h" #include "llvm/Method.h" -#include "llvm/Type.h" +#include "llvm/DerivedTypes.h" #include "llvm/Assembly/Parser.h" -#include "llvm/Tools/StringExtras.h" +#include "Support/StringExtras.h" class Module; @@ -31,15 +31,27 @@ extern string CurFilename; Module *RunVMAsmParser(const string &Filename, FILE *F); +// UnEscapeLexed - Run through the specified buffer and change \xx codes to the +// appropriate character. If AllowNull is set to false, a \00 value will cause +// an exception to be thrown. +// +// If AllowNull is set to true, the return value of the function points to the +// last character of the string in memory. +// +char *UnEscapeLexed(char *Buffer, bool AllowNull = false); + + // ThrowException - Wrapper around the ParseException class that automatically // fills in file line number and column number and options info. // // 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 string &message, + int LineNo = -1) { + if (LineNo == -1) LineNo = llvmAsmlineno; // TODO: column number in exception - throw ParseException(CurFilename, message, llvmAsmlineno); + throw ParseException(CurFilename, message, LineNo); } // ValID - Represents a reference of a definition of some sort. This may either @@ -51,9 +63,11 @@ 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, ConstStringVal, + 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. @@ -63,35 +77,40 @@ 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; + ValID D; D.Type = ConstStringVal; D.Name = Name; return D; } static ValID create(double Val) { - ValID D; D.Type = 5; D.ConstPoolFP = Val; return D; + ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D; } - inline void destroy() { - if (Type == 1 || Type == 4) free(Name); // Free this strdup'd memory... + static ValID createNull() { + ValID D; D.Type = ConstNullVal; return D; + } + + inline void destroy() const { + if (Type == NameVal || Type == ConstStringVal) + free(Name); // Free this strdup'd memory... } inline ValID copy() const { - if (Type != 1 && Type != 4) return *this; + if (Type != NameVal && Type != ConstStringVal) return *this; ValID Result = *this; Result.Name = strdup(Name); return Result; @@ -99,11 +118,30 @@ struct ValID { inline string getName() const { 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 string("#") + itostr(Num); + case NameVal : return Name; + case ConstStringVal: return string("\"") + Name + string("\""); + case ConstFPVal : return ftostr(ConstPoolFP); + case ConstNullVal : return "null"; + case ConstUIntVal : + case ConstSIntVal : return string("%") + itostr(ConstPool64); + default: + assert(0 && "Unknown value!"); + abort(); + } + } + + bool operator<(const ValID &V) const { + if (Type != V.Type) return Type < V.Type; + switch (Type) { + case NumberVal: return Num < V.Num; + case ConstStringVal: + 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; } } }; @@ -111,13 +149,15 @@ struct ValID { template -class PlaceholderDef : public SuperType { +class PlaceholderValue : public SuperType { ValID D; - // TODO: Placeholder def should hold Line #/Column # of definition in case - // there is an error resolving the defintition! + int LineNum; public: - PlaceholderDef(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {} + PlaceholderValue(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) { + LineNum = llvmAsmlineno; + } ValID &getDef() { return D; } + int getLineNum() const { return LineNum; } }; struct InstPlaceHolderHelper : public Instruction { @@ -134,23 +174,34 @@ struct BBPlaceHolderHelper : public BasicBlock { }; struct MethPlaceHolderHelper : public Method { - MethPlaceHolderHelper(const Type *Ty) - : Method((const MethodType*)Ty) { - assert(Ty->isMethodType() && "Method placeholders must be method types!"); - } + MethPlaceHolderHelper(const Type *Ty) : Method(cast(Ty), + true) {} }; -typedef PlaceholderDef DefPlaceHolder; -typedef PlaceholderDef BBPlaceHolder; -typedef PlaceholderDef MethPlaceHolder; -//typedef PlaceholderDef ModulePlaceHolder; - -static inline ValID &getValIDFromPlaceHolder(Value *Def) { - switch (Def->getType()->getPrimitiveID()) { - case Type::LabelTyID: return ((BBPlaceHolder*)Def)->getDef(); - case Type::MethodTyID: return ((MethPlaceHolder*)Def)->getDef(); -//case Type::ModuleTyID: return ((ModulePlaceHolder*)Def)->getDef(); - default: return ((DefPlaceHolder*)Def)->getDef(); +typedef PlaceholderValue ValuePlaceHolder; +typedef PlaceholderValue BBPlaceHolder; + +static inline ValID &getValIDFromPlaceHolder(const Value *Val) { + 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(); + default: return ((ValuePlaceHolder*)Val)->getDef(); + } +} + +static inline int getLineNumFromPlaceHolder(const Value *Val) { + 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(); + default: return ((ValuePlaceHolder*)Val)->getLineNum(); } }