X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=8fd5031c05a42141610dbe7df7500f78d02dad04;hb=389056110f861ef8f5af5c3c10ddd854d260a0b8;hp=47696289daddb4dfa0d3bd9e1b21b9f2b68fb794;hpb=cf3056db0fee1db7921214b1f25cea04e959e105;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 47696289dad..8fd5031c05a 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -1,6 +1,13 @@ //===-- ParserInternals.h - Definitions internal to the parser --*- C++ -*-===// // -// This header file defines the various variables that are shared among the +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This header file defines the various variables that are shared among the // different components of the parser... // //===----------------------------------------------------------------------===// @@ -9,79 +16,89 @@ #define PARSER_INTERNALS_H #include "llvm/Constants.h" -#include "llvm/iOther.h" -#include "llvm/Function.h" #include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" +#include "llvm/Function.h" +#include "llvm/Instructions.h" #include "llvm/Assembly/Parser.h" -#include "Support/StringExtras.h" - -class Module; +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/APFloat.h" +namespace llvm { class MemoryBuffer; } // Global variables exported from the lexer... -extern std::FILE *llvmAsmin; -extern int llvmAsmlineno; -// Globals exported by the parser... -extern std::string CurFilename; -Module *RunVMAsmParser(const std::string &Filename, FILE *F); +extern llvm::ParseError* TheParseError; /// FIXME: Not threading friendly -extern char* llvmAsmtext; -extern int llvmAsmleng; +// functions exported from the lexer +void InitLLLexer(llvm::MemoryBuffer *MB); +const char *LLLgetTokenStart(); +unsigned LLLgetTokenLength(); +std::string LLLgetFilename(); +unsigned LLLgetLineNo(); +void FreeLexer(); -// 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); +namespace llvm { +class Module; +// RunVMAsmParser - Parse a buffer and return Module +Module *RunVMAsmParser(llvm::MemoryBuffer *MB); -// ThrowException - Wrapper around the ParseException class that automatically +// GenerateError - 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 +// This also helps me because I keep typing 'throw new ParseException' instead // of just 'throw ParseException'... sigh... // -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, LineNo); -} +extern void GenerateError(const std::string &message, int LineNo = -1); + +/// InlineAsmDescriptor - This is a simple class that holds info about inline +/// asm blocks, for use by ValID. +struct InlineAsmDescriptor { + std::string AsmString, Constraints; + bool HasSideEffects; + + InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE) + : AsmString(as), Constraints(c), HasSideEffects(HSE) {} +}; + // ValID - Represents a reference of a definition of some sort. This may either -// be a numeric reference or a symbolic (%var) reference. This is just a +// be a numeric reference or a symbolic (%var) reference. This is just a // discriminated union. // -// Note that I can't implement this class in a straight forward manner with -// constructors and stuff because it goes in a union, and GCC doesn't like -// putting classes with ctor's in unions. :( +// Note that I can't implement this class in a straight forward manner with +// constructors and stuff because it goes in a union. // struct ValID { enum { - NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal, - ConstantVal, + LocalID, GlobalID, LocalName, GlobalName, + ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal, + ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal } Type; union { - int Num; // If it's a numeric reference - char *Name; // If it's a named reference. Memory must be free'd. + unsigned Num; // If it's a numeric reference like %1234 + std::string *Name; // If it's a named reference. Memory must be deleted. int64_t ConstPool64; // Constant pool reference. This is the value uint64_t UConstPool64;// Unsigned constant pool reference. - double ConstPoolFP; // Floating point constant pool reference + APFloat *ConstPoolFP; // Floating point constant pool reference Constant *ConstantValue; // Fully resolved constant for ConstantVal case. - }; + InlineAsmDescriptor *IAD; + }; - static ValID create(int Num) { - ValID D; D.Type = NumberVal; D.Num = Num; return D; + static ValID createLocalID(unsigned Num) { + ValID D; D.Type = LocalID; D.Num = Num; return D; } - - static ValID create(char *Name) { - ValID D; D.Type = NameVal; D.Name = Name; return D; + static ValID createGlobalID(unsigned Num) { + ValID D; D.Type = GlobalID; D.Num = Num; return D; } - + static ValID createLocalName(const std::string &Name) { + ValID D; D.Type = LocalName; D.Name = new std::string(Name); return D; + } + static ValID createGlobalName(const std::string &Name) { + ValID D; D.Type = GlobalName; D.Name = new std::string(Name); return D; + } + static ValID create(int64_t Val) { ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val; return D; } @@ -90,7 +107,7 @@ struct ValID { ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val; return D; } - static ValID create(double Val) { + static ValID create(APFloat *Val) { ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D; } @@ -98,33 +115,56 @@ struct ValID { ValID D; D.Type = ConstNullVal; return D; } + static ValID createUndef() { + ValID D; D.Type = ConstUndefVal; return D; + } + + static ValID createZeroInit() { + ValID D; D.Type = ConstZeroVal; return D; + } + static ValID create(Constant *Val) { ValID D; D.Type = ConstantVal; D.ConstantValue = Val; return D; } + + static ValID createInlineAsm(const std::string &AsmString, + const std::string &Constraints, + bool HasSideEffects) { + ValID D; + D.Type = InlineAsmVal; + D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects); + return D; + } inline void destroy() const { - if (Type == NameVal) - free(Name); // Free this strdup'd memory... + if (Type == LocalName || Type == GlobalName) + delete Name; // Free this strdup'd memory. + else if (Type == InlineAsmVal) + delete IAD; } inline ValID copy() const { - if (Type != NameVal) return *this; + if (Type != LocalName && Type != GlobalName) return *this; ValID Result = *this; - Result.Name = strdup(Name); + Result.Name = new std::string(*Name); return Result; } inline std::string getName() const { switch (Type) { - case NumberVal : return std::string("#") + itostr(Num); - case NameVal : return Name; - case ConstFPVal : return ftostr(ConstPoolFP); + case LocalID : return '%' + utostr(Num); + case GlobalID : return '@' + utostr(Num); + case LocalName : return *Name; + case GlobalName : return *Name; + case ConstFPVal : return ftostr(*ConstPoolFP); case ConstNullVal : return "null"; + case ConstUndefVal : return "undef"; + case ConstZeroVal : return "zeroinitializer"; case ConstUIntVal : case ConstSIntVal : return std::string("%") + itostr(ConstPool64); case ConstantVal: - if (ConstantValue == ConstantBool::True) return "true"; - if (ConstantValue == ConstantBool::False) return "false"; + if (ConstantValue == ConstantInt::getTrue()) return "true"; + if (ConstantValue == ConstantInt::getFalse()) return "false"; return ""; default: assert(0 && "Unknown value!"); @@ -136,75 +176,67 @@ struct ValID { bool operator<(const ValID &V) const { if (Type != V.Type) return Type < V.Type; switch (Type) { - case NumberVal: return Num < V.Num; - case NameVal: return strcmp(Name, V.Name) < 0; + case LocalID: + case GlobalID: return Num < V.Num; + case LocalName: + case GlobalName: return *Name < *V.Name; case ConstSIntVal: return ConstPool64 < V.ConstPool64; case ConstUIntVal: return UConstPool64 < V.UConstPool64; - case ConstFPVal: return ConstPoolFP < V.ConstPoolFP; + case ConstFPVal: return ConstPoolFP->compare(*V.ConstPoolFP) == + APFloat::cmpLessThan; case ConstNullVal: return false; + case ConstUndefVal: return false; + case ConstZeroVal: return false; case ConstantVal: return ConstantValue < V.ConstantValue; default: assert(0 && "Unknown value type!"); return false; } } -}; - - -template -class PlaceholderValue : public SuperType { - ValID D; - int LineNum; -public: - PlaceholderValue(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) { - LineNum = llvmAsmlineno; + bool operator==(const ValID &V) const { + if (Type == V.Type) { + switch (Type) { + case LocalID: + case GlobalID: return Num == V.Num; + case LocalName: + case GlobalName: return *Name == *(V.Name); + case ConstSIntVal: return ConstPool64 == V.ConstPool64; + case ConstUIntVal: return UConstPool64 == V.UConstPool64; + case ConstFPVal: return ConstPoolFP->compare(*V.ConstPoolFP) == + APFloat::cmpEqual; + case ConstantVal: return ConstantValue == V.ConstantValue; + case ConstNullVal: return true; + case ConstUndefVal: return true; + case ConstZeroVal: return true; + default: assert(0 && "Unknown value type!"); return false; + } + } + return false; } - 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(); return 0; } - virtual const char *getOpcodeName() const { return "placeholder"; } +struct TypeWithAttrs { + llvm::PATypeHolder *Ty; + uint16_t Attrs; }; -struct BBPlaceHolderHelper : public BasicBlock { - BBPlaceHolderHelper(const Type *Ty) : BasicBlock() { - assert(Ty == Type::LabelTy); - } -}; +typedef std::vector TypeWithAttrsList; -struct MethPlaceHolderHelper : public Function { - MethPlaceHolderHelper(const Type *Ty) - : Function(cast(Ty), InternalLinkage) {} +struct ArgListEntry { + uint16_t Attrs; + llvm::PATypeHolder *Ty; + std::string *Name; }; -typedef PlaceholderValue ValuePlaceHolder; -typedef PlaceholderValue BBPlaceHolder; +typedef std::vector ArgListType; -static inline ValID &getValIDFromPlaceHolder(const Value *Val) { - const Type *Ty = Val->getType(); - if (isa(Ty) && - isa(cast(Ty)->getElementType())) - Ty = cast(Ty)->getElementType(); +struct ParamListEntry { + Value *Val; + uint16_t Attrs; +}; - switch (Ty->getPrimitiveID()) { - case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getDef(); - default: return ((ValuePlaceHolder*)Val)->getDef(); - } -} +typedef std::vector ParamList; -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(); - } -} +} // End llvm namespace #endif