6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-05 01:31:05 +00:00
Code Issues Projects Releases Wiki Activity

Move remaining stuff to the isInteger predicate.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@92771 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer 2010-01-05 21:05:54 +00:00
parent 718bf3f89d
commit 8c65f6e71c
14 changed files with 31 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Analysis/ValueTracking.cpp
View File

@ -1348,7 +1348,7 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset,
// Make sure the index-ee is a pointer to array of i8.
const PointerType *PT = cast<PointerType>(GEP->getOperand(0)->getType());
const ArrayType *AT = dyn_cast<ArrayType>(PT->getElementType());
if (AT == 0 || AT->getElementType() != Type::getInt8Ty(V->getContext()))
if (AT == 0 || !AT->getElementType()->isInteger(8))
return false;
// Check to make sure that the first operand of the GEP is an integer and
@ -1387,8 +1387,7 @@ bool llvm::GetConstantStringInfo(Value *V, std::string &Str, uint64_t Offset,
// Must be a Constant Array
ConstantArray *Array = dyn_cast<ConstantArray>(GlobalInit);
if (Array == 0 ||
Array->getType()->getElementType() != Type::getInt8Ty(V->getContext()))
if (Array == 0 || !Array->getType()->getElementType()->isInteger(8))
return false;
// Get the number of elements in the array

2
lib/AsmParser/LLParser.cpp
View File

@ -3656,7 +3656,7 @@ int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
}
}
if (Size && Size->getType() != Type::getInt32Ty(Context))
if (Size && !Size->getType()->isInteger(32))
return Error(SizeLoc, "element count must be i32");
if (isAlloca) {

2
lib/CodeGen/StackProtector.cpp
View File

@ -113,7 +113,7 @@ bool StackProtector::RequiresStackProtector() const {
if (const ArrayType *AT = dyn_cast<ArrayType>(AI->getAllocatedType())) {
// We apparently only care about character arrays.
if (AT->getElementType() != Type::getInt8Ty(AT->getContext()))
if (!AT->getElementType()->isInteger(8))
continue;
// If an array has more than SSPBufferSize bytes of allocated space,

8
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -356,7 +356,7 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
}
// FALLS THROUGH
case 1:
if (FTy->getParamType(0) != Type::getInt32Ty(Fn->getContext())) {
if (!FTy->getParamType(0)->isInteger(32)) {
llvm_report_error("Invalid type for first argument of main() supplied");
}
// FALLS THROUGH
@ -618,13 +618,11 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
GV.DoubleVal = GV.IntVal.bitsToDouble();
break;
case Type::FloatTyID:
assert(DestTy == Type::getInt32Ty(DestTy->getContext()) &&
"Invalid bitcast");
assert(DestTy->isInteger(32) && "Invalid bitcast");
GV.IntVal.floatToBits(GV.FloatVal);
break;
case Type::DoubleTyID:
assert(DestTy == Type::getInt64Ty(DestTy->getContext()) &&
"Invalid bitcast");
assert(DestTy->isInteger(64) && "Invalid bitcast");
GV.IntVal.doubleToBits(GV.DoubleVal);
break;
case Type::PointerTyID:

2
lib/ExecutionEngine/JIT/JIT.cpp
View File

@ -411,7 +411,7 @@ GenericValue JIT::runFunction(Function *F,
// Handle some common cases first. These cases correspond to common `main'
// prototypes.
if (RetTy == Type::getInt32Ty(F->getContext()) || RetTy->isVoidTy()) {
if (RetTy->isInteger(32) || RetTy->isVoidTy()) {
switch (ArgValues.size()) {
case 3:
if (FTy->getParamType(0)->isInteger(32) &&

3
lib/Target/X86/X86ISelLowering.cpp
View File

@ -7535,8 +7535,7 @@ bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
bool X86TargetLowering::isZExtFree(const Type *Ty1, const Type *Ty2) const {
// x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
return Ty1 == Type::getInt32Ty(Ty1->getContext()) &&
Ty2 == Type::getInt64Ty(Ty1->getContext()) && Subtarget->is64Bit();
return Ty1->isInteger(64) && Ty2->isInteger(64) && Subtarget->is64Bit();
}
bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {

2
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -1925,7 +1925,7 @@ GlobalVariable *GlobalOpt::FindGlobalCtors(Module &M) {
if (!ATy) return 0;
const StructType *STy = dyn_cast<StructType>(ATy->getElementType());
if (!STy || STy->getNumElements() != 2 ||
STy->getElementType(0) != Type::getInt32Ty(M.getContext())) return 0;
!STy->getElementType(0)->isInteger(32)) return 0;
const PointerType *PFTy = dyn_cast<PointerType>(STy->getElementType(1));
if (!PFTy) return 0;
const FunctionType *FTy = dyn_cast<FunctionType>(PFTy->getElementType());

2
lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -199,7 +199,7 @@ Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
// Extract the length and alignment and fill if they are constant.
ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
if (!LenC || !FillC || FillC->getType() != Type::getInt8Ty(MI->getContext()))
if (!LenC || !FillC || !FillC->getType()->isInteger(8))
return 0;
uint64_t Len = LenC->getZExtValue();
Alignment = MI->getAlignment();

3
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -596,8 +596,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
// (where tmp = 8*tmp2) into:
// getelementptr [100 x double]* %arr, i32 0, i32 %tmp2; bitcast
if (TD && isa<ArrayType>(SrcElTy) &&
ResElTy == Type::getInt8Ty(GEP.getContext())) {
if (TD && isa<ArrayType>(SrcElTy) && ResElTy->isInteger(8)) {
uint64_t ArrayEltSize =
TD->getTypeAllocSize(cast<ArrayType>(SrcElTy)->getElementType());

2
lib/Transforms/Instrumentation/ProfilingUtils.cpp
View File

@ -84,7 +84,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
AI = MainFn->arg_begin();
// If the program looked at argc, have it look at the return value of the
// init call instead.
if (AI->getType() != Type::getInt32Ty(Context)) {
if (!AI->getType()->isInteger(32)) {
Instruction::CastOps opcode;
if (!AI->use_empty()) {
opcode = CastInst::getCastOpcode(InitCall, true, AI->getType(), true);

21
lib/Transforms/Scalar/SimplifyLibCalls.cpp
View File

@ -505,8 +505,7 @@ static uint64_t GetStringLengthH(Value *V, SmallPtrSet<PHINode*, 32> &PHIs) {
// Must be a Constant Array
ConstantArray *Array = dyn_cast<ConstantArray>(GlobalInit);
if (!Array ||
Array->getType()->getElementType() != Type::getInt8Ty(V->getContext()))
if (!Array || !Array->getType()->getElementType()->isInteger(8))
return false;
// Get the number of elements in the array
@ -678,9 +677,7 @@ struct StrChrOpt : public LibCallOptimization {
if (!TD) return 0;
uint64_t Len = GetStringLength(SrcStr);
if (Len == 0 ||
FT->getParamType(1) != Type::getInt32Ty(*Context)) // memchr needs
// i32.
if (Len == 0 || !FT->getParamType(1)->isInteger(32)) // memchr needs i32.
return 0;
return EmitMemChr(SrcStr, CI->getOperand(2), // include nul.
@ -722,7 +719,7 @@ struct StrCmpOpt : public LibCallOptimization {
// Verify the "strcmp" function prototype.
const FunctionType *FT = Callee->getFunctionType();
if (FT->getNumParams() != 2 ||
FT->getReturnType() != Type::getInt32Ty(*Context) ||
!FT->getReturnType()->isInteger(32) ||
FT->getParamType(0) != FT->getParamType(1) ||
FT->getParamType(0) != Type::getInt8PtrTy(*Context))
return 0;
@ -770,7 +767,7 @@ struct StrNCmpOpt : public LibCallOptimization {
// Verify the "strncmp" function prototype.
const FunctionType *FT = Callee->getFunctionType();
if (FT->getNumParams() != 3 ||
FT->getReturnType() != Type::getInt32Ty(*Context) ||
!FT->getReturnType()->isInteger(32) ||
FT->getParamType(0) != FT->getParamType(1) ||
FT->getParamType(0) != Type::getInt8PtrTy(*Context) ||
!isa<IntegerType>(FT->getParamType(2)))
@ -991,7 +988,7 @@ struct MemCmpOpt : public LibCallOptimization {
const FunctionType *FT = Callee->getFunctionType();
if (FT->getNumParams() != 3 || !isa<PointerType>(FT->getParamType(0)) ||
!isa<PointerType>(FT->getParamType(1)) ||
FT->getReturnType() != Type::getInt32Ty(*Context))
!FT->getReturnType()->isInteger(32))
return 0;
Value *LHS = CI->getOperand(1), *RHS = CI->getOperand(2);
@ -1353,7 +1350,7 @@ struct FFSOpt : public LibCallOptimization {
// Just make sure this has 2 arguments of the same FP type, which match the
// result type.
if (FT->getNumParams() != 1 ||
FT->getReturnType() != Type::getInt32Ty(*Context) ||
!FT->getReturnType()->isInteger(32) ||
!isa<IntegerType>(FT->getParamType(0)))
return 0;
@ -1389,7 +1386,7 @@ struct IsDigitOpt : public LibCallOptimization {
const FunctionType *FT = Callee->getFunctionType();
// We require integer(i32)
if (FT->getNumParams() != 1 || !isa<IntegerType>(FT->getReturnType()) ||
FT->getParamType(0) != Type::getInt32Ty(*Context))
!FT->getParamType(0)->isInteger(32))
return 0;
// isdigit(c) -> (c-'0') <u 10
@ -1410,7 +1407,7 @@ struct IsAsciiOpt : public LibCallOptimization {
const FunctionType *FT = Callee->getFunctionType();
// We require integer(i32)
if (FT->getNumParams() != 1 || !isa<IntegerType>(FT->getReturnType()) ||
FT->getParamType(0) != Type::getInt32Ty(*Context))
!FT->getParamType(0)->isInteger(32))
return 0;
// isascii(c) -> c <u 128
@ -1451,7 +1448,7 @@ struct ToAsciiOpt : public LibCallOptimization {
const FunctionType *FT = Callee->getFunctionType();
// We require i32(i32)
if (FT->getNumParams() != 1 || FT->getReturnType() != FT->getParamType(0) ||
FT->getParamType(0) != Type::getInt32Ty(*Context))
!FT->getParamType(0)->isInteger(32))
return 0;
// isascii(c) -> c & 0x7f

8
lib/VMCore/ConstantFold.cpp
View File

@ -1229,10 +1229,10 @@ static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2,
// Ok, we have two differing integer indices. Sign extend them to be the same
// type. Long is always big enough, so we use it.
if (C1->getType() != Type::getInt64Ty(Context))
if (!C1->getType()->isInteger(64))
C1 = ConstantExpr::getSExt(C1, Type::getInt64Ty(Context));
if (C2->getType() != Type::getInt64Ty(Context))
if (!C2->getType()->isInteger(64))
C2 = ConstantExpr::getSExt(C2, Type::getInt64Ty(Context));
if (C1 == C2) return 0; // They are equal
@ -2042,10 +2042,10 @@ Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context,
// Before adding, extend both operands to i64 to avoid
// overflow trouble.
if (PrevIdx->getType() != Type::getInt64Ty(Context))
if (!PrevIdx->getType()->isInteger(64))
PrevIdx = ConstantExpr::getSExt(PrevIdx,
Type::getInt64Ty(Context));
if (Div->getType() != Type::getInt64Ty(Context))
if (!Div->getType()->isInteger(64))
Div = ConstantExpr::getSExt(Div,
Type::getInt64Ty(Context));

4
lib/VMCore/Constants.cpp
View File

@ -928,7 +928,7 @@ void ConstantArray::destroyConstant() {
/// if the elements of the array are all ConstantInt's.
bool ConstantArray::isString() const {
// Check the element type for i8...
if (getType()->getElementType() != Type::getInt8Ty(getContext()))
if (!getType()->getElementType()->isInteger(8))
return false;
// Check the elements to make sure they are all integers, not constant
// expressions.
@ -943,7 +943,7 @@ bool ConstantArray::isString() const {
/// null bytes except its terminator.
bool ConstantArray::isCString() const {
// Check the element type for i8...
if (getType()->getElementType() != Type::getInt8Ty(getContext()))
if (!getType()->getElementType()->isInteger(8))
return false;
// Last element must be a null.

7
lib/VMCore/Instructions.cpp
View File

@ -1391,8 +1391,7 @@ ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
if (!isa<VectorType>(Val->getType()) ||
Index->getType() != Type::getInt32Ty(Val->getContext()))
if (!isa<VectorType>(Val->getType()) || !Index->getType()->isInteger(32))
return false;
return true;
}
@ -1439,7 +1438,7 @@ bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType())
return false;// Second operand of insertelement must be vector element type.
if (Index->getType() != Type::getInt32Ty(Vec->getContext()))
if (!Index->getType()->isInteger(32))
return false; // Third operand of insertelement must be i32.
return true;
}
@ -1491,7 +1490,7 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
const VectorType *MaskTy = dyn_cast<VectorType>(Mask->getType());
if (!isa<Constant>(Mask) || MaskTy == 0 ||
MaskTy->getElementType() != Type::getInt32Ty(V1->getContext()))
!MaskTy->getElementType()->isInteger(32))
return false;
return true;
}