Add more support for new style casts

Convert more code to use them

llvm-svn: 695

llvm/include/llvm/Analysis/ConstantsScanner.h

@@ -45,7 +45,7 @@ public:
 
   inline pointer operator*() const {
     assert(isAtConstant() && "Dereferenced an iterator at the end!");
-    return InstI->getOperand(OpIdx)->castConstantAsserting();
+    return cast<ConstPoolVal>(InstI->getOperand(OpIdx));
   }
   inline pointer operator->() const { return operator*(); }
 

llvm/include/llvm/Analysis/InstForest.h

@@ -20,8 +20,8 @@
 
 namespace analysis {
 
-template <class Payload> class InstTreeNode;
+template<class Payload> class InstTreeNode;
-template<class Payload>  class InstForest;
+template<class Payload> class InstForest;
 
 
 //===----------------------------------------------------------------------===//
@@ -74,10 +74,10 @@ public:
 
   // Accessors for different node types...
   inline ConstPoolVal *getConstant() {
-    return getValue()->castConstantAsserting();
+    return cast<ConstPoolVal>(getValue());
   }
   inline const ConstPoolVal *getConstant() const {
-    return getValue()->castConstantAsserting();
+    return cast<const ConstPoolVal>(getValue());
   }
   inline BasicBlock *getBasicBlock() {
     return cast<BasicBlock>(getValue());
@@ -230,12 +230,12 @@ InstTreeNode<Payload>::InstTreeNode(InstForest<Payload> &IF, Value *V,
   getTreeData().first.first = V;   // Save tree node
  
   if (!V->isInstruction()) {
-    assert((V->isConstant() || V->isBasicBlock() ||
+    assert((isa<ConstPoolVal>(V) || isa<BasicBlock>(V) ||
-	    V->isMethodArgument() || V->isGlobal()) &&
+	    isa<MethodArgument>(V) || isa<GlobalVariable>(V)) &&
 	   "Unrecognized value type for InstForest Partition!");
-    if (V->isConstant())
+    if (isa<ConstPoolVal>(V))
       getTreeData().first.second = ConstNode;
-    else if (V->isBasicBlock())
+    else if (isa<BasicBlock>(V))
       getTreeData().first.second = BasicBlockNode;
     else 
       getTreeData().first.second = TemporaryNode;

llvm/include/llvm/Assembly/Writer.h

@@ -91,7 +91,7 @@ inline ostream &operator<<(ostream &o, const Type *T) {
 
 inline ostream &operator<<(ostream &o, const Value *I) {
   switch (I->getValueType()) {
-  case Value::TypeVal:       return o << I->castTypeAsserting();
+  case Value::TypeVal:       return o << cast<const Type>(I);
   case Value::ConstantVal:   WriteToAssembly((const ConstPoolVal*)I,o);break;
   case Value::MethodArgumentVal: return o << I->getType() << " "<< I->getName();
   case Value::InstructionVal:WriteToAssembly((const Instruction *)I, o);break;

llvm/include/llvm/DerivedTypes.h

@@ -78,6 +78,15 @@ public:
   // type NewType and for 'this' to be deleted.
   //
   void refineAbstractTypeTo(const Type *NewType);
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const DerivedType *T) { return true; }
+  static inline bool isa(const Type *T) {
+    return T->isDerivedType();
+  }
+  static inline bool isa(const Value *V) {
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
+  }
 };
 
 
@@ -129,7 +138,7 @@ public:
     return T->getPrimitiveID() == MethodTyID;
   }
   static inline bool isa(const Value *V) {
-    return ::isa<Type>(V) && MethodType::isa(cast<const Type>(V));
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
   }
 };
 
@@ -170,6 +179,15 @@ public:
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
 
   static ArrayType *get(const Type *ElementType, int NumElements = -1);
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const ArrayType *T) { return true; }
+  static inline bool isa(const Type *T) {
+    return T->getPrimitiveID() == ArrayTyID;
+  }
+  static inline bool isa(const Value *V) {
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
+  }
 };
 
 
@@ -206,6 +224,15 @@ public:
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
 
   static StructType *get(const vector<const Type*> &Params);
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const StructType *T) { return true; }
+  static inline bool isa(const Type *T) {
+    return T->getPrimitiveID() == StructTyID;
+  }
+  static inline bool isa(const Value *V) {
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
+  }
 };
 
 
