From 9b625030c8427a3bc56f5993c0b5b214c393042f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 6 May 2002 16:15:30 +0000 Subject: [PATCH] Replace all usages of Type::isPointerType with isa git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2486 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/Expressions.cpp | 4 +- lib/Analysis/IPA/FindUnsafePointerTypes.cpp | 2 +- lib/Analysis/InductionVariable.cpp | 6 +- lib/AsmParser/llvmAsmParser.y | 10 +-- lib/Bytecode/Reader/InstructionReader.cpp | 2 +- lib/Bytecode/Reader/Reader.cpp | 2 +- lib/Bytecode/Writer/InstructionWriter.cpp | 2 +- .../InstrSelection/InstrSelectionSupport.cpp | 4 +- .../InstrSelection/InstrSelectionSupport.cpp | 4 +- lib/Target/SparcV9/SparcV9InstrInfo.cpp | 8 +-- lib/Target/SparcV9/SparcV9InstrSelection.cpp | 62 ++++++++----------- lib/Target/TargetData.cpp | 6 +- lib/VMCore/iMemory.cpp | 6 +- 13 files changed, 53 insertions(+), 65 deletions(-) diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index 006a9920b54..cd68d04f8ae 100644 --- 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(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(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 627c7ff5f37..1723a8edac7 100644 --- 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(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 f0b01e84554..b3da95f0902 100644 --- 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(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(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(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 f2eccf53e86..4faf70cf8eb 100644 --- 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(Ty)) ThrowException("Cannot create a a non pointer null!"); return ConstantPointerNull::get(cast(Ty)); @@ -1549,14 +1549,14 @@ MemoryInst : MALLOC Types { delete $2; } | FREE ResolvedVal { - if (!$2->getType()->isPointerType()) + if (!isa($2->getType())) ThrowException("Trying to free nonpointer type " + $2->getType()->getDescription() + "!"); $$ = new FreeInst($2); } | LOAD Types ValueRef IndexList { - if (!(*$2)->isPointerType()) + if (!isa(*$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(*$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(*$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 2d28db1b4c0..9b98d945305 100644 --- 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(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 70a6ae97f3e..c4ab67f91b4 100644 --- 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(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 2c1ce975bcf..7ab953cf3cb 100644 --- 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(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 d06ac172db0..8cf36f83ed8 100644 --- 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(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(CPV->getType())) { intValue = 0; } diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp index d06ac172db0..8cf36f83ed8 100644 --- 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(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(CPV->getType())) { intValue = 0; } diff --git a/lib/Target/SparcV9/SparcV9InstrInfo.cpp b/lib/Target/SparcV9/SparcV9InstrInfo.cpp index 71380ed92a2..fd18841dc18 100644 --- a/lib/Target/SparcV9/SparcV9InstrInfo.cpp +++ b/lib/Target/SparcV9/SparcV9InstrInfo.cpp @@ -235,9 +235,9 @@ UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(Function *F, std::vector& tempVec, TargetMachine& target) const { - assert((val->getType()->isIntegral() || val->getType()->isPointerType()) + assert((val->getType()->isIntegral() || isa(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& 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(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 7054ae9c44d..7109ba4a35c 100644 --- 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(constOp)->getValue(); + if (ConstantFP *FPC = dyn_cast(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(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(constOp)->getValue(); - if (dval == 0.0) - minstr = CreateMovFloatInstruction(instrNode, resultType); - } + if (ConstantFP *FPC = dyn_cast(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(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(constOp)) { - double dval = cast(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(constOp)) { - double dval = cast(constOp)->getValue(); + double dval = FPC->getValue(); if (fabs(dval) == 1) { bool needNeg = (dval < 0); @@ -987,7 +978,7 @@ SetMemOperands_Internal(vector& 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(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(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(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(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(opType) || opType == Type::BoolTy) { forwardOperandNum = 0; // forward first operand to user @@ -1559,7 +1550,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot, Value* destForCast; vector 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(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(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 8479c6c8dbd..0df95209b55 100644 --- 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 Value *)T); - assert(Ty->isStructType() && + const Type *Ty = cast((const Value *)T); + assert(isa(Ty) && "Can only create StructLayout annotation on structs!"); - return new StructLayout((const StructType *)Ty, TD); + return new StructLayout(cast(Ty), TD); } //===----------------------------------------------------------------------===// diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp index 0a62d1cae06..3d0c753d9f3 100644 --- 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(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 &Idx, bool AllowCompositeLeaf = false) { - if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type! + if (!isa(Ptr)) return 0; // Type isn't a pointer type! // Handle the special case of the empty set index set... if (Idx.empty()) return cast(Ptr)->getElementType(); @@ -143,7 +143,7 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &Idx, //===----------------------------------------------------------------------===// FreeInst::FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") { - assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!"); + assert(isa(Ptr->getType()) && "Can't free nonpointer!"); Operands.reserve(1); Operands.push_back(Use(Ptr, this)); }