X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=76052fa5410199a19b451efe2471a56cffe11646;hb=cee8f9ae67104576b2028125b56e9ba4856a1d66;hp=d9f34440b850b4ce9957dd0b36ddcccf7a941c04;hpb=3d52b2fdcc07ce26c61adf99822adfa8251696cc;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index d9f34440b85..76052fa5410 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -16,10 +16,9 @@ #include "llvm/ConstPoolVals.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/CommandLine.h" -#include "llvm/Tools/StringExtras.h" +#include "Support/StringExtras.h" class Module; @@ -28,8 +27,18 @@ extern FILE *llvmAsmin; extern int llvmAsmlineno; // Globals exported by the parser... -extern const ToolCommandLine *CurOptions; -Module *RunVMAsmParser(const ToolCommandLine &Opts, FILE *F); +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 @@ -38,9 +47,11 @@ Module *RunVMAsmParser(const ToolCommandLine &Opts, FILE *F); // 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(*CurOptions, message, llvmAsmlineno); + throw ParseException(CurFilename, message, LineNo); } // ValID - Represents a reference of a definition of some sort. This may either @@ -52,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. @@ -64,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; @@ -100,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; } } }; @@ -112,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 { @@ -135,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)->getValueType())) + Ty = cast(Ty)->getValueType(); + + 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)->getValueType())) + Ty = cast(Ty)->getValueType(); + + switch (Ty->getPrimitiveID()) { + case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getLineNum(); + default: return ((ValuePlaceHolder*)Val)->getLineNum(); } }