@@ -240,6 +267,15 @@ public:
   // concrete type.
   //
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const PointerType *T) { return true; }
+  static inline bool isa(const Type *T) {
+    return T->getPrimitiveID() == PointerTyID;
+  }
+  static inline bool isa(const Value *V) {
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
+  }
 };
 
 
@@ -261,6 +297,15 @@ public:
   static OpaqueType *get() {
     return new OpaqueType();           // All opaque types are distinct
   }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const OpaqueType *T) { return true; }
+  static inline bool isa(const Type *T) {
+    return T->getPrimitiveID() == OpaqueTyID;
+  }
+  static inline bool isa(const Value *V) {
+    return ::isa<Type>(V) && isa(cast<const Type>(V));
+  }
 };
 
 
@@ -272,11 +317,11 @@ public:
 //
 template <class TypeSubClass> void PATypeHandle<TypeSubClass>::addUser() {
   if (Ty->isAbstract())
-    Ty->castDerivedTypeAsserting()->addAbstractTypeUser(User);
+    cast<DerivedType>(Ty)->addAbstractTypeUser(User);
 }
 template <class TypeSubClass> void PATypeHandle<TypeSubClass>::removeUser() {
   if (Ty->isAbstract())
-    Ty->castDerivedTypeAsserting()->removeAbstractTypeUser(User);
+    cast<DerivedType>(Ty)->removeAbstractTypeUser(User);
 }
 
 #endif

llvm/include/llvm/GlobalVariable.h

@@ -46,10 +46,10 @@ public:
   //
   inline bool hasInitializer() const { return !Operands.empty(); }
   inline const ConstPoolVal *getInitializer() const {
-    return Operands[0]->castConstantAsserting();
+    return (const ConstPoolVal*)Operands[0].get();
   }
   inline ConstPoolVal *getInitializer() {
-    return Operands[0]->castConstantAsserting();
+    return (ConstPoolVal*)Operands[0].get();
   }
   inline void setInitializer(ConstPoolVal *CPV) { Operands[0] = (Value*)CPV; }
 
@@ -59,6 +59,12 @@ public:
   // leads to undefined behavior.
   //
   inline bool isConstant() const { return Constant; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool isa(const GlobalVariable *) { return true; }
+  static inline bool isa(const Value *V) {
+    return V->getValueType() == Value::GlobalVal;
+  }
 };
 
 #endif

llvm/include/llvm/SymbolTable.h

@@ -19,6 +19,11 @@
 #include "llvm/Value.h"
 #include <map>
 
+#ifndef NDEBUG             // Only for assertions
+#include "llvm/Type.h"
+#include "llvm/ConstPoolVals.h"
+#endif
+
 class Value;
 class Type;
 
@@ -63,7 +68,7 @@ public:
   // (constant/type)s.
   //
   inline void insert(const string &Name, Value *V) {
-    assert((V->isType() || V->isConstant()) &&
+    assert((isa<Type>(V) || isa<ConstPoolVal>(V)) &&
 	   "Can only insert types and constants here!");
     insertEntry(Name, V);
   }

llvm/include/llvm/Type.h

@@ -187,13 +187,6 @@ public:
   inline bool isPrimitiveType() const { return ID < FirstDerivedTyID;  }
 
   inline bool isDerivedType()   const { return ID >= FirstDerivedTyID; }
-  inline const DerivedType *castDerivedType() const {
-    return isDerivedType() ? (const DerivedType*)this : 0;
-  }
-  inline const DerivedType *castDerivedTypeAsserting() const {
-    assert(isDerivedType());
-    return (const DerivedType*)this;
-  }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool isa(const Type *T) { return true; }

llvm/include/llvm/Value.h

@@ -98,14 +98,6 @@ public:
   inline CLASS *cast##NAME() {         /* nonconst version */             \
     return is##NAME() ? (CLASS*)this : 0;                                 \
   }                                                                       \
