X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAsmParser%2FParserInternals.h;h=8b10c36e60f5934030f2d60382d10c5a91fd6c54;hb=c8a79af27df2a24b2bb496997194aa35bba70432;hp=88986c288ab8aed2631193a68d639bcfecf9d481;hpb=1a1cb111fe9081cab4d666338c547253c4a437c9;p=oota-llvm.git

diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 88986c288ab..8b10c36e60f 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -13,22 +13,22 @@
 
 #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/Function.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Support/StringExtras.h"
+#include "Support/StringExtras.h"
 
 class Module;
 
 // Global variables exported from the lexer...
-extern FILE *llvmAsmin;
+extern std::FILE *llvmAsmin;
 extern int llvmAsmlineno;
 
 // Globals exported by the parser...
-extern string CurFilename;
-Module *RunVMAsmParser(const string &Filename, FILE *F);
+extern std::string CurFilename;
+Module *RunVMAsmParser(const std::string &Filename, FILE *F);
 
 
 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
@@ -47,7 +47,7 @@ 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 string &message,
+static inline void ThrowException(const std::string &message,
 				  int LineNo = -1) {
   if (LineNo == -1) LineNo = llvmAsmlineno;
   // TODO: column number in exception
@@ -116,18 +116,33 @@ struct ValID {
     return Result;
   }
 
-  inline string getName() const {
+  inline std::string getName() const {
     switch (Type) {
-    case NumberVal     : return string("#") + itostr(Num);
+    case NumberVal     : return std::string("#") + itostr(Num);
     case NameVal       : return Name;
-    case ConstStringVal: return string("\"") + Name + string("\"");
+    case ConstStringVal: return std::string("\"") + Name + std::string("\"");
     case ConstFPVal    : return ftostr(ConstPoolFP);
     case ConstNullVal  : return "null";
     case ConstUIntVal  :
-    case ConstSIntVal  : return string("%") + itostr(ConstPool64);
+    case ConstSIntVal  : return std::string("%") + itostr(ConstPool64);
     default:
       assert(0 && "Unknown value!");
       abort();
+      return "";
+    }
+  }
+
+  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;
     }
   }
 };
@@ -146,52 +161,47 @@ 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, "") {}
 
-  virtual Instruction *clone() const { abort(); }
+  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->isLabelType());
+    assert(Ty == Type::LabelTy);
   }
 };
 
-struct MethPlaceHolderHelper : public Method {
-  MethPlaceHolderHelper(const Type *Ty) 
-    : Method((const MethodType*)Ty) {
-    assert(Ty->isMethodType() && "Method placeholders must be method types!");
-  }
+struct MethPlaceHolderHelper : public Function {
+  MethPlaceHolderHelper(const Type *Ty)
+    : Function(cast<FunctionType>(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<FunctionType>(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<FunctionType>(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();
   }
 }