X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=9c94505bf820f66f4b36647c237d895949f55f92;hb=6345d75729392d9b50383f1b5c7f92d477572290;hp=c18434d1f0767683e8d19ea25cf0e7eaec4f8db8;hpb=d0fde30ce850b78371fd1386338350591f9ff494;p=oota-llvm.git diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index c18434d1f07..9c94505bf82 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -1,13 +1,13 @@ //===-- ParserInternals.h - Definitions internal to the parser --*- C++ -*-===// -// +// // 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 header file defines the various variables that are shared among the +// This header file defines the various variables that are shared among the // different components of the parser... // //===----------------------------------------------------------------------===// @@ -16,15 +16,23 @@ #define PARSER_INTERNALS_H #include "llvm/Constants.h" -#include "llvm/iOther.h" -#include "llvm/Function.h" #include "llvm/DerivedTypes.h" +#include "llvm/Function.h" +#include "llvm/Instructions.h" #include "llvm/Assembly/Parser.h" -#include "Support/StringExtras.h" +#include "llvm/ADT/StringExtras.h" + // Global variables exported from the lexer... -extern std::FILE *llvmAsmin; -extern int llvmAsmlineno; + +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; @@ -33,15 +41,18 @@ extern int llvmAsmleng; namespace llvm { // Globals exported by the parser... -extern std::string CurFilename; +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 exception to be thrown. +// an error. // // If AllowNull is set to true, the return value of the function points to the // last character of the string in memory. @@ -52,28 +63,33 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false); // ThrowException - 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, + ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal } Type; union { @@ -83,6 +99,7 @@ struct ValID { uint64_t UConstPool64;// Unsigned constant pool reference. double ConstPoolFP; // Floating point constant pool reference Constant *ConstantValue; // Fully resolved constant for ConstantVal case. + InlineAsmDescriptor *IAD; }; static ValID create(int Num) { @@ -109,13 +126,32 @@ 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... + free(Name); // Free this strdup'd memory. + else if (Type == InlineAsmVal) + delete IAD; } inline ValID copy() const { @@ -131,11 +167,13 @@ struct ValID { case NameVal : 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 == ConstantBool::getTrue()) return "true"; + if (ConstantValue == ConstantBool::getFalse()) return "false"; return ""; default: assert(0 && "Unknown value!"); @@ -153,66 +191,30 @@ struct ValID { case ConstUIntVal: return UConstPool64 < V.UConstPool64; case ConstFPVal: return ConstPoolFP < V.ConstPoolFP; 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; } } }; +} // End llvm namespace - -template -class PlaceholderValue : public SuperType { - ValID D; - int LineNum; -public: - 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(); return 0; } - virtual const char *getOpcodeName() const { return "placeholder"; } -}; - -struct BBPlaceHolderHelper : public BasicBlock { - BBPlaceHolderHelper(const Type *Ty) : BasicBlock() { - assert(Ty == Type::LabelTy); - } +// 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; }; - -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(); - } -} - -} // End llvm namespace +typedef OpcodeInfo BinaryOpInfo; +typedef OpcodeInfo TermOpInfo; +typedef OpcodeInfo MemOpInfo; +typedef OpcodeInfo OtherOpInfo; #endif