X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=8fd5031c05a42141610dbe7df7500f78d02dad04;hb=389056110f861ef8f5af5c3c10ddd854d260a0b8;hp=1f6bafce1500fd9d4416816447eeddb11d26bf01;hpb=bcbf6baf10c34086594bc03f0002a8977cd66941;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index 1f6bafce150..8fd5031c05a 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -1,6 +1,13 @@ -//===-- ParserInternals.h - Definitions internal to the parser ---*- C++ -*--=// +//===-- 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... // //===----------------------------------------------------------------------===// @@ -8,150 +15,228 @@ #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/iOther.h" -#include "llvm/Method.h" -#include "llvm/Type.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" +#include "llvm/Function.h" +#include "llvm/Instructions.h" #include "llvm/Assembly/Parser.h" -#include "llvm/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 FILE *llvmAsmin; -extern int llvmAsmlineno; -// Globals exported by the parser... -extern string CurFilename; -Module *RunVMAsmParser(const string &Filename, FILE *F); +extern llvm::ParseError* TheParseError; /// FIXME: Not threading friendly + +// functions exported from the lexer +void InitLLLexer(llvm::MemoryBuffer *MB); +const char *LLLgetTokenStart(); +unsigned LLLgetTokenLength(); +std::string LLLgetFilename(); +unsigned LLLgetLineNo(); +void FreeLexer(); + +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 string &message) { - // TODO: column number in exception - throw ParseException(CurFilename, message, llvmAsmlineno); -} +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 { - int Type; // 0 = number, 1 = name, 2 = const pool, - // 3 = unsigned const pool, 4 = const string, - // 5 = const fp + enum { + 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 = 0; 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 = 1; 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 = 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(APFloat *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; + } + + 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 == 1 || Type == 4) 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 != 1 && Type != 4) 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 string getName() const { + inline std::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 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 == ConstantInt::getTrue()) return "true"; + if (ConstantValue == ConstantInt::getFalse()) return "false"; + return ""; + default: + assert(0 && "Unknown value!"); + abort(); + return ""; } } -}; + bool operator<(const ValID &V) const { + if (Type != V.Type) return 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::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; + } + } + 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; + } +}; -template -class PlaceholderDef : public SuperType { - ValID D; - // TODO: Placeholder def should hold Line #/Column # of definition in case - // there is an error resolving the defintition! -public: - PlaceholderDef(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {} - ValID &getDef() { return D; } +struct TypeWithAttrs { + llvm::PATypeHolder *Ty; + uint16_t Attrs; }; -struct InstPlaceHolderHelper : public Instruction { - InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {} +typedef std::vector TypeWithAttrsList; - virtual Instruction *clone() const { abort(); } - virtual const char *getOpcodeName() const { return "placeholder"; } +struct ArgListEntry { + uint16_t Attrs; + llvm::PATypeHolder *Ty; + std::string *Name; }; -struct BBPlaceHolderHelper : public BasicBlock { - BBPlaceHolderHelper(const Type *Ty) : BasicBlock() { - assert(Ty->isLabelType()); - } -}; +typedef std::vector ArgListType; -struct MethPlaceHolderHelper : public Method { - MethPlaceHolderHelper(const Type *Ty) - : Method((const MethodType*)Ty) { - assert(Ty->isMethodType() && "Method placeholders must be method types!"); - } +struct ParamListEntry { + Value *Val; + uint16_t Attrs; }; -typedef PlaceholderDef DefPlaceHolder; -typedef PlaceholderDef BBPlaceHolder; -typedef PlaceholderDef MethPlaceHolder; -//typedef PlaceholderDef ModulePlaceHolder; +typedef std::vector ParamList; -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(); - } -} + +} // End llvm namespace #endif