Replace all usages of Type::isPointerType with isa<PointerType>

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2486 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp
index 006a9920b549cd6aecb27af0c81091205604bbd6..cd68d04f8aee9abb1ef4bd1272356a5c4fdae4b5 100644 (file)
--- a/lib/Analysis/Expressions.cpp
+++ b/lib/Analysis/Expressions.cpp
@@ -76,7 +76,7 @@ struct DefOne : public DefVal {
 // happen for values in the range of 0 to 127.
 //
 static ConstantInt *getUnsignedConstant(uint64_t V, const Type *Ty) {
-  if (Ty->isPointerType()) Ty = Type::ULongTy;
+  if (isa<PointerType>(Ty)) Ty = Type::ULongTy;
   if (Ty->isSigned()) {
     // If this value is not a valid unsigned value for this type, return null!
     if (V > 127 && ((int64_t)V < 0 ||
@@ -320,7 +320,7 @@ ExprType analysis::ClassifyExpression(Value *Expr) {
   case Instruction::Cast: {
     ExprType Src(ClassifyExpression(I->getOperand(0)));
     const Type *DestTy = I->getType();
-    if (DestTy->isPointerType())
+    if (isa<PointerType>(DestTy))
       DestTy = Type::ULongTy;  // Pointer types are represented as ulong
 
     /*

diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
index 627c7ff5f37092e57e00731c27537e513517b18a..1723a8edac7c77af55a8de4f6cba71907a715f28 100644 (file)
--- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
+++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp
@@ -57,7 +57,7 @@ bool FindUnsafePointerTypes::run(Module *Mod) {
     for (const_inst_iterator I = inst_begin(M), E = inst_end(M); I != E; ++I) {
       const Instruction *Inst = *I;
       const Type *ITy = Inst->getType();
-      if (ITy->isPointerType() && !UnsafeTypes.count((PointerType*)ITy))
+      if (isa<PointerType>(ITy) && !UnsafeTypes.count((PointerType*)ITy))
         if (!isSafeInstruction(Inst)) {
           UnsafeTypes.insert((PointerType*)ITy);
 

diff --git a/lib/Analysis/InductionVariable.cpp b/lib/Analysis/InductionVariable.cpp
index f0b01e845542262e759644ff38ee8bc04a7ac87d..b3da95f0902fd77f03350f320a47d4e32cf4720c 100644 (file)
--- a/lib/Analysis/InductionVariable.cpp
+++ b/lib/Analysis/InductionVariable.cpp
@@ -99,7 +99,7 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) {
 
     // Okay, we have found an induction variable. Save the start and step values
     const Type *ETy = Phi->getType();
-    if (ETy->isPointerType()) ETy = Type::ULongTy;
+    if (isa<PointerType>(ETy)) ETy = Type::ULongTy;
 
     Start = (Value*)(E1.Offset ? E1.Offset : ConstantInt::get(ETy, 0));
     Step  = (Value*)(E2.Offset ? E2.Offset : ConstantInt::get(ETy, 0));
@@ -132,7 +132,7 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) {
          StepE.Var != Phi) return;
 
       const Type *ETy = Phi->getType();
-      if (ETy->isPointerType()) ETy = Type::ULongTy;
+      if (isa<PointerType>(ETy)) ETy = Type::ULongTy;
       Step  = (Value*)(StepE.Offset ? StepE.Offset : ConstantInt::get(ETy, 0));
     } else {   // We were able to get a step value, simplify with expr analysis
       ExprType StepE = analysis::ClassifyExpression(Step);
@@ -145,7 +145,7 @@ InductionVariable::InductionVariable(PHINode *P, LoopInfo *LoopInfo) {
         else
           Step = Constant::getNullValue(Step->getType());
         const Type *ETy = Phi->getType();
-        if (ETy->isPointerType()) ETy = Type::ULongTy;
+        if (isa<PointerType>(ETy)) ETy = Type::ULongTy;
         Step  = (Value*)(StepE.Offset ? StepE.Offset : ConstantInt::get(ETy,0));
       }
     }

diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index f2eccf53e86d813ef2c192e251039756f78ed6e0..4faf70cf8eb56cdbf6dab8a1fb0dbb70a1c9b6d8 100644 (file)
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -321,7 +321,7 @@ static Value *getValNonImprovising(const Type *Ty, const ValID &D) {
     return ConstantFP::get(Ty, D.ConstPoolFP);
     
   case ValID::ConstNullVal:      // Is it a null value?
-    if (!Ty->isPointerType())
+    if (!isa<PointerType>(Ty))
       ThrowException("Cannot create a a non pointer null!");
     return ConstantPointerNull::get(cast<PointerType>(Ty));
     
@@ -1549,14 +1549,14 @@ MemoryInst : MALLOC Types {
     delete $2;
   }
   | FREE ResolvedVal {
-    if (!$2->getType()->isPointerType())
+    if (!isa<PointerType>($2->getType()))
       ThrowException("Trying to free nonpointer type " + 
                      $2->getType()->getDescription() + "!");
     $$ = new FreeInst($2);
   }
 
   | LOAD Types ValueRef IndexList {
-    if (!(*$2)->isPointerType())
+    if (!isa<PointerType>(*$2))
       ThrowException("Can't load from nonpointer type: " +
                     (*$2)->getDescription());
     if (LoadInst::getIndexedType(*$2, *$4) == 0)
@@ -1567,7 +1567,7 @@ MemoryInst : MALLOC Types {
     delete $2;
   }
   | STORE ResolvedVal ',' Types ValueRef IndexList {
-    if (!(*$4)->isPointerType())
+    if (!isa<PointerType>(*$4))
       ThrowException("Can't store to a nonpointer type: " +
                      (*$4)->getDescription());
     const Type *ElTy = StoreInst::getIndexedType(*$4, *$6);
@@ -1580,7 +1580,7 @@ MemoryInst : MALLOC Types {
     delete $4; delete $6;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
-    if (!(*$2)->isPointerType())
+    if (!isa<PointerType>(*$2))
       ThrowException("getelementptr insn requires pointer operand!");
     if (!GetElementPtrInst::getIndexedType(*$2, *$4, true))
       ThrowException("Can't get element ptr '" + (*$2)->getDescription()+ "'!");

diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index 2d28db1b4c0f3827538e90a5ef5fae6d3871510a..9b98d945305c2e5d3b0faf154f1d61513af078d9 100644 (file)
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -345,7 +345,7 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
 
   case Instruction::Free:
     V = getValue(Raw.Ty, Raw.Arg1);
-    if (!V->getType()->isPointerType()) return failure(true);
+    if (!isa<PointerType>(V->getType())) return failure(true);
     Res = new FreeInst(V);
     return false;
 

diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index 70a6ae97f3e4c97ac9add5f3c93064e194047919..c4ab67f91b40650516ff51fd5598429d1af1f33b 100644 (file)
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -389,7 +389,7 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
     // VarType Fields: bit0 = isConstant, bit1 = hasInitializer,
     // bit2 = isInternal, bit3+ = slot#
     const Type *Ty = getType(VarType >> 3);
-    if (!Ty || !Ty->isPointerType()) { 
+    if (!Ty || !isa<PointerType>(Ty)) { 
       Error = "Global not pointer type!  Ty = " + Ty->getDescription();
       return failure(true); 
     }

diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
index 2c1ce975bcf9e5604ee392d3f362a7ae71da8ba9..7ab953cf3cb57a08999cc1845d7f2c523cbb5897 100644 (file)
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ b/lib/Bytecode/Writer/InstructionWriter.cpp
@@ -198,7 +198,7 @@ void BytecodeWriter::processInstruction(const Instruction *I) {
     break;
   case Instruction::Store:
     Ty = I->getOperand(1)->getType();  // Encode the pointer type...
-    assert(Ty->isPointerType() && "Store to nonpointer type!?!?");
+    assert(isa<PointerType>(Ty) && "Store to nonpointer type!?!?");
     break;
   default:              // Otherwise use the default behavior...
     Ty = NumOperands ? I->getOperand(0)->getType() : I->getType();

diff --git a/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp b/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
index d06ac172db0c8b676d90202db41f8ecb4902dd88..8cf36f83ed81ba062c1098eb0a0e909cfaa011ad 100644 (file)
--- a/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
@@ -277,7 +277,7 @@ ChooseRegOrImmed(Value* val,
   
   // Otherwise it needs to be an integer or a NULL pointer
   if (! CPV->getType()->isIntegral() &&
-      ! (CPV->getType()->isPointerType() &&
+      ! (isa<PointerType>(CPV->getType()) &&
          CPV->isNullValue()))
     return opType;
   
@@ -287,7 +287,7 @@ ChooseRegOrImmed(Value* val,
   // unsigned constants to signed).
   // 
   int64_t intValue;
-  if (CPV->getType()->isPointerType())
+  if (isa<PointerType>(CPV->getType()))
     {
       intValue = 0;
     }

diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
index d06ac172db0c8b676d90202db41f8ecb4902dd88..8cf36f83ed81ba062c1098eb0a0e909cfaa011ad 100644 (file)
--- a/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
@@ -277,7 +277,7 @@ ChooseRegOrImmed(Value* val,
   
   // Otherwise it needs to be an integer or a NULL pointer
   if (! CPV->getType()->isIntegral() &&
-      ! (CPV->getType()->isPointerType() &&
+      ! (isa<PointerType>(CPV->getType()) &&
          CPV->isNullValue()))
     return opType;
   
@@ -287,7 +287,7 @@ ChooseRegOrImmed(Value* val,
   // unsigned constants to signed).
   // 
   int64_t intValue;
-  if (CPV->getType()->isPointerType())
+  if (isa<PointerType>(CPV->getType()))
     {
       intValue = 0;
     }

diff --git a/lib/Target/SparcV9/SparcV9InstrInfo.cpp b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
index 71380ed92a2bc6ca5345a1632e0dd090336e195d..fd18841dc18daa1e7c9391339c8c20a25866643b 100644 (file)
--- a/lib/Target/SparcV9/SparcV9InstrInfo.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
@@ -235,9 +235,9 @@ UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(Function *F,
                                          std::vector<TmpInstruction*>& tempVec,
                                          TargetMachine& target) const
 {
-  assert((val->getType()->isIntegral() || val->getType()->isPointerType())
+  assert((val->getType()->isIntegral() || isa<PointerType>(val->getType()))
          && "Source type must be integral");
-  assert((dest->getType() == Type::FloatTy || dest->getType() == Type::DoubleTy)
+  assert(dest->getType()->isFloatingPoint()
          && "Dest type must be float/double");
   
   MachineCodeForMethod& mcinfo = MachineCodeForMethod::get(F);
@@ -279,9 +279,9 @@ UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(Function *F,
                                         std::vector<TmpInstruction*>& tempVec,
                                         TargetMachine& target) const
 {
-  assert((val->getType() ==Type::FloatTy || val->getType() ==Type::DoubleTy)
+  assert(val->getType()->isFloatingPoint()
          && "Source type must be float/double");
-  assert((dest->getType()->isIntegral() || dest->getType()->isPointerType())
+  assert((dest->getType()->isIntegral() || isa<PointerType>(dest->getType()))
          && "Dest type must be integral");
   
   MachineCodeForMethod& mcinfo = MachineCodeForMethod::get(F);

diff --git a/lib/Target/SparcV9/SparcV9InstrSelection.cpp b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
index 7054ae9c44d825697c8c1ff31971f7487da86eee..7109ba4a35cf7eef0fa944edf6c3f96284bc385e 100644 (file)
--- a/lib/Target/SparcV9/SparcV9InstrSelection.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
@@ -176,9 +176,7 @@ ChooseBccInstruction(const InstructionNode* instrNode,
   BinaryOperator* setCCInstr = (BinaryOperator*) setCCNode->getInstruction();
   const Type* setCCType = setCCInstr->getOperand(0)->getType();
   
-  isFPBranch = (setCCType == Type::FloatTy || setCCType == Type::DoubleTy); 
-  
-  if (isFPBranch) 
+  if (setCCType->isFloatingPoint())
     return ChooseBFpccInstruction(instrNode, setCCInstr);
   else
     return ChooseBpccInstruction(instrNode, setCCInstr);
@@ -387,10 +385,8 @@ CreateAddConstInstruction(const InstructionNode* instrNode)
   // 
   const Type* resultType = instrNode->getInstruction()->getType();
   
-  if (resultType == Type::FloatTy ||
-      resultType == Type::DoubleTy)
-    {
-      double dval = cast<ConstantFP>(constOp)->getValue();
+  if (ConstantFP *FPC = dyn_cast<ConstantFP>(constOp)) {
+      double dval = FPC->getValue();
       if (dval == 0.0)
         minstr = CreateMovFloatInstruction(instrNode, resultType);
     }
@@ -404,8 +400,7 @@ ChooseSubInstructionByType(const Type* resultType)
 {
   MachineOpCode opCode = INVALID_OPCODE;
   
-  if (resultType->isIntegral() ||
-      resultType->isPointerType())
+  if (resultType->isIntegral() || isa<PointerType>(resultType))
     {
       opCode = SUB;
     }
@@ -435,13 +430,11 @@ CreateSubConstInstruction(const InstructionNode* instrNode)
   // 
   const Type* resultType = instrNode->getInstruction()->getType();
   
-  if (resultType == Type::FloatTy ||
-      resultType == Type::DoubleTy)
-    {
-      double dval = cast<ConstantFP>(constOp)->getValue();
-      if (dval == 0.0)
-        minstr = CreateMovFloatInstruction(instrNode, resultType);
-    }
+  if (ConstantFP *FPC = dyn_cast<ConstantFP>(constOp)) {
+    double dval = FPC->getValue();
+    if (dval == 0.0)
+      minstr = CreateMovFloatInstruction(instrNode, resultType);
+  }
   
   return minstr;
 }
@@ -537,7 +530,7 @@ CreateMulConstInstruction(const TargetMachine &target,
   // 
   const Type* resultType = destVal->getType();
   
-  if (resultType->isIntegral() || resultType->isPointerType())
+  if (resultType->isIntegral() || isa<PointerType>(resultType))
     {
       unsigned pow;
       bool isValidConst;
@@ -583,10 +576,9 @@ CreateMulConstInstruction(const TargetMachine &target,
     }
   else
     {
-      if (resultType == Type::FloatTy ||
-          resultType == Type::DoubleTy)
+      if (ConstantFP *FPC = dyn_cast<ConstantFP>(constOp))
         {
-          double dval = cast<ConstantFP>(constOp)->getValue();
+          double dval = FPC->getValue();
           if (fabs(dval) == 1)
             {
               bool needNeg = (dval < 0);
@@ -771,10 +763,9 @@ CreateDivConstInstruction(TargetMachine &target,
     }
   else
     {
-      if (resultType == Type::FloatTy ||
-          resultType == Type::DoubleTy)
+      if (ConstantFP *FPC = dyn_cast<ConstantFP>(constOp))
         {
-          double dval = cast<ConstantFP>(constOp)->getValue();
+          double dval = FPC->getValue();
           if (fabs(dval) == 1)
             {
               bool needNeg = (dval < 0);
@@ -987,7 +978,7 @@ SetMemOperands_Internal(vector<MachineInstr*>& mvec,
       
       // This is a real structure reference if the ptr target is a
       // structure type, and the first offset is [0] (eliminate that offset).
-      if (firstIndexIsZero && ptrType->getElementType()->isStructType())
+      if (firstIndexIsZero && isa<StructType>(ptrType->getElementType()))
         {
           // Compute the offset value using the index vector. Create a
           // virtual reg. for it since it may not fit in the immed field.
@@ -1373,7 +1364,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
         bool isValidConst;
         
         if ((constVal->getType()->isIntegral()
-             || constVal->getType()->isPointerType())
+             || isa<PointerType>(constVal->getType()))
             && GetConstantValueAsSignedInt(constVal, isValidConst) == 0
             && isValidConst)
           {
@@ -1519,7 +1510,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       case 22: // reg:   ToBoolTy(reg):
       {
         const Type* opType = subtreeRoot->leftChild()->getValue()->getType();
-        assert(opType->isIntegral() || opType->isPointerType()
+        assert(opType->isIntegral() || isa<PointerType>(opType)
                || opType == Type::BoolTy);
         forwardOperandNum = 0;          // forward first operand to user
         break;
@@ -1532,7 +1523,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       {
         const Type* opType = subtreeRoot->leftChild()->getValue()->getType();
         assert(opType->isIntegral() ||
-               opType->isPointerType() ||
+               isa<PointerType>(opType) ||
                opType == Type::BoolTy && "Cast is illegal for other types");
         forwardOperandNum = 0;          // forward first operand to user
         break;
@@ -1545,7 +1536,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       {
         const Type* opType = subtreeRoot->leftChild()->getValue()->getType();
         if (opType->isIntegral()
-            || opType->isPointerType()
+            || isa<PointerType>(opType)
             || opType == Type::BoolTy)
           {
             forwardOperandNum = 0;          // forward first operand to user
@@ -1559,7 +1550,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
             Value* destForCast;
             vector<MachineInstr*> minstrVec;
             
-            if (opType == Type::FloatTy || opType == Type::DoubleTy)
+            if (opType->isFloatingPoint())
               {
                 // Create a temporary to represent the INT register
                 // into which the FP value will be copied via memory.
@@ -1629,7 +1620,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
                 Instruction *dest = subtreeRoot->getInstruction();
                 Value* srcForCast;
                 int n = 0;
-                if (opType != Type::FloatTy && opType != Type::DoubleTy)
+                if (opType->isFloatingPoint())
                   {
                     // Create a temporary to represent the FP register
                     // into which the integer will be copied via memory.
@@ -1872,12 +1863,11 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
         // a FP condition code register.
         // 
         Value* leftVal = subtreeRoot->leftChild()->getValue();
-        bool isFPCompare = (leftVal->getType() == Type::FloatTy || 
-                            leftVal->getType() == Type::DoubleTy);
+        bool isFPCompare = leftVal->getType()->isFloatingPoint();
         
         TmpInstruction* tmpForCC = GetTmpForCC(setCCInstr,
                                      setCCInstr->getParent()->getParent(),
-                                     isFPCompare? Type::FloatTy : Type::IntTy);
+                                     isFPCompare ? Type::FloatTy : Type::IntTy);
         MachineCodeForInstruction::get(setCCInstr).addTemp(tmpForCC);
         
         if (! isFPCompare)
@@ -2104,8 +2094,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       case 62: // reg:   Shl(reg, reg)
       { const Type* opType = subtreeRoot->leftChild()->getValue()->getType();
         assert(opType->isIntegral()
-               || opType == Type::BoolTy
-               || opType->isPointerType()&& "Shl unsupported for other types");
+               || isa<PointerType>(opType)&& "Shl unsupported for other types");
         mvec.push_back(new MachineInstr((opType == Type::LongTy)? SLLX : SLL));
         Set3OperandsFromInstr(mvec.back(), subtreeRoot, target);
         break;
@@ -2114,8 +2103,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
       case 63: // reg:   Shr(reg, reg)
       { const Type* opType = subtreeRoot->leftChild()->getValue()->getType();
         assert(opType->isIntegral()
-               || opType == Type::BoolTy
-               || opType->isPointerType() &&"Shr unsupported for other types");
+               || isa<PointerType>(opType) &&"Shr unsupported for other types");
         mvec.push_back(new MachineInstr((opType->isSigned()
                                    ? ((opType == Type::LongTy)? SRAX : SRA)
                                    : ((opType == Type::LongTy)? SRLX : SRL))));

diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index 8479c6c8dbdae0a92b230538a858fbe901ba84d3..0df95209b555aec4e458b488d5441ec942340c03 100644 (file)
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -61,10 +61,10 @@ 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 = cast<const Type>((const Value *)T);
-  assert(Ty->isStructType() && 
+  const Type *Ty = cast<Type>((const Value *)T);
+  assert(isa<StructType>(Ty) && 
         "Can only create StructLayout annotation on structs!");
-  return new StructLayout((const StructType *)Ty, TD);
+  return new StructLayout(cast<StructType>(Ty), TD);
 }
 
 //===----------------------------------------------------------------------===//

diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index 0a62d1cae069f313e6cfaafad6e0dd28a5fa62d5..3d0c753d9f3cff0862f23ad68f33e592c3306114 100644 (file)
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -16,7 +16,7 @@ static inline const Type *checkType(const Type *Ty) {
 AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
                                const std::string &Name = "")
   : Instruction(Ty, iTy, Name) {
-  assert(Ty->isPointerType() && "Can't allocate a non pointer type!");
+  assert(isa<PointerType>(Ty) && "Can't allocate a non pointer type!");
 
   // ArraySize defaults to 1.
   if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1);
@@ -51,7 +51,7 @@ const Type *AllocationInst::getAllocatedType() const {
 const Type* MemAccessInst::getIndexedType(const Type *Ptr, 
                                          const std::vector<Value*> &Idx,
                                          bool AllowCompositeLeaf = false) {
-  if (!Ptr->isPointerType()) return 0;   // Type isn't a pointer type!
+  if (!isa<PointerType>(Ptr)) return 0;   // Type isn't a pointer type!
 
   // Handle the special case of the empty set index set...
   if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
@@ -143,7 +143,7 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
 //===----------------------------------------------------------------------===//
 
 FreeInst::FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") {
-  assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!");
+  assert(isa<PointerType>(Ptr->getType()) && "Can't free nonpointer!");
   Operands.reserve(1);
   Operands.push_back(Use(Ptr, this));
 }