-  inline const CLASS *cast##NAME##Asserting() const { /*const version */  \
-    assert(is##NAME() && "Expected Value Type: " #NAME);                  \
-    return (const CLASS*)this;                                            \
-  }                                                                       \
-  inline CLASS *cast##NAME##Asserting() {         /* nonconst version */  \
-    assert(is##NAME() && "Expected Value Type: " #NAME);                  \
-    return (CLASS*)this;                                                  \
-  }                                                                       \
 
   CAST_FN(Constant      ,       ConstPoolVal  )
   CAST_FN(MethodArgument,       MethodArgument)
@@ -113,19 +105,8 @@ public:
   CAST_FN(BasicBlock    ,       BasicBlock    )
   CAST_FN(Method        ,       Method        )
   CAST_FN(Global        ,       GlobalVariable)
-  CAST_FN(Module        ,       Module        )
 #undef CAST_FN
 
-  // Type value is special, because there is no nonconst version of functions!
-  inline bool isType() const { return VTy == TypeVal; }
-  inline const Type *castType() const {
-    return (VTy == TypeVal) ? (const Type*)this : 0;
-  }
-  inline const Type *castTypeAsserting() const {
-    assert(isType() && "Expected Value Type: Type");
-    return (const Type*)this;
-  }
-
   // replaceAllUsesWith - Go through the uses list for this definition and make
   // each use point to "D" instead of "this".  After this completes, 'this's 
   // use list should be empty.
@@ -256,4 +237,33 @@ X *dyn_cast(Y Val) {
   return isa<X>(Val) ? cast<X>(Val) : 0;
 }
 
+
+// isa - Provide some specializations of isa so that we have to include the
+// subtype header files to test to see if the value is a subclass...
+//
+template <> bool isa<Type, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::TypeVal;
+}
+template <> bool isa<ConstPoolVal, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::ConstantVal; 
+}
+template <> bool isa<MethodArgument, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::MethodArgumentVal;
+}
+template <> bool isa<Instruction, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::InstructionVal;
+}
+template <> bool isa<BasicBlock, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::BasicBlockVal;
+}
+template <> bool isa<Method, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::MethodVal;
+}
+template <> bool isa<GlobalVariable, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::GlobalVal;
+}
+template <> bool isa<Module, Value*>(Value *Val) { 
+  return Val->getValueType() == Value::ModuleVal;
+}
+
 #endif

llvm/include/llvm/iTerminators.h

@@ -154,11 +154,11 @@ public:
   // successor. WARNING: This does not gracefully accept idx's out of range!
   inline const ConstPoolVal *getSuccessorValue(unsigned idx) const {
     assert(idx < getNumSuccessors() && "Successor # out of range!");
-    return Operands[idx*2]->castConstantAsserting();
+    return cast<const ConstPoolVal>(Operands[idx*2]);
   }
   inline ConstPoolVal *getSuccessorValue(unsigned idx) {
     assert(idx < getNumSuccessors() && "Successor # out of range!");
-    return Operands[idx*2]->castConstantAsserting();
+    return cast<ConstPoolVal>(Operands[idx*2]);
   }
   virtual unsigned getNumSuccessors() const { return Operands.size()/2; }
 };

llvm/lib/Analysis/Expressions.cpp

