X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=lib%2FAsmParser%2FParserInternals.h;h=298dd8c19023fbeda71884efd31052c0af1b21cd;hb=e6be34a53ecbe8c2ff9f0793b13d847e94c0de91;hp=c26c5f4ffb50f2709a0aa4c46bfbfb5a62c5aaa8;hpb=36699cabc5ab461f53047be6384a27fb9a7845ce;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index c26c5f4ffb5..298dd8c1902 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -17,50 +17,33 @@ #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/ADT/StringExtras.h" - +#include "llvm/ADT/APFloat.h" +namespace llvm { class MemoryBuffer; } // Global variables exported from the lexer... -extern int llvmAsmlineno; /// FIXME: Not threading friendly extern llvm::ParseError* TheParseError; /// FIXME: Not threading friendly -extern std::string &llvmAsmTextin; - // functions exported from the lexer -void set_scan_file(FILE * F); -void set_scan_string (const char * str); - -// Globals exported by the parser... -extern char* llvmAsmtext; -extern int llvmAsmleng; +void InitLLLexer(llvm::MemoryBuffer *MB); +const char *LLLgetTokenStart(); +unsigned LLLgetTokenLength(); +std::string LLLgetFilename(); +unsigned LLLgetLineNo(); +void FreeLexer(); namespace llvm { - -// Globals exported by the parser... -extern std::string CurFilename; /// FIXME: Not threading friendly - class Module; -Module *RunVMAsmParser(const std::string &Filename, FILE *F); - -// Parse a string directly -Module *RunVMAsmParser(const char * AsmString, Module * M); - -// 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 error. -// -// 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); +// 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 @@ -88,28 +71,34 @@ struct InlineAsmDescriptor { // struct ValID { enum { - NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal, + 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; } @@ -118,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; } @@ -148,32 +137,34 @@ struct ValID { } 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::getTrue()) return "true"; - if (ConstantValue == ConstantBool::getFalse()) return "false"; + if (ConstantValue == ConstantInt::getTrue()) return "true"; + if (ConstantValue == ConstantInt::getFalse()) return "false"; return ""; default: assert(0 && "Unknown value!"); @@ -185,11 +176,14 @@ 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; @@ -197,50 +191,52 @@ struct ValID { default: assert(0 && "Unknown value type!"); return false; } } -}; - -} // End llvm namespace -// This structure is used to keep track of obsolete opcodes. The lexer will -// retain the ability to parse obsolete opcode mnemonics. In this case it will -// set "obsolete" to true and the opcode will be the replacement opcode. For -// example if "rem" is encountered then opcode will be set to "urem" and the -// "obsolete" flag will be true. If the opcode is not obsolete then "obsolete" -// will be false. -template -struct OpcodeInfo { - Enum opcode; - bool obsolete; + 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; + } }; -typedef OpcodeInfo BinaryOpInfo; -typedef OpcodeInfo TermOpInfo; -typedef OpcodeInfo MemOpInfo; -typedef OpcodeInfo OtherOpInfo; - -/// This enumeration is used to indicate if a type is signed, signless or -/// unsigned. It is used for backwards compatibility with assembly code that -/// pre-dates the signless types conversion. -enum Signedness { - isSigned, - isUnsigned, - isSignless + +struct TypeWithAttrs { + llvm::PATypeHolder *Ty; + ParameterAttributes Attrs; }; -/// This structure is used to keep track of the signedness of the obsolete -/// integer types. Instead of creating an llvm::Type directly, the Lexer will -/// create instances of TypeInfo which retains the signedness indication so -/// it can be used by the parser for upgrade decisions. -/// For example if "uint" is encountered then the type will be set "int32" -/// and the "signedness" will be "isUnsigned". If the type is not obsolete -/// then "signedness" will be "isSignless". -struct TypeInfo { - llvm::PATypeHolder *type; - Signedness signedness; +typedef std::vector TypeWithAttrsList; + +struct ArgListEntry { + ParameterAttributes Attrs; + llvm::PATypeHolder *Ty; + std::string *Name; }; -struct ValueInfo { - std::vector valuelist; - std::vector signlist; +typedef std::vector ArgListType; + +struct ParamListEntry { + Value *Val; + ParameterAttributes Attrs; }; +typedef std::vector ParamList; + + +} // End llvm namespace + #endif