Renamed inst_const_iterator -> const_inst_iterator

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

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 31c0b24144d482618656887a7beeb727abf851a1..750833fae83cde59b9dd020333840aa10d3d5a9c 100644 (file)
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -13,12 +13,12 @@
 
 #include "llvm/InstrTypes.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/iOther.h"
 #include "llvm/Method.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Support/StringExtras.h"
+#include "Support/StringExtras.h"
 
 class Module;
 
@@ -63,9 +63,11 @@ static inline void ThrowException(const string &message,
 // putting classes with ctor's in unions.  :(
 //
 struct ValID {
-  int Type;               // 0 = number, 1 = name, 2 = const pool, 
-                          // 3 = unsigned const pool, 4 = const string, 
-                          // 5 = const fp
+  enum {
+    NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstStringVal, 
+    ConstFPVal, ConstNullVal
+  } Type;
+
   union {
     int      Num;         // If it's a numeric reference
     char    *Name;        // If it's a named reference.  Memory must be free'd.
@@ -75,35 +77,40 @@ struct ValID {
   };
 
   static ValID create(int Num) {
-    ValID D; D.Type = 0; D.Num = Num; return D;
+    ValID D; D.Type = NumberVal; D.Num = Num; return D;
   }
 
   static ValID create(char *Name) {
-    ValID D; D.Type = 1; D.Name = Name; return D;
+    ValID D; D.Type = NameVal; D.Name = 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;
+    ValID D; D.Type = ConstStringVal; D.Name = Name; return D;
   }
 
   static ValID create(double Val) {
-    ValID D; D.Type = 5; D.ConstPoolFP = Val; return D;
+    ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val; return D;
+  }
+
+  static ValID createNull() {
+    ValID D; D.Type = ConstNullVal; return D;
   }
 
   inline void destroy() const {
-    if (Type == 1 || Type == 4) free(Name);  // Free this strdup'd memory...
+    if (Type == NameVal || Type == ConstStringVal)
+      free(Name);    // Free this strdup'd memory...
   }
 
   inline ValID copy() const {
-    if (Type != 1 && Type != 4) return *this;
+    if (Type != NameVal && Type != ConstStringVal) return *this;
     ValID Result = *this;
     Result.Name = strdup(Name);
     return Result;
@@ -111,11 +118,30 @@ struct ValID {
 
   inline 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 NumberVal     : return string("#") + itostr(Num);
+    case NameVal       : return Name;
+    case ConstStringVal: return string("\"") + Name + string("\"");
+    case ConstFPVal    : return ftostr(ConstPoolFP);
+    case ConstNullVal  : return "null";
+    case ConstUIntVal  :
+    case ConstSIntVal  : return string("%") + itostr(ConstPool64);
+    default:
+      assert(0 && "Unknown value!");
+      abort();
+    }
+  }
+
+  bool operator<(const ValID &V) const {
+    if (Type != V.Type) return Type < V.Type;
+    switch (Type) {
+    case NumberVal:     return Num < V.Num;
+    case ConstStringVal:
+    case NameVal:       return strcmp(Name, V.Name) < 0;
+    case ConstSIntVal:  return ConstPool64  < V.ConstPool64;
+    case ConstUIntVal:  return UConstPool64 < V.UConstPool64;
+    case ConstFPVal:    return ConstPoolFP  < V.ConstPoolFP;
+    case ConstNullVal:  return false;
+    default:  assert(0 && "Unknown value type!"); return false;
     }
   }
 };
@@ -134,13 +160,6 @@ public:
   int getLineNum() const { return LineNum; }
 };
 
-struct TypePlaceHolderHelper : public OpaqueType {
-  TypePlaceHolderHelper(const Type *Ty) : OpaqueType() {
-    assert(Ty == Type::TypeTy);
-  }
-};
-
-
 struct InstPlaceHolderHelper : public Instruction {
   InstPlaceHolderHelper(const Type *Ty) : Instruction(Ty, UserOp1, "") {}
 
@@ -155,31 +174,33 @@ struct BBPlaceHolderHelper : public BasicBlock {
 };
 
 struct MethPlaceHolderHelper : public Method {
-  MethPlaceHolderHelper(const Type *Ty) 
-    : Method((const MethodType*)Ty) {
-    assert(Ty->isMethodType() && "Method placeholders must be method types!");
-  }
+  MethPlaceHolderHelper(const Type *Ty) : Method(cast<const MethodType>(Ty),
+                                                true) {}
 };
 
-typedef PlaceholderValue<TypePlaceHolderHelper>  TypePlaceHolder;
 typedef PlaceholderValue<InstPlaceHolderHelper>  ValuePlaceHolder;
 typedef PlaceholderValue<BBPlaceHolderHelper>    BBPlaceHolder;
-typedef PlaceholderValue<MethPlaceHolderHelper>  MethPlaceHolder;
 
 static inline ValID &getValIDFromPlaceHolder(const Value *Val) {
-  switch (Val->getType()->getPrimitiveID()) {
-  case Type::TypeTyID:   return ((TypePlaceHolder*)Val)->getDef();
+  const Type *Ty = Val->getType();
+  if (isa<PointerType>(Ty) &&
+      isa<MethodType>(cast<PointerType>(Ty)->getElementType()))
+    Ty = cast<PointerType>(Ty)->getElementType();
+
+  switch (Ty->getPrimitiveID()) {
   case Type::LabelTyID:  return ((BBPlaceHolder*)Val)->getDef();
-  case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getDef();
   default:               return ((ValuePlaceHolder*)Val)->getDef();
   }
 }
 
 static inline int getLineNumFromPlaceHolder(const Value *Val) {
-  switch (Val->getType()->getPrimitiveID()) {
-  case Type::TypeTyID:   return ((TypePlaceHolder*)Val)->getLineNum();
+  const Type *Ty = Val->getType();
+  if (isa<PointerType>(Ty) &&
+      isa<MethodType>(cast<PointerType>(Ty)->getElementType()))
+    Ty = cast<PointerType>(Ty)->getElementType();
+
+  switch (Ty->getPrimitiveID()) {
   case Type::LabelTyID:  return ((BBPlaceHolder*)Val)->getLineNum();
-  case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getLineNum();
   default:               return ((ValuePlaceHolder*)Val)->getLineNum();
   }
 }