@@ -225,7 +225,7 @@ ExprType analysis::ClassifyExpression(Value *Expr) {
   case Value::MethodArgumentVal:        // nothing known, return variable itself
     return Expr;
   case Value::ConstantVal:              // Constant value, just return constant
-    ConstPoolVal *CPV = Expr->castConstantAsserting();
+    ConstPoolVal *CPV = cast<ConstPoolVal>(Expr);
     if (CPV->getType()->isIntegral()) { // It's an integral constant!
       ConstPoolInt *CPI = (ConstPoolInt*)Expr;
       return ExprType(CPI->equalsInt(0) ? 0 : CPI);

llvm/lib/AsmParser/llvmAsmParser.y

@@ -155,7 +155,7 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
     }
 
     D.destroy();  // Free old strdup'd memory...
-    return N->castTypeAsserting();
+    return cast<const Type>(N);
   }
   default:
     ThrowException("Invalid symbol type reference!");
@@ -267,7 +267,7 @@ static Value *getVal(const Type *Ty, const ValID &D,
     case ValID::ConstNullVal:
       if (!Ty->isPointerType())
         ThrowException("Cannot create a a non pointer null!");
-      CPV = ConstPoolPointer::getNullPointer(Ty->castPointerType());
+      CPV = ConstPoolPointer::getNullPointer(cast<PointerType>(Ty));
       break;
     default:
       assert(0 && "Unhandled case!");
@@ -341,7 +341,7 @@ static void ResolveDefinitions(vector<ValueList> &LateResolvers) {
 			 getLineNumFromPlaceHolder(V));
       }
 
-      assert(!V->isType() && "Types should be in LateResolveTypes!");
+      assert(!isa<Type>(V) && "Types should be in LateResolveTypes!");
 
       V->replaceAllUsesWith(TheRealValue);
       delete V;
@@ -371,11 +371,8 @@ static void ResolveTypes(vector<PATypeHolder<Type> > &LateResolveTypes) {
 		       getLineNumFromPlaceHolder(Ty));
     }
 
-    // FIXME: When types are not const
-    DerivedType *DTy = const_cast<DerivedType*>(Ty->castDerivedTypeAsserting());
-    
     // Refine the opaque type we had to the new type we are getting.
-    DTy->refineAbstractTypeTo(TheRealType);
+    cast<DerivedType>(Ty)->refineAbstractTypeTo(TheRealType);
 
     // No need to delete type, refine does that for us.
     LateResolveTypes.pop_back();
