For PR797:

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

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index b21dea7a078fee17f174e49fb4409a5bc71d96a3..633ffc13485a75f2609d3c562d688f23d318e4f9 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, 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) {
@@ -122,13 +130,28 @@ struct ValID {
     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 {
@@ -145,6 +168,7 @@ struct ValID {
     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:
@@ -168,6 +192,7 @@ struct ValID {
     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;
     }