implement zextload bool and truncstore bool

[oota-llvm.git] / lib / AsmParser / ParserInternals.h

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 6f747c742633609a2c5f577387ca70e116b852a7..9c94505bf820f66f4b36647c237d895949f55f92 100644 (file)
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -25,7 +25,8 @@
 
 // Global variables exported from the lexer...
 
-extern int llvmAsmlineno;
+extern int llvmAsmlineno;         /// FIXME: Not threading friendly
+extern llvm::ParseError* TheParseError; /// FIXME: Not threading friendly
 
 extern std::string &llvmAsmTextin;
 
@@ -40,7 +41,7 @@ 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);
@@ -51,7 +52,7 @@ 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.
@@ -65,12 +66,18 @@ char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
 // 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
@@ -82,7 +89,7 @@ static inline void ThrowException(const std::string &message,
 struct ValID {
   enum {
     NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
-    ConstUndefVal, ConstZeroVal, ConstantVal,
+    ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
   } Type;
 
   union {
@@ -92,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) {
@@ -129,10 +137,21 @@ struct ValID {
   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 {
@@ -153,8 +172,8 @@ struct ValID {
     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 "<constant expression>";
     default:
       assert(0 && "Unknown value!");
@@ -182,4 +201,20 @@ struct ValID {
 
 } // 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 <class Enum> 
+struct OpcodeInfo {
+  Enum opcode;
+  bool obsolete;
+};
+typedef OpcodeInfo<llvm::Instruction::BinaryOps>  BinaryOpInfo;
+typedef OpcodeInfo<llvm::Instruction::TermOps>    TermOpInfo;
+typedef OpcodeInfo<llvm::Instruction::MemoryOps>  MemOpInfo;
+typedef OpcodeInfo<llvm::Instruction::OtherOps>   OtherOpInfo;
+
 #endif