X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=656d718e385a0934f2f4c6336577a68fefd59fab;hb=05dcf353fc6165cd75beaa5e46abff8d1f23517c;hp=1f6bafce1500fd9d4416816447eeddb11d26bf01;hpb=bcbf6baf10c34086594bc03f0002a8977cd66941;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 1f6bafce150..656d718e385 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -8,27 +8,34 @@ #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/Type.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 +// 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 @@ -37,9 +44,11 @@ Module *RunVMAsmParser(const string &Filename, 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 std::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 +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. @@ -63,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; } } }; @@ -111,46 +140,59 @@ 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 { 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 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(); } }