@@ -399,12 +396,11 @@ static void setValueName(Value *V, char *NameStr) {
   if (Existing) {    // Inserting a name that is already defined???
     // There is only one case where this is allowed: when we are refining an
     // opaque type.  In this case, Existing will be an opaque type.
-    if (const Type *Ty = Existing->castType())
+    if (const Type *Ty = cast<const Type>(Existing))
       if (Ty->isOpaqueType()) {
 	// We ARE replacing an opaque type!
 
-	// TODO: FIXME when types are not const!
+	cast<DerivedType>(Ty)->refineAbstractTypeTo(cast<Type>(V));
-	const_cast<DerivedType*>(Ty->castDerivedTypeAsserting())->refineAbstractTypeTo(V->castTypeAsserting());
 	return;
       }
 
@@ -899,7 +895,7 @@ ConstPool : ConstPool OptAssign ConstVal {
   | ConstPool OptAssign GlobalType ResolvedVal {
     const Type *Ty = $4->getType();
     // Global declarations appear in Constant Pool
-    ConstPoolVal *Initializer = $4->castConstant();
+    ConstPoolVal *Initializer = cast<ConstPoolVal>($4);
     if (Initializer == 0)
       ThrowException("Global value initializer is not a constant!");
 	 
@@ -913,7 +909,7 @@ ConstPool : ConstPool OptAssign ConstVal {
   | ConstPool OptAssign UNINIT GlobalType Types {
     const Type *Ty = *$5;
     // Global declarations appear in Constant Pool
-    if (Ty->isArrayType() && Ty->castArrayType()->isUnsized()) {
+    if (isa<ArrayType>(Ty) && cast<ArrayType>(Ty)->isUnsized()) {
       ThrowException("Type '" + Ty->getDescription() +
 		     "' is not a sized type!");
     }
@@ -1162,7 +1158,7 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
 
 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
-    ConstPoolVal *V = getVal($2, $3, true)->castConstantAsserting();
+    ConstPoolVal *V = cast<ConstPoolVal>(getVal($2, $3, true));
     if (V == 0)
       ThrowException("May only switch on a constant pool value!");
 
@@ -1170,7 +1166,7 @@ JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
     $$ = new list<pair<ConstPoolVal*, BasicBlock*> >();
-    ConstPoolVal *V = getVal($1, $2, true)->castConstantAsserting();
+    ConstPoolVal *V = cast<ConstPoolVal>(getVal($1, $2, true));
 
     if (V == 0)
       ThrowException("May only switch on a constant pool value!");

llvm/lib/Bytecode/Reader/ConstantReader.cpp

@@ -149,8 +149,7 @@ bool BytecodeParser::parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
     // abstract type to use the newty.  This also will cause the opaque type
     // to be deleted...
     //
-    // FIXME when types are not const
+    cast<DerivedType>(Tab[i+BaseLevel].get())->refineAbstractTypeTo(NewTy);
-    const_cast<DerivedType*>(Tab[i+BaseLevel]->castDerivedTypeAsserting())->refineAbstractTypeTo(NewTy);
 
     // This should have replace the old opaque type with the new type in the
     // value table...
@@ -159,7 +158,7 @@ bool BytecodeParser::parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
 
   BCR_TRACE(5, "Resulting types:\n");
   for (unsigned i = 0; i < NumEntries; i++) {
-    BCR_TRACE(5, Tab[i+BaseLevel]->castTypeAsserting() << "\n");
+    BCR_TRACE(5, cast<Type>(Tab[i+BaseLevel]) << "\n");
   }
   return false;
 }

llvm/lib/Bytecode/Reader/Reader.cpp

@@ -55,7 +55,7 @@ const Type *BytecodeParser::getType(unsigned ID) {
   const Value *D = getValue(Type::TypeTy, ID, false);
   if (D == 0) return failure<const Type*>(0);
 
-  return D->castTypeAsserting();
+  return cast<Type>(D);
 }
 
 bool BytecodeParser::insertValue(Value *Val, vector<ValueList> &ValueTab) {
@@ -341,7 +341,7 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
       Value *V = getValue(Ty->castPointerType()->getValueType(),
 			  InitSlot, false);
       if (V == 0) return failure(true);
-      Initializer = V->castConstantAsserting();
+      Initializer = cast<ConstPoolVal>(V);
     }
 
     // Create the global variable...

llvm/lib/Bytecode/Writer/Writer.cpp

@@ -84,7 +84,8 @@ void BytecodeWriter::outputConstants(bool isMethod) {
 
     unsigned NC = ValNo;              // Number of constants
     for (; NC < Plane.size() && 
-	   (Plane[NC]->isConstant() || Plane[NC]->isType()); NC++) /*empty*/;
+	   (isa<ConstPoolVal>(Plane[NC]) || 
+            isa<Type>(Plane[NC])); NC++) /*empty*/;
     NC -= ValNo;                      // Convert from index into count
     if (NC == 0) continue;            // Skip empty type planes...
 

llvm/lib/Target/Sparc/SparcInstrSelection.cpp

@@ -1525,8 +1525,8 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       case 208:	// stmt:   BrCond(boolconst)
         {
         // boolconst => boolean is a constant; use BA to first or second label
-        ConstPoolVal* constVal =
+        ConstPoolVal* constVal = 
-          subtreeRoot->leftChild()->getValue()->castConstantAsserting();
+          cast<ConstPoolVal>(subtreeRoot->leftChild()->getValue());
         unsigned dest = ((ConstPoolBool*) constVal)->getValue()? 0 : 1;
         
         mvec[0] = new MachineInstr(BA);

llvm/lib/Target/TargetData.cpp

@@ -61,7 +61,7 @@ Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T,
 				      void *D) {
   const TargetData &TD = *(const TargetData*)D;
   assert(AID == TD.AID && "Target data annotation ID mismatch!");
-  const Type *Ty = ((const Value *)T)->castTypeAsserting();
+  const Type *Ty = cast<const Type>((const Value *)T);
   assert(Ty->isStructType() && 
 	 "Can only create StructLayout annotation on structs!");
   return new StructLayout((const StructType *)Ty, TD);

llvm/lib/Transforms/Scalar/SymbolStripping.cpp

@@ -29,7 +29,7 @@ static bool StripSymbolTable(SymbolTable *SymTab) {
     SymbolTable::type_iterator B;
     while ((B = Plane.begin()) != Plane.end()) {   // Found nonempty type plane!
       Value *V = B->second;
-      if (V->isConstant() || V->isType())
+      if (isa<ConstPoolVal>(V) || isa<Type>(V))
 	SymTab->type_remove(B);
       else 
 	V->setName("", SymTab);   // Set name to "", removing from symbol table!

llvm/lib/VMCore/AsmWriter.cpp

@@ -143,9 +143,9 @@ void AssemblyWriter::processSymbolTable(const SymbolTable &ST) {
     
     for (; I != End; ++I) {
       const Value *V = I->second;
-      if (const ConstPoolVal *CPV = V->castConstant()) {
+      if (const ConstPoolVal *CPV = cast<const ConstPoolVal>(V)) {
 	processConstant(CPV);
-      } else if (const Type *Ty = V->castType()) {
+      } else if (const Type *Ty = cast<const Type>(V)) {
 	Out << "\t%" << I->first << " = type " << Ty->getDescription() << endl;
       }
     }

llvm/lib/VMCore/ConstPoolVals.cpp

@@ -127,10 +127,10 @@ string ConstPoolArray::getStrValue() const {
   string Result = "[";
   if (Operands.size()) {
     Result += " " + Operands[0]->getType()->getDescription() + 
-	      " " + Operands[0]->castConstantAsserting()->getStrValue();
+	      " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
     for (unsigned i = 1; i < Operands.size(); i++)
       Result += ", " + Operands[i]->getType()->getDescription() + 
-	         " " + Operands[i]->castConstantAsserting()->getStrValue();
+	         " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
   }
 
   return Result + " ]";
@@ -140,10 +140,10 @@ string ConstPoolStruct::getStrValue() const {
   string Result = "{";
   if (Operands.size()) {
     Result += " " + Operands[0]->getType()->getDescription() + 
-	      " " + Operands[0]->castConstantAsserting()->getStrValue();
+	      " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
     for (unsigned i = 1; i < Operands.size(); i++)
       Result += ", " + Operands[i]->getType()->getDescription() + 
-	         " " + Operands[i]->castConstantAsserting()->getStrValue();
+	         " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
   }
 
   return Result + " }";

llvm/lib/VMCore/ConstantHandling.cpp

@@ -238,7 +238,7 @@ struct DirectRules
 //
 Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) {
   assert(AID == ConstRules::AID && "Bad annotation for factory!");
-  const Type *Ty = ((const Value*)TyA)->castTypeAsserting();
+  const Type *Ty = cast<Type>((const Value*)TyA);
   
   switch (Ty->getPrimitiveID()) {
   case Type::BoolTyID: return new BoolRules();

llvm/lib/VMCore/SlotCalculator.cpp

@@ -250,13 +250,13 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore = false) {
   if (!dontIgnore)                               // Don't ignore nonignorables!
     if (D->getType() == Type::VoidTy ||          // Ignore void type nodes
 	(IgnoreNamedNodes &&                     // Ignore named and constants
-	 (D->hasName() || D->isConstant()) && !D->isType())) {
+	 (D->hasName() || isa<ConstPoolVal>(D)) && !isa<Type>(D))) {
       SC_DEBUG("ignored value " << D << endl);
       return -1;                  // We do need types unconditionally though
     }
 
   // If it's a type, make sure that all subtypes of the type are included...
-  if (const Type *TheTy = D->castType()) {
+  if (const Type *TheTy = dyn_cast<const Type>(D)) {
     SC_DEBUG("  Inserted type: " << TheTy->getDescription() << endl);
 
     // Loop over any contained types in the definition... in reverse depth first
@@ -289,7 +289,7 @@ int SlotCalculator::doInsertVal(const Value *D) {
 
   // Used for debugging DefSlot=-1 assertion...
   //if (Typ == Type::TypeTy)
-  //  cerr << "Inserting type '" << D->castTypeAsserting()->getDescription() << "'!\n";
+  //  cerr << "Inserting type '" << cast<Type>(D)->getDescription() << "'!\n";
 
   if (Typ->isDerivedType()) {
     int DefSlot = getValSlot(Typ);

llvm/lib/VMCore/SymbolTable.cpp

@@ -8,10 +8,6 @@
 #include "llvm/InstrTypes.h"
 #include "llvm/Support/StringExtras.h"
 #include "llvm/DerivedTypes.h"
-#ifndef NDEBUG
-#include "llvm/BasicBlock.h"   // Required for assertions to work.
-#include "llvm/Type.h"
-#endif
 
 SymbolTable::~SymbolTable() {
   // Drop all abstract type references in the type plane...
@@ -19,16 +15,16 @@ SymbolTable::~SymbolTable() {
   if (TyPlane != end()) {
     VarMap &TyP = TyPlane->second;
     for (VarMap::iterator I = TyP.begin(), E = TyP.end(); I != E; ++I) {
-      const Type *Ty = I->second->castTypeAsserting();
+      const Type *Ty = cast<const Type>(I->second);
       if (Ty->isAbstract())   // If abstract, drop the reference...
-	Ty->castDerivedTypeAsserting()->removeAbstractTypeUser(this);
+	cast<DerivedType>(Ty)->removeAbstractTypeUser(this);
     }
   }
 #ifndef NDEBUG   // Only do this in -g mode...
   bool LeftoverValues = true;
   for (iterator i = begin(); i != end(); ++i) {
     for (type_iterator I = i->second.begin(); I != i->second.end(); ++I)
-      if (!I->second->isConstant() && !I->second->isType()) {
+      if (!isa<ConstPoolVal>(I->second) && !isa<Type>(I->second)) {
 	cerr << "Value still in symbol table! Type = '"
 	     << i->first->getDescription() << "' Name = '" << I->first << "'\n";
 	LeftoverValues = false;
@@ -112,9 +108,9 @@ Value *SymbolTable::type_remove(const type_iterator &It) {
   // If we are removing an abstract type, remove the symbol table from it's use
   // list...
   if (Ty == Type::TypeTy) {
-    const Type *T = Result->castTypeAsserting();
+    const Type *T = cast<const Type>(Result);
     if (T->isAbstract())
-      T->castDerivedTypeAsserting()->removeAbstractTypeUser(this);
+      cast<DerivedType>(T)->removeAbstractTypeUser(this);
   }
 
   return Result;
@@ -149,9 +145,9 @@ void SymbolTable::insertEntry(const string &Name, Value *V) {
 
   // If we are adding an abstract type, add the symbol table to it's use list.
   if (VTy == Type::TypeTy) {
-    const Type *T = V->castTypeAsserting();
+    const Type *T = cast<const Type>(V);
     if (T->isAbstract())
-      T->castDerivedTypeAsserting()->addAbstractTypeUser(this);
+      cast<DerivedType>(T)->addAbstractTypeUser(this);
   }
 }
 
@@ -174,6 +170,6 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType,
       OldType->removeAbstractTypeUser(this);
       I->second = (Value*)NewType;  // TODO FIXME when types aren't const
       if (NewType->isAbstract())
-	NewType->castDerivedTypeAsserting()->addAbstractTypeUser(this);
+	cast<const DerivedType>(NewType)->addAbstractTypeUser(this);
     }
 }