if (V1 == V2) return MustAlias;
if ((!isa<PointerType>(V1->getType()) || !isa<PointerType>(V2->getType())) &&
- V1->getType() != Type::LongTy && V2->getType() != Type::LongTy)
+ V1->getType() != Type::Int64Ty && V2->getType() != Type::Int64Ty)
return NoAlias; // Scalars cannot alias each other
// Strip off cast instructions...
if (Constant *C1 = dyn_cast<Constant>(V1))
if (Constant *C2 = dyn_cast<Constant>(V2)) {
// Sign extend the constants to long types, if necessary
- if (C1->getType()->getPrimitiveSizeInBits() < 64)
- C1 = ConstantExpr::getSExt(C1, Type::LongTy);
- else if (C1->getType() == Type::ULongTy)
- C1 = ConstantExpr::getBitCast(C1, Type::LongTy);
- if (C2->getType()->getPrimitiveSizeInBits() < 64)
- C2 = ConstantExpr::getSExt(C2, Type::LongTy);
- else if (C2->getType() == Type::ULongTy)
- C2 = ConstantExpr::getBitCast(C2, Type::LongTy);
+ if (C1->getType() != Type::Int64Ty)
+ C1 = ConstantExpr::getSExt(C1, Type::Int64Ty);
+ if (C2->getType() != Type::Int64Ty)
+ C2 = ConstantExpr::getSExt(C2, Type::Int64Ty);
return C1 == C2;
}
return false;
if (Constant *G2OC = dyn_cast<ConstantInt>(const_cast<Value*>(G2Oper))){
if (G1OC->getType() != G2OC->getType()) {
// Sign extend both operands to long.
- if (G1OC->getType()->getPrimitiveSizeInBits() < 64)
- G1OC = ConstantExpr::getSExt(G1OC, Type::LongTy);
- else if (G1OC->getType() == Type::ULongTy)
- G1OC = ConstantExpr::getBitCast(G1OC, Type::LongTy);
- if (G2OC->getType()->getPrimitiveSizeInBits() < 64)
- G2OC = ConstantExpr::getSExt(G2OC, Type::LongTy);
- else if (G2OC->getType() == Type::ULongTy)
- G2OC = ConstantExpr::getBitCast(G2OC, Type::LongTy);
+ if (G1OC->getType() != Type::Int64Ty)
+ G1OC = ConstantExpr::getSExt(G1OC, Type::Int64Ty);
+ if (G2OC->getType() != Type::Int64Ty)
+ G2OC = ConstantExpr::getSExt(G2OC, Type::Int64Ty);
GEP1Ops[FirstConstantOper] = G1OC;
GEP2Ops[FirstConstantOper] = G2OC;
}
const Type *ZeroIdxTy = GEPPointerTy;
for (unsigned i = 0; i != FirstConstantOper; ++i) {
if (!isa<StructType>(ZeroIdxTy))
- GEP1Ops[i] = GEP2Ops[i] = Constant::getNullValue(Type::UIntTy);
+ GEP1Ops[i] = GEP2Ops[i] = Constant::getNullValue(Type::Int32Ty);
if (const CompositeType *CT = dyn_cast<CompositeType>(ZeroIdxTy))
ZeroIdxTy = CT->getTypeAtIndex(GEP1Ops[i]);
// value possible.
//
if (const ArrayType *AT = dyn_cast<ArrayType>(BasePtr1Ty))
- GEP1Ops[i] = ConstantInt::get(Type::LongTy, AT->getNumElements()-1);
+ GEP1Ops[i] = ConstantInt::get(Type::Int64Ty, AT->getNumElements()-1);
else if (const PackedType *PT = dyn_cast<PackedType>(BasePtr1Ty))
- GEP1Ops[i] = ConstantInt::get(Type::LongTy, PT->getNumElements()-1);
+ GEP1Ops[i] = ConstantInt::get(Type::Int64Ty, PT->getNumElements()-1);
}
}
break;
}
} else if (ConstantInt *Op = dyn_cast<ConstantInt>(Operands[0])) {
- assert(Op->getType()->isUnsigned() && "bswap args must be unsigned");
uint64_t V = Op->getZExtValue();
if (Name == "llvm.bswap.i16")
return ConstantInt::get(Ty, ByteSwap_16(V));
ConstantRange SCEV::getValueRange() const {
const Type *Ty = getType();
assert(Ty->isInteger() && "Can't get range for a non-integer SCEV!");
- Ty = Ty->getUnsignedVersion();
// Default to a full range if no better information is available.
return ConstantRange(getType());
}
}
SCEVHandle SCEVConstant::get(ConstantInt *V) {
- // Make sure that SCEVConstant instances are all unsigned.
- // FIXME:Signless. This entire if statement can be removed when integer types
- // are signless. There won't be a need to bitcast then.
- if (V->getType()->isSigned()) {
- const Type *NewTy = V->getType()->getUnsignedVersion();
- V = cast<ConstantInt>(ConstantExpr::getBitCast(V, NewTy));
- }
-
SCEVConstant *&R = (*SCEVConstants)[V];
if (R == 0) R = new SCEVConstant(V);
return R;
}
const Type *SCEVSDivExpr::getType() const {
- const Type *Ty = LHS->getType();
- if (Ty->isUnsigned()) Ty = Ty->getSignedVersion();
- return Ty;
+ return LHS->getType();
}
// SCEVAddRecExprs - Only allow the creation of one SCEVAddRecExpr for any
uint64_t Result = 1;
for (; NumSteps; --NumSteps)
Result *= Val-(NumSteps-1);
- Constant *Res = ConstantInt::get(Type::ULongTy, Result);
+ Constant *Res = ConstantInt::get(Type::Int64Ty, Result);
return SCEVUnknown::get(ConstantExpr::getTruncOrBitCast(Res, V->getType()));
}
case Instruction::Trunc:
// We don't handle trunc to bool yet.
if (I->getType()->isInteger())
- return SCEVTruncateExpr::get(getSCEV(I->getOperand(0)),
- I->getType()->getUnsignedVersion());
+ return SCEVTruncateExpr::get(getSCEV(I->getOperand(0)), I->getType());
break;
case Instruction::ZExt:
// We don't handle zext from bool yet.
if (I->getOperand(0)->getType()->isInteger())
- return SCEVZeroExtendExpr::get(getSCEV(I->getOperand(0)),
- I->getType()->getUnsignedVersion());
+ return SCEVZeroExtendExpr::get(getSCEV(I->getOperand(0)), I->getType());
break;
case Instruction::BitCast:
// Form the constant range.
ConstantRange CompRange(Cond, CompVal);
- // Now that we have it, if it's signed, convert it to an unsigned
- // range.
- // FIXME:Signless. This entire if statement can go away when
- // integers are signless. ConstantRange is already signless.
- if (CompRange.getLower()->getType()->isSigned()) {
- const Type *NewTy = RHSC->getValue()->getType();
- Constant *NewL = ConstantExpr::getBitCast(CompRange.getLower(),
- NewTy);
- Constant *NewU = ConstantExpr::getBitCast(CompRange.getUpper(),
- NewTy);
- CompRange = ConstantRange(NewL, NewU);
- }
-
SCEVHandle Ret = AddRec->getNumIterationsInRange(CompRange,
- ICmpInst::isSignedPredicate(Cond));
+ false /*Always treat as unsigned range*/);
if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
}
}
unsigned MaxSteps = MaxBruteForceIterations;
for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
ConstantInt *ItCst =
- ConstantInt::get(IdxExpr->getType()->getUnsignedVersion(), IterationNum);
+ ConstantInt::get(IdxExpr->getType(), IterationNum);
ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst);
// Form the GEP offset.
if (CondVal->getValue() == ExitWhen) {
ConstantEvolutionLoopExitValue[PN] = PHIVal;
++NumBruteForceTripCountsComputed;
- return SCEVConstant::get(ConstantInt::get(Type::UIntTy, IterationNum));
+ return SCEVConstant::get(ConstantInt::get(Type::Int32Ty, IterationNum));
}
// Compute the value of the PHI node for the next iteration.
SqrtTerm = ConstantExpr::getSub(ConstantExpr::getMul(B, B), SqrtTerm);
// Compute floor(sqrt(B^2-4ac))
- ConstantInt *SqrtVal =
- cast<ConstantInt>(ConstantExpr::getBitCast(SqrtTerm,
- SqrtTerm->getType()->getUnsignedVersion()));
- uint64_t SqrtValV = SqrtVal->getZExtValue();
+ uint64_t SqrtValV = cast<ConstantInt>(SqrtTerm)->getZExtValue();
uint64_t SqrtValV2 = (uint64_t)sqrt((double)SqrtValV);
// The square root might not be precise for arbitrary 64-bit integer
// values. Do some sanity checks to ensure it's correct.
return std::make_pair(CNC, CNC);
}
- SqrtVal = ConstantInt::get(Type::ULongTy, SqrtValV2);
+ ConstantInt *SqrtVal = ConstantInt::get(Type::Int64Ty, SqrtValV2);
SqrtTerm = ConstantExpr::getTruncOrBitCast(SqrtVal, SqrtTerm->getType());
Constant *NegB = ConstantExpr::getNeg(B);
Constant *TwoA = ConstantExpr::getMul(A, Two);
// The divisions must be performed as signed divisions.
- // FIXME:Signedness. These casts can all go away once integer types are
- // signless.
- const Type *SignedTy = NegB->getType()->getSignedVersion();
- NegB = ConstantExpr::getBitCast(NegB, SignedTy);
- TwoA = ConstantExpr::getBitCast(TwoA, SignedTy);
- SqrtTerm = ConstantExpr::getBitCast(SqrtTerm, SignedTy);
-
Constant *Solution1 =
ConstantExpr::getSDiv(ConstantExpr::getAdd(NegB, SqrtTerm), TwoA);
Constant *Solution2 =
<< " sol#2: " << *R2 << "\n";
#endif
// Pick the smallest positive root value.
- assert(R1->getType()->isUnsigned()&&"Didn't canonicalize to unsigned?");
if (ConstantBool *CB =
dyn_cast<ConstantBool>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
R1->getValue(), R2->getValue()))) {
SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
if (R1) {
// Pick the smallest positive root value.
- assert(R1->getType()->isUnsigned() && "Didn't canonicalize to unsigned?");
if (ConstantBool *CB =
dyn_cast<ConstantBool>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
R1->getValue(), R2->getValue()))) {
Constant *CPV = cast<Constant>(V);
// Constants are converted by constant folding the cast that is required.
// We assume here that all casts are implemented for constant prop.
- Instruction::CastOps opcode = CastInst::getCastOpcode(CPV,
- CPV->getType()->isSigned(), Ty, Ty->isSigned());
+ // FIXME: This seems to work, but it is unclear why ZEXT is always the
+ // right choice here.
+ Instruction::CastOps opcode = CastInst::getCastOpcode(CPV, false, Ty,false);
Value *Result = ConstantExpr::getCast(opcode, CPV, Ty);
// Add the instruction to the expression map
//VMC.ExprMap[V] = Result;
case Instruction::BitCast: {
assert(VMC.NewCasts.count(ValueHandle(VMC, I)) == 0);
Instruction::CastOps opcode = CastInst::getCastOpcode(I->getOperand(0),
- I->getOperand(0)->getType()->isSigned(), Ty, Ty->isSigned());
+ false, Ty, false);
Res = CastInst::create(opcode, I->getOperand(0), Ty, Name);
VMC.NewCasts.insert(ValueHandle(VMC, Res));
break;
}
case Instruction::LShr:
case Instruction::AShr:
- if (Ty->isSigned() != V->getType()->isSigned()) return false;
- // FALL THROUGH
case Instruction::Shl:
if (I->getOperand(1) == V) return false; // Cannot change shift amount type
if (!Ty->isInteger()) return false;
switch (I->getOpcode()) {
case Instruction::BitCast: {
- Instruction::CastOps opcode = CastInst::getCastOpcode(NewVal,
- NewVal->getType()->isSigned(), I->getType(), I->getType()->isSigned());
+ Instruction::CastOps opcode = CastInst::getCastOpcode(NewVal, false,
+ I->getType(), false);
Res = CastInst::create(opcode, NewVal, I->getType(), Name);
break;
}
if (const CompositeType *CT = dyn_cast<CompositeType>(LoadedTy)) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
unsigned Offset = 0; // No offset, get first leaf.
LoadedTy = getStructOffsetType(CT, Offset, Indices, TD, false);
if (ElTy != NewTy) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
unsigned Offset = 0;
const Type *Ty = getStructOffsetType(ElTy, Offset, Indices, TD,false);
if (isa<StructType>(ValTy)) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
unsigned Offset = 0;
ValTy = getStructOffsetType(ValTy, Offset, Indices, TD, false);
bool ExtraArgHack = false;
if (Params.empty() && FTy->isVarArg()) {
ExtraArgHack = true;
- Params.push_back(Type::IntTy);
+ Params.push_back(Type::Int32Ty);
}
FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
}
if (ExtraArgHack)
- Args.push_back(Constant::getNullValue(Type::IntTy));
+ Args.push_back(Constant::getNullValue(Type::Int32Ty));
// Push any varargs arguments on the list
for (; AI != CS.arg_end(); ++AI)
// Notify the alias analysis implementation that we inserted a new argument.
if (ExtraArgHack)
- AA.copyValue(Constant::getNullValue(Type::IntTy), NF->arg_begin());
+ AA.copyValue(Constant::getNullValue(Type::Int32Ty), NF->arg_begin());
// Tell the alias analysis that the old function is about to disappear.
bool ExtraArgHack = false;
if (Params.empty() && FTy->isVarArg()) {
ExtraArgHack = true;
- Params.push_back(Type::IntTy);
+ Params.push_back(Type::Int32Ty);
}
FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
Args.push_back(*AI);
if (ExtraArgHack)
- Args.push_back(UndefValue::get(Type::IntTy));
+ Args.push_back(UndefValue::get(Type::Int32Ty));
// Push any varargs arguments on the list
for (; AI != CS.arg_end(); ++AI)
NewGlobals.reserve(STy->getNumElements());
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
Constant *In = getAggregateConstantElement(Init,
- ConstantInt::get(Type::UIntTy, i));
+ ConstantInt::get(Type::Int32Ty, i));
assert(In && "Couldn't get element of initializer?");
GlobalVariable *NGV = new GlobalVariable(STy->getElementType(i), false,
GlobalVariable::InternalLinkage,
NewGlobals.reserve(NumElements);
for (unsigned i = 0, e = NumElements; i != e; ++i) {
Constant *In = getAggregateConstantElement(Init,
- ConstantInt::get(Type::UIntTy, i));
+ ConstantInt::get(Type::Int32Ty, i));
assert(In && "Couldn't get element of initializer?");
GlobalVariable *NGV = new GlobalVariable(STy->getElementType(), false,
DOUT << "PERFORMING GLOBAL SRA ON: " << *GV;
- Constant *NullInt = Constant::getNullValue(Type::IntTy);
+ Constant *NullInt = Constant::getNullValue(Type::Int32Ty);
// Loop over all of the uses of the global, replacing the constantexpr geps,
// with smaller constantexpr geps or direct references.
Type *NewTy = ArrayType::get(MI->getAllocatedType(),
NElements->getZExtValue());
MallocInst *NewMI =
- new MallocInst(NewTy, Constant::getNullValue(Type::UIntTy),
+ new MallocInst(NewTy, Constant::getNullValue(Type::Int32Ty),
MI->getAlignment(), MI->getName(), MI);
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::IntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
Indices.push_back(Indices[0]);
Value *NewGEP = new GetElementPtrInst(NewMI, Indices,
NewMI->getName()+".el0", MI);
// Otherwise, this should be: 'getelementptr Ptr, Idx, uint FieldNo ...'
GetElementPtrInst *GEPI = cast<GetElementPtrInst>(User);
assert(GEPI->getNumOperands() >= 3 && isa<ConstantInt>(GEPI->getOperand(2))
- && GEPI->getOperand(2)->getType()->isUnsigned()
&& "Unexpected GEPI!");
// Load the pointer for this field.
if (!ATy) return 0;
const StructType *STy = dyn_cast<StructType>(ATy->getElementType());
if (!STy || STy->getNumElements() != 2 ||
- STy->getElementType(0) != Type::IntTy) return 0;
+ STy->getElementType(0) != Type::Int32Ty) return 0;
const PointerType *PFTy = dyn_cast<PointerType>(STy->getElementType(1));
if (!PFTy) return 0;
const FunctionType *FTy = dyn_cast<FunctionType>(PFTy->getElementType());
const std::vector<Function*> &Ctors) {
// If we made a change, reassemble the initializer list.
std::vector<Constant*> CSVals;
- CSVals.push_back(ConstantInt::get(Type::IntTy, 65535));
+ CSVals.push_back(ConstantInt::get(Type::Int32Ty, 65535));
CSVals.push_back(0);
// Create the new init list.
std::vector<const Type*>(), false);
const PointerType *PFTy = PointerType::get(FTy);
CSVals[1] = Constant::getNullValue(PFTy);
- CSVals[0] = ConstantInt::get(Type::IntTy, 2147483647);
+ CSVals[0] = ConstantInt::get(Type::Int32Ty, 2147483647);
}
CAList.push_back(ConstantStruct::get(CSVals));
}
"malloc_llvm_bounce", &M);
BasicBlock* bb = new BasicBlock("entry",FN);
Instruction* c = CastInst::createIntegerCast(
- FN->arg_begin(), Type::UIntTy, false, "c", bb);
- Instruction* a = new MallocInst(Type::SByteTy, c, "m", bb);
+ FN->arg_begin(), Type::Int32Ty, false, "c", bb);
+ Instruction* a = new MallocInst(Type::Int8Ty, c, "m", bb);
new ReturnInst(a, bb);
++NumBounce;
NumBounceSites += F->getNumUses();
// This function is always successful, unless it isn't.
bool LowerSetJmp::doInitialization(Module& M)
{
- const Type *SBPTy = PointerType::get(Type::SByteTy);
+ const Type *SBPTy = PointerType::get(Type::Int8Ty);
const Type *SBPPTy = PointerType::get(SBPTy);
// N.B. See llvm/runtime/GCCLibraries/libexception/SJLJ-Exception.h for
// void __llvm_sjljeh_add_setjmp_to_map(void**, void*, unsigned)
AddSJToMap = M.getOrInsertFunction("__llvm_sjljeh_add_setjmp_to_map",
Type::VoidTy, SBPPTy, SBPTy,
- Type::UIntTy, (Type *)0);
+ Type::Int32Ty, (Type *)0);
// void __llvm_sjljeh_throw_longjmp(int*, int)
ThrowLongJmp = M.getOrInsertFunction("__llvm_sjljeh_throw_longjmp",
- Type::VoidTy, SBPTy, Type::IntTy,
+ Type::VoidTy, SBPTy, Type::Int32Ty,
(Type *)0);
// unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **)
TryCatchLJ =
M.getOrInsertFunction("__llvm_sjljeh_try_catching_longjmp_exception",
- Type::UIntTy, SBPPTy, (Type *)0);
+ Type::Int32Ty, SBPPTy, (Type *)0);
// bool __llvm_sjljeh_is_longjmp_exception()
IsLJException = M.getOrInsertFunction("__llvm_sjljeh_is_longjmp_exception",
// int __llvm_sjljeh_get_longjmp_value()
GetLJValue = M.getOrInsertFunction("__llvm_sjljeh_get_longjmp_value",
- Type::IntTy, (Type *)0);
+ Type::Int32Ty, (Type *)0);
return true;
}
// throwing the exception for us.
void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
{
- const Type* SBPTy = PointerType::get(Type::SByteTy);
+ const Type* SBPTy = PointerType::get(Type::Int8Ty);
// Create the call to "__llvm_sjljeh_throw_longjmp". This takes the
// same parameters as "longjmp", except that the buffer is cast to a
assert(Inst && "Couldn't find even ONE instruction in entry block!");
// Fill in the alloca and call to initialize the SJ map.
- const Type *SBPTy = PointerType::get(Type::SByteTy);
+ const Type *SBPTy = PointerType::get(Type::Int8Ty);
AllocaInst* Map = new AllocaInst(SBPTy, 0, "SJMap", Inst);
new CallInst(InitSJMap, make_vector<Value*>(Map, 0), "", Inst);
return SJMap[Func] = Map;
Function* Func = ABlock->getParent();
// Add this setjmp to the setjmp map.
- const Type* SBPTy = PointerType::get(Type::SByteTy);
+ const Type* SBPTy = PointerType::get(Type::Int8Ty);
CastInst* BufPtr =
new BitCastInst(Inst->getOperand(1), SBPTy, "SBJmpBuf", Inst);
new CallInst(AddSJToMap,
make_vector<Value*>(GetSetJmpMap(Func), BufPtr,
- ConstantInt::get(Type::UIntTy,
+ ConstantInt::get(Type::Int32Ty,
SetJmpIDMap[Func]++), 0),
"", Inst);
// This PHI node will be in the new block created from the
// splitBasicBlock call.
- PHINode* PHI = new PHINode(Type::IntTy, "SetJmpReturn", Inst);
+ PHINode* PHI = new PHINode(Type::Int32Ty, "SetJmpReturn", Inst);
// Coming from a call to setjmp, the return is 0.
- PHI->addIncoming(ConstantInt::getNullValue(Type::IntTy), ABlock);
+ PHI->addIncoming(ConstantInt::getNullValue(Type::Int32Ty), ABlock);
// Add the case for this setjmp's number...
SwitchValuePair SVP = GetSJSwitch(Func, GetRethrowBB(Func));
- SVP.first->addCase(ConstantInt::get(Type::UIntTy, SetJmpIDMap[Func] - 1),
+ SVP.first->addCase(ConstantInt::get(Type::Int32Ty, SetJmpIDMap[Func] - 1),
SetJmpContBlock);
// Value coming from the handling of the exception.
//
void RaiseAllocations::doInitialization(Module &M) {
const FunctionType *MallocType = // Get the type for malloc
- FunctionType::get(PointerType::get(Type::SByteTy),
- std::vector<const Type*>(1, Type::ULongTy), false);
+ FunctionType::get(PointerType::get(Type::Int8Ty),
+ std::vector<const Type*>(1, Type::Int64Ty), false);
const FunctionType *FreeType = // Get the type for free
FunctionType::get(Type::VoidTy,
- std::vector<const Type*>(1, PointerType::get(Type::SByteTy)),
+ std::vector<const Type*>(1, PointerType::get(Type::Int8Ty)),
false);
// Get Malloc and free prototypes if they exist!
// Check to see if the prototype is wrong, giving us sbyte*(uint) * malloc
// This handles the common declaration of: 'void *malloc(unsigned);'
if (MallocFunc == 0) {
- MallocType = FunctionType::get(PointerType::get(Type::SByteTy),
- std::vector<const Type*>(1, Type::UIntTy), false);
+ MallocType = FunctionType::get(PointerType::get(Type::Int8Ty),
+ std::vector<const Type*>(1, Type::Int32Ty), false);
MallocFunc = M.getFunction("malloc", MallocType);
}
// Check to see if the prototype is missing, giving us sbyte*(...) * malloc
// This handles the common declaration of: 'void *malloc();'
if (MallocFunc == 0) {
- MallocType = FunctionType::get(PointerType::get(Type::SByteTy),
+ MallocType = FunctionType::get(PointerType::get(Type::Int8Ty),
std::vector<const Type*>(), true);
MallocFunc = M.getFunction("malloc", MallocType);
}
// One last try, check to see if we can find free as 'int (...)* free'. This
// handles the case where NOTHING was declared.
if (FreeFunc == 0) {
- FreeType = FunctionType::get(Type::IntTy, std::vector<const Type*>(),true);
+ FreeType = FunctionType::get(Type::Int32Ty, std::vector<const Type*>(),true);
FreeFunc = M.getFunction("free", FreeType);
}
// If no prototype was provided for malloc, we may need to cast the
// source size.
- if (Source->getType() != Type::UIntTy)
+ if (Source->getType() != Type::Int32Ty)
Source =
- CastInst::createIntegerCast(Source, Type::UIntTy, false/*ZExt*/,
+ CastInst::createIntegerCast(Source, Type::Int32Ty, false/*ZExt*/,
"MallocAmtCast", I);
std::string Name(I->getName()); I->setName("");
- MallocInst *MI = new MallocInst(Type::SByteTy, Source, Name, I);
+ MallocInst *MI = new MallocInst(Type::Int8Ty, Source, Name, I);
I->replaceAllUsesWith(MI);
// If the old instruction was an invoke, add an unconditional branch
//
Value *Source = *CS.arg_begin();
if (!isa<PointerType>(Source->getType()))
- Source = new IntToPtrInst(Source, PointerType::get(Type::SByteTy),
+ Source = new IntToPtrInst(Source, PointerType::get(Type::Int8Ty),
"FreePtrCast", I);
new FreeInst(Source, I);
/// @brief Return a Function* for the putchar libcall
Function* get_putchar() {
if (!putchar_func)
- putchar_func = M->getOrInsertFunction("putchar", Type::IntTy, Type::IntTy,
- NULL);
+ putchar_func =
+ M->getOrInsertFunction("putchar", Type::Int32Ty, Type::Int32Ty, NULL);
return putchar_func;
}
/// @brief Return a Function* for the puts libcall
Function* get_puts() {
if (!puts_func)
- puts_func = M->getOrInsertFunction("puts", Type::IntTy,
- PointerType::get(Type::SByteTy),
+ puts_func = M->getOrInsertFunction("puts", Type::Int32Ty,
+ PointerType::get(Type::Int8Ty),
NULL);
return puts_func;
}
/// @brief Return a Function* for the fputc libcall
Function* get_fputc(const Type* FILEptr_type) {
if (!fputc_func)
- fputc_func = M->getOrInsertFunction("fputc", Type::IntTy, Type::IntTy,
+ fputc_func = M->getOrInsertFunction("fputc", Type::Int32Ty, Type::Int32Ty,
FILEptr_type, NULL);
return fputc_func;
}
/// @brief Return a Function* for the fputs libcall
Function* get_fputs(const Type* FILEptr_type) {
if (!fputs_func)
- fputs_func = M->getOrInsertFunction("fputs", Type::IntTy,
- PointerType::get(Type::SByteTy),
+ fputs_func = M->getOrInsertFunction("fputs", Type::Int32Ty,
+ PointerType::get(Type::Int8Ty),
FILEptr_type, NULL);
return fputs_func;
}
Function* get_fwrite(const Type* FILEptr_type) {
if (!fwrite_func)
fwrite_func = M->getOrInsertFunction("fwrite", TD->getIntPtrType(),
- PointerType::get(Type::SByteTy),
+ PointerType::get(Type::Int8Ty),
TD->getIntPtrType(),
TD->getIntPtrType(),
FILEptr_type, NULL);
Function* get_strcpy() {
if (!strcpy_func)
strcpy_func = M->getOrInsertFunction("strcpy",
- PointerType::get(Type::SByteTy),
- PointerType::get(Type::SByteTy),
- PointerType::get(Type::SByteTy),
+ PointerType::get(Type::Int8Ty),
+ PointerType::get(Type::Int8Ty),
+ PointerType::get(Type::Int8Ty),
NULL);
return strcpy_func;
}
Function* get_strlen() {
if (!strlen_func)
strlen_func = M->getOrInsertFunction("strlen", TD->getIntPtrType(),
- PointerType::get(Type::SByteTy),
+ PointerType::get(Type::Int8Ty),
NULL);
return strlen_func;
}
Function* get_memchr() {
if (!memchr_func)
memchr_func = M->getOrInsertFunction("memchr",
- PointerType::get(Type::SByteTy),
- PointerType::get(Type::SByteTy),
- Type::IntTy, TD->getIntPtrType(),
+ PointerType::get(Type::Int8Ty),
+ PointerType::get(Type::Int8Ty),
+ Type::Int32Ty, TD->getIntPtrType(),
NULL);
return memchr_func;
}
/// @brief Return a Function* for the memcpy libcall
Function* get_memcpy() {
if (!memcpy_func) {
- const Type *SBP = PointerType::get(Type::SByteTy);
- const char *N = TD->getIntPtrType() == Type::UIntTy ?
+ const Type *SBP = PointerType::get(Type::Int8Ty);
+ const char *N = TD->getIntPtrType() == Type::Int32Ty ?
"llvm.memcpy.i32" : "llvm.memcpy.i64";
memcpy_func = M->getOrInsertFunction(N, Type::VoidTy, SBP, SBP,
- TD->getIntPtrType(), Type::UIntTy,
+ TD->getIntPtrType(), Type::Int32Ty,
NULL);
}
return memcpy_func;
/// @brief Make sure that the "strcat" function has the right prototype
virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){
- if (f->getReturnType() == PointerType::get(Type::SByteTy))
+ if (f->getReturnType() == PointerType::get(Type::Int8Ty))
if (f->arg_size() == 2)
{
Function::const_arg_iterator AI = f->arg_begin();
- if (AI++->getType() == PointerType::get(Type::SByteTy))
- if (AI->getType() == PointerType::get(Type::SByteTy))
+ if (AI++->getType() == PointerType::get(Type::Int8Ty))
+ if (AI->getType() == PointerType::get(Type::Int8Ty))
{
// Indicate this is a suitable call type.
return true;
vals.push_back(gep); // destination
vals.push_back(ci->getOperand(2)); // source
vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length
- vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment
+ vals.push_back(ConstantInt::get(Type::Int32Ty,1)); // alignment
new CallInst(SLC.get_memcpy(), vals, "", ci);
// Finally, substitute the first operand of the strcat call for the
/// @brief Make sure that the "strchr" function has the right prototype
virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){
- if (f->getReturnType() == PointerType::get(Type::SByteTy) &&
+ if (f->getReturnType() == PointerType::get(Type::Int8Ty) &&
f->arg_size() == 2)
return true;
return false;
// If it is, get the length and data, otherwise return false.
uint64_t len = 0;
ConstantArray* CA = 0;
- if (!getConstantStringLength(ci->getOperand(1),len,&CA))
+ if (!getConstantStringLength(ci->getOperand(1), len, &CA))
return false;
// Check that the second argument to strchr is a constant int. If it isn't
// a constant signed integer, we can try an alternate optimization
ConstantInt* CSI = dyn_cast<ConstantInt>(ci->getOperand(2));
- if (!CSI || CSI->getType()->isUnsigned() ) {
+ if (!CSI) {
// The second operand is not constant, or not signed. Just lower this to
// memchr since we know the length of the string since it is constant.
Function* f = SLC.get_memchr();
std::vector<Value*> args;
args.push_back(ci->getOperand(1));
args.push_back(ci->getOperand(2));
- args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
- ci->replaceAllUsesWith( new CallInst(f,args,ci->getName(),ci));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(), len));
+ ci->replaceAllUsesWith( new CallInst(f, args, ci->getName(), ci));
ci->eraseFromParent();
return true;
}
// (if c is a constant integer and s is a constant string)
if (char_found) {
std::vector<Value*> indices;
- indices.push_back(ConstantInt::get(Type::ULongTy,offset));
+ indices.push_back(ConstantInt::get(Type::Int64Ty,offset));
GetElementPtrInst* GEP = new GetElementPtrInst(ci->getOperand(1),indices,
ci->getOperand(1)->getName()+".strchr",ci);
ci->replaceAllUsesWith(GEP);
} else {
ci->replaceAllUsesWith(
- ConstantPointerNull::get(PointerType::get(Type::SByteTy)));
+ ConstantPointerNull::get(PointerType::get(Type::Int8Ty)));
}
ci->eraseFromParent();
return true;
/// @brief Make sure that the "strcmp" function has the right prototype
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
- return F->getReturnType() == Type::IntTy && F->arg_size() == 2;
+ return F->getReturnType() == Type::Int32Ty && F->arg_size() == 2;
}
/// @brief Perform the strcmp optimization
Value* s2 = ci->getOperand(2);
if (s1 == s2) {
// strcmp(x,x) -> 0
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,0));
ci->eraseFromParent();
return true;
}
LoadInst* load =
new LoadInst(CastToCStr(s2,*ci), ci->getName()+".load",ci);
CastInst* cast =
- CastInst::create(Instruction::SExt, load, Type::IntTy,
+ CastInst::create(Instruction::SExt, load, Type::Int32Ty,
ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
LoadInst* load =
new LoadInst(CastToCStr(s1,*ci),ci->getName()+".val",ci);
CastInst* cast =
- CastInst::create(Instruction::SExt, load, Type::IntTy,
+ CastInst::create(Instruction::SExt, load, Type::Int32Ty,
ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
std::string str1 = A1->getAsString();
std::string str2 = A2->getAsString();
int result = strcmp(str1.c_str(), str2.c_str());
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,result));
ci->eraseFromParent();
return true;
}
/// @brief Make sure that the "strncmp" function has the right prototype
virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){
- if (f->getReturnType() == Type::IntTy && f->arg_size() == 3)
+ if (f->getReturnType() == Type::Int32Ty && f->arg_size() == 3)
return true;
return false;
}
Value* s2 = ci->getOperand(2);
if (s1 == s2) {
// strncmp(x,x,l) -> 0
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,0));
ci->eraseFromParent();
return true;
}
len_arg = len_CI->getZExtValue();
if (len_arg == 0) {
// strncmp(x,y,0) -> 0
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,0));
ci->eraseFromParent();
return true;
}
// strncmp("",x) -> *x
LoadInst* load = new LoadInst(s1,ci->getName()+".load",ci);
CastInst* cast =
- CastInst::create(Instruction::SExt, load, Type::IntTy,
+ CastInst::create(Instruction::SExt, load, Type::Int32Ty,
ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
// strncmp(x,"") -> *x
LoadInst* load = new LoadInst(s2,ci->getName()+".val",ci);
CastInst* cast =
- CastInst::create(Instruction::SExt, load, Type::IntTy,
+ CastInst::create(Instruction::SExt, load, Type::Int32Ty,
ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
std::string str1 = A1->getAsString();
std::string str2 = A2->getAsString();
int result = strncmp(str1.c_str(), str2.c_str(), len_arg);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,result));
ci->eraseFromParent();
return true;
}
/// @brief Make sure that the "strcpy" function has the right prototype
virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){
- if (f->getReturnType() == PointerType::get(Type::SByteTy))
+ if (f->getReturnType() == PointerType::get(Type::Int8Ty))
if (f->arg_size() == 2) {
Function::const_arg_iterator AI = f->arg_begin();
- if (AI++->getType() == PointerType::get(Type::SByteTy))
- if (AI->getType() == PointerType::get(Type::SByteTy)) {
+ if (AI++->getType() == PointerType::get(Type::Int8Ty))
+ if (AI->getType() == PointerType::get(Type::Int8Ty)) {
// Indicate this is a suitable call type.
return true;
}
// If the constant string's length is zero we can optimize this by just
// doing a store of 0 at the first byte of the destination
if (len == 0) {
- new StoreInst(ConstantInt::get(Type::SByteTy,0),ci->getOperand(1),ci);
+ new StoreInst(ConstantInt::get(Type::Int8Ty,0),ci->getOperand(1),ci);
ci->replaceAllUsesWith(dest);
ci->eraseFromParent();
return true;
vals.push_back(dest); // destination
vals.push_back(src); // source
vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length
- vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment
+ vals.push_back(ConstantInt::get(Type::Int32Ty,1)); // alignment
new CallInst(SLC.get_memcpy(), vals, "", ci);
// Finally, substitute the first operand of the strcat call for the
if (f->getReturnType() == SLC.getTargetData()->getIntPtrType())
if (f->arg_size() == 1)
if (Function::const_arg_iterator AI = f->arg_begin())
- if (AI->getType() == PointerType::get(Type::SByteTy))
+ if (AI->getType() == PointerType::get(Type::Int8Ty))
return true;
return false;
}
{
// Make sure we're dealing with an sbyte* here.
Value* str = ci->getOperand(1);
- if (str->getType() != PointerType::get(Type::SByteTy))
+ if (str->getType() != PointerType::get(Type::Int8Ty))
return false;
// Does the call to strlen have exactly one use?
// strlen(x) == 0 -> *x == 0
LoadInst* load = new LoadInst(str,str->getName()+".first",ci);
ICmpInst* rbop = new ICmpInst(bop->getPredicate(), load,
- ConstantInt::get(Type::SByteTy,0),
+ ConstantInt::get(Type::Int8Ty,0),
bop->getName()+".strlen", ci);
bop->replaceAllUsesWith(rbop);
bop->eraseFromParent();
return true;
case 1: {
// memcmp(S1,S2,1) -> *(ubyte*)S1 - *(ubyte*)S2
- const Type *UCharPtr = PointerType::get(Type::UByteTy);
+ const Type *UCharPtr = PointerType::get(Type::Int8Ty);
CastInst *Op1Cast = CastInst::create(
Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
CastInst *Op2Cast = CastInst::create(
// TODO: IF both are aligned, use a short load/compare.
// memcmp(S1,S2,2) -> S1[0]-S2[0] | S1[1]-S2[1] iff only ==/!= 0 matters
- const Type *UCharPtr = PointerType::get(Type::UByteTy);
+ const Type *UCharPtr = PointerType::get(Type::Int8Ty);
CastInst *Op1Cast = CastInst::create(
Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
CastInst *Op2Cast = CastInst::create(
Value *S2V1 = new LoadInst(Op2Cast, RHS->getName()+".val1", CI);
Value *D1 = BinaryOperator::createSub(S1V1, S2V1,
CI->getName()+".d1", CI);
- Constant *One = ConstantInt::get(Type::IntTy, 1);
+ Constant *One = ConstantInt::get(Type::Int32Ty, 1);
Value *G1 = new GetElementPtrInst(Op1Cast, One, "next1v", CI);
Value *G2 = new GetElementPtrInst(Op2Cast, One, "next2v", CI);
Value *S1V2 = new LoadInst(G1, LHS->getName()+".val2", CI);
// memcpy(d,s,0,a) -> noop
ci->eraseFromParent();
return true;
- case 1: castType = Type::SByteTy; break;
- case 2: castType = Type::ShortTy; break;
- case 4: castType = Type::IntTy; break;
- case 8: castType = Type::LongTy; break;
+ case 1: castType = Type::Int8Ty; break;
+ case 2: castType = Type::Int16Ty; break;
+ case 4: castType = Type::Int32Ty; break;
+ case 8: castType = Type::Int64Ty; break;
default:
return false;
}
ConstantInt* FILL = dyn_cast<ConstantInt>(ci->getOperand(2));
if (!FILL)
return false;
- if (FILL->getType() != Type::UByteTy)
+ if (FILL->getType() != Type::Int8Ty)
return false;
// memset(s,c,n) -> store s, c (for n=1,2,4,8)
Type* castType = 0;
switch (len) {
case 1:
- castType = Type::UByteTy;
+ castType = Type::Int8Ty;
break;
case 2:
- castType = Type::UShortTy;
+ castType = Type::Int16Ty;
fill_value |= fill_char << 8;
break;
case 4:
- castType = Type::UIntTy;
+ castType = Type::Int32Ty;
fill_value |= fill_char << 8 | fill_char << 16 | fill_char << 24;
break;
case 8:
- castType = Type::ULongTy;
+ castType = Type::Int64Ty;
fill_value |= fill_char << 8 | fill_char << 16 | fill_char << 24;
fill_value |= fill_char << 32 | fill_char << 40 | fill_char << 48;
fill_value |= fill_char << 56;
std::vector<Value*> args;
args.push_back(CastToCStr(ci->getOperand(2), *ci));
new CallInst(puts_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,len));
break;
}
case 'c':
if (!putchar_func)
return false;
CastInst* cast = CastInst::createSExtOrBitCast(
- ci->getOperand(2), Type::IntTy, CI->getName()+".int", ci);
+ ci->getOperand(2), Type::Int32Ty, CI->getName()+".int", ci);
new CallInst(putchar_func, cast, "", ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy, 1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty, 1));
break;
}
default:
args.push_back(ConstantInt::get(SLC.getIntPtrType(),1));
args.push_back(ci->getOperand(1));
new CallInst(fwrite_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,len));
ci->eraseFromParent();
return true;
}
args.push_back(ConstantInt::get(SLC.getIntPtrType(),1));
args.push_back(ci->getOperand(1));
new CallInst(fwrite_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,len));
} else {
// fprintf(file,"%s",str) -> fputs(str,file)
const Type* FILEptr_type = ci->getOperand(1)->getType();
args.push_back(CastToCStr(ci->getOperand(3), *ci));
args.push_back(ci->getOperand(1));
new CallInst(fputs_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,len));
}
break;
}
if (!fputc_func)
return false;
CastInst* cast = CastInst::createSExtOrBitCast(
- ci->getOperand(3), Type::IntTy, CI->getName()+".int", ci);
+ ci->getOperand(3), Type::Int32Ty, CI->getName()+".int", ci);
new CallInst(fputc_func,cast,ci->getOperand(1),"",ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,1));
break;
}
default:
/// @brief Make sure that the "fprintf" function has the right prototype
virtual bool ValidateCalledFunction(const Function *f, SimplifyLibCalls &SLC){
// Just make sure this has at least 2 arguments
- return (f->getReturnType() == Type::IntTy && f->arg_size() >= 2);
+ return (f->getReturnType() == Type::Int32Ty && f->arg_size() >= 2);
}
/// @brief Perform the sprintf optimization.
if (ci->getNumOperands() == 3) {
if (len == 0) {
// If the length is 0, we just need to store a null byte
- new StoreInst(ConstantInt::get(Type::SByteTy,0),ci->getOperand(1),ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
+ new StoreInst(ConstantInt::get(Type::Int8Ty,0),ci->getOperand(1),ci);
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,0));
ci->eraseFromParent();
return true;
}
args.push_back(ci->getOperand(1));
args.push_back(ci->getOperand(2));
args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
- args.push_back(ConstantInt::get(Type::UIntTy,1));
+ args.push_back(ConstantInt::get(Type::Int32Ty,1));
new CallInst(memcpy_func,args,"",ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,len));
ci->eraseFromParent();
return true;
}
args.push_back(CastToCStr(ci->getOperand(1), *ci));
args.push_back(CastToCStr(ci->getOperand(3), *ci));
args.push_back(Len1);
- args.push_back(ConstantInt::get(Type::UIntTy,1));
+ args.push_back(ConstantInt::get(Type::Int32Ty,1));
new CallInst(memcpy_func, args, "", ci);
// The strlen result is the unincremented number of bytes in the string.
case 'c': {
// sprintf(dest,"%c",chr) -> store chr, dest
CastInst* cast = CastInst::createTruncOrBitCast(
- ci->getOperand(3), Type::SByteTy, "char", ci);
+ ci->getOperand(3), Type::Int8Ty, "char", ci);
new StoreInst(cast, ci->getOperand(1), ci);
GetElementPtrInst* gep = new GetElementPtrInst(ci->getOperand(1),
- ConstantInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end",
+ ConstantInt::get(Type::Int32Ty,1),ci->getOperand(1)->getName()+".end",
ci);
- new StoreInst(ConstantInt::get(Type::SByteTy,0),gep,ci);
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
+ new StoreInst(ConstantInt::get(Type::Int8Ty,0),gep,ci);
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,1));
ci->eraseFromParent();
return true;
}
return false;
LoadInst* loadi = new LoadInst(ci->getOperand(1),
ci->getOperand(1)->getName()+".byte",ci);
- CastInst* casti = new SExtInst(loadi, Type::IntTy,
+ CastInst* casti = new SExtInst(loadi, Type::Int32Ty,
loadi->getName()+".int", ci);
new CallInst(fputc_func,casti,ci->getOperand(2),"",ci);
break;
// isdigit(c) -> 0 or 1, if 'c' is constant
uint64_t val = CI->getZExtValue();
if (val >= '0' && val <='9')
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,1));
else
- ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty,0));
ci->eraseFromParent();
return true;
}
// isdigit(c) -> (unsigned)c - '0' <= 9
CastInst* cast = CastInst::createIntegerCast(ci->getOperand(1),
- Type::UIntTy, false/*ZExt*/, ci->getOperand(1)->getName()+".uint", ci);
+ Type::Int32Ty, false/*ZExt*/, ci->getOperand(1)->getName()+".uint", ci);
BinaryOperator* sub_inst = BinaryOperator::createSub(cast,
- ConstantInt::get(Type::UIntTy,0x30),
+ ConstantInt::get(Type::Int32Ty,0x30),
ci->getOperand(1)->getName()+".sub",ci);
ICmpInst* setcond_inst = new ICmpInst(ICmpInst::ICMP_ULE,sub_inst,
- ConstantInt::get(Type::UIntTy,9),
+ ConstantInt::get(Type::Int32Ty,9),
ci->getOperand(1)->getName()+".cmp",ci);
- CastInst* c2 = new ZExtInst(setcond_inst, Type::IntTy,
+ CastInst* c2 = new ZExtInst(setcond_inst, Type::Int32Ty,
ci->getOperand(1)->getName()+".isdigit", ci);
ci->replaceAllUsesWith(c2);
ci->eraseFromParent();
/// @brief Make sure that the "ffs" function has the right prototype
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
// Just make sure this has 2 arguments
- return F->arg_size() == 1 && F->getReturnType() == Type::IntTy;
+ return F->arg_size() == 1 && F->getReturnType() == Type::Int32Ty;
}
/// @brief Perform the ffs optimization.
val >>= 1;
}
}
- TheCall->replaceAllUsesWith(ConstantInt::get(Type::IntTy, result));
+ TheCall->replaceAllUsesWith(ConstantInt::get(Type::Int32Ty, result));
TheCall->eraseFromParent();
return true;
}
// ffsl(x) -> x == 0 ? 0 : llvm.cttz(x)+1
// ffsll(x) -> x == 0 ? 0 : llvm.cttz(x)+1
const Type *ArgType = TheCall->getOperand(1)->getType();
- ArgType = ArgType->getUnsignedVersion();
const char *CTTZName;
switch (ArgType->getTypeID()) {
default: assert(0 && "Unknown unsigned type!");
- case Type::UByteTyID : CTTZName = "llvm.cttz.i8" ; break;
- case Type::UShortTyID: CTTZName = "llvm.cttz.i16"; break;
- case Type::UIntTyID : CTTZName = "llvm.cttz.i32"; break;
- case Type::ULongTyID : CTTZName = "llvm.cttz.i64"; break;
+ case Type::Int8TyID : CTTZName = "llvm.cttz.i8" ; break;
+ case Type::Int16TyID: CTTZName = "llvm.cttz.i16"; break;
+ case Type::Int32TyID : CTTZName = "llvm.cttz.i32"; break;
+ case Type::Int64TyID : CTTZName = "llvm.cttz.i64"; break;
}
Function *F = SLC.getModule()->getOrInsertFunction(CTTZName, ArgType,
Value *V = CastInst::createIntegerCast(TheCall->getOperand(1), ArgType,
false/*ZExt*/, "tmp", TheCall);
Value *V2 = new CallInst(F, V, "tmp", TheCall);
- V2 = CastInst::createIntegerCast(V2, Type::IntTy, false/*ZExt*/,
+ V2 = CastInst::createIntegerCast(V2, Type::Int32Ty, false/*ZExt*/,
"tmp", TheCall);
- V2 = BinaryOperator::createAdd(V2, ConstantInt::get(Type::IntTy, 1),
+ V2 = BinaryOperator::createAdd(V2, ConstantInt::get(Type::Int32Ty, 1),
"tmp", TheCall);
Value *Cond = new ICmpInst(ICmpInst::ICMP_EQ, V,
Constant::getNullValue(V->getType()), "tmp",
TheCall);
- V2 = new SelectInst(Cond, ConstantInt::get(Type::IntTy, 0), V2,
+ V2 = new SelectInst(Cond, ConstantInt::get(Type::Int32Ty, 0), V2,
TheCall->getName(), TheCall);
TheCall->replaceAllUsesWith(V2);
TheCall->eraseFromParent();
Value *CastToCStr(Value *V, Instruction &IP) {
assert(isa<PointerType>(V->getType()) &&
"Can't cast non-pointer type to C string type");
- const Type *SBPTy = PointerType::get(Type::SByteTy);
+ const Type *SBPTy = PointerType::get(Type::Int8Ty);
if (V->getType() != SBPTy)
return new BitCastInst(V, SBPTy, V->getName(), &IP);
return V;
if (!I->isExternal())
++NumFunctions;
- const Type *ATy = ArrayType::get(Type::UIntTy, NumFunctions);
+ const Type *ATy = ArrayType::get(Type::Int32Ty, NumFunctions);
GlobalVariable *Counters =
new GlobalVariable(ATy, false, GlobalValue::InternalLinkage,
Constant::getNullValue(ATy), "FuncProfCounters", &M);
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
NumBlocks += I->size();
- const Type *ATy = ArrayType::get(Type::UIntTy, NumBlocks);
+ const Type *ATy = ArrayType::get(Type::Int32Ty, NumBlocks);
GlobalVariable *Counters =
new GlobalVariable(ATy, false, GlobalValue::InternalLinkage,
Constant::getNullValue(ATy), "BlockProfCounters", &M);
NumEdges += BB->getTerminator()->getNumSuccessors();
}
- const Type *ATy = ArrayType::get(Type::UIntTy, NumEdges);
+ const Type *ATy = ArrayType::get(Type::Int32Ty, NumEdges);
GlobalVariable *Counters =
new GlobalVariable(ATy, false, GlobalValue::InternalLinkage,
Constant::getNullValue(ATy), "EdgeProfCounters", &M);
//std::cerr<<MI;
vConsts.push_back(MI);
- sBCons.push_back(ConstantInt::get(Type::SByteTy, hasBackEdge(MI)));
+ sBCons.push_back(ConstantInt::get(Type::Int8Ty, hasBackEdge(MI)));
counter++;
}
cstruct, "llvmFunctionTable");
M.getGlobalList().push_back(gb);
- Constant *constArray = ConstantArray::get(ArrayType::get(Type::SByteTy,
+ Constant *constArray = ConstantArray::get(ArrayType::get(Type::Int8Ty,
sBCons.size()),
sBCons);
M.getGlobalList().push_back(funcArray);
- ConstantInt *cnst = ConstantInt::get(Type::IntTy, counter);
- GlobalVariable *fnCount = new GlobalVariable(Type::IntTy, true,
+ ConstantInt *cnst = ConstantInt::get(Type::Int32Ty, counter);
+ GlobalVariable *fnCount = new GlobalVariable(Type::Int32Ty, true,
GlobalValue::ExternalLinkage,
cnst, "llvmFunctionCount");
M.getGlobalList().push_back(fnCount);
void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
GlobalValue *Array) {
- const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy));
- const PointerType *UIntPtr = PointerType::get(Type::UIntTy);
+ const Type *ArgVTy = PointerType::get(PointerType::get(Type::Int8Ty));
+ const PointerType *UIntPtr = PointerType::get(Type::Int32Ty);
Module &M = *MainFn->getParent();
- Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy,
- ArgVTy, UIntPtr, Type::UIntTy,
+ Function *InitFn = M.getOrInsertFunction(FnName, Type::Int32Ty, Type::Int32Ty,
+ ArgVTy, UIntPtr, Type::Int32Ty,
(Type *)0);
// This could force argc and argv into programs that wouldn't otherwise have
// them, but instead we just pass null values in.
std::vector<Value*> Args(4);
- Args[0] = Constant::getNullValue(Type::IntTy);
+ Args[0] = Constant::getNullValue(Type::Int32Ty);
Args[1] = Constant::getNullValue(ArgVTy);
// Skip over any allocas in the entry block.
BasicBlock::iterator InsertPos = Entry->begin();
while (isa<AllocaInst>(InsertPos)) ++InsertPos;
- std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::IntTy));
+ std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::Int32Ty));
unsigned NumElements = 0;
if (Array) {
Args[2] = ConstantExpr::getGetElementPtr(Array, GEPIndices);
// pass null.
Args[2] = ConstantPointerNull::get(UIntPtr);
}
- Args[3] = ConstantInt::get(Type::UIntTy, NumElements);
+ Args[3] = ConstantInt::get(Type::Int32Ty, NumElements);
Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos);
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::IntTy) {
+ if (AI->getType() != Type::Int32Ty) {
Instruction::CastOps opcode;
if (!AI->use_empty()) {
opcode = CastInst::getCastOpcode(InitCall, true, AI->getType(), true);
AI->replaceAllUsesWith(
CastInst::create(opcode, InitCall, AI->getType(), "", InsertPos));
}
- opcode = CastInst::getCastOpcode(AI, true, Type::IntTy, true);
+ opcode = CastInst::getCastOpcode(AI, true, Type::Int32Ty, true);
InitCall->setOperand(1,
- CastInst::create(opcode, AI, Type::IntTy, "argc.cast", InitCall));
+ CastInst::create(opcode, AI, Type::Int32Ty, "argc.cast", InitCall));
} else {
AI->replaceAllUsesWith(InitCall);
InitCall->setOperand(1, AI);
// Create the getelementptr constant expression
std::vector<Constant*> Indices(2);
- Indices[0] = Constant::getNullValue(Type::IntTy);
- Indices[1] = ConstantInt::get(Type::IntTy, CounterNum);
+ Indices[0] = Constant::getNullValue(Type::Int32Ty);
+ Indices[1] = ConstantInt::get(Type::Int32Ty, CounterNum);
Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices);
// Load, increment and store the value back.
Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos);
Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal,
- ConstantInt::get(Type::UIntTy, 1),
+ ConstantInt::get(Type::Int32Ty, 1),
"NewFuncCounter", InsertPos);
new StoreInst(NewVal, ElementPtr, InsertPos);
}
CycleCounter::CycleCounter(Module& m, uint64_t resetmask) : rm(resetmask) {
- F = m.getOrInsertFunction("llvm.readcyclecounter", Type::ULongTy, NULL);
+ F = m.getOrInsertFunction("llvm.readcyclecounter", Type::Int64Ty, NULL);
}
CycleCounter::~CycleCounter() {}
CallInst* c = new CallInst(F, "rdcc", t);
BinaryOperator* b =
- BinaryOperator::createAnd(c, ConstantInt::get(Type::ULongTy, rm),
+ BinaryOperator::createAnd(c, ConstantInt::get(Type::Int64Ty, rm),
"mrdcc", t);
ICmpInst *s = new ICmpInst(ICmpInst::ICMP_EQ, b,
- ConstantInt::get(Type::ULongTy, 0),
+ ConstantInt::get(Type::Int64Ty, 0),
"mrdccc", t);
t->setCondition(s);
// Create the getelementptr constant expression
std::vector<Constant*> Indices(2);
- Indices[0] = Constant::getNullValue(Type::IntTy);
- Indices[1] = ConstantInt::get(Type::IntTy, CounterNum);
+ Indices[0] = Constant::getNullValue(Type::Int32Ty);
+ Indices[1] = ConstantInt::get(Type::Int32Ty, CounterNum);
Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices);
// Load, increment and store the value back.
Value *OldVal = new LoadInst(ElementPtr, "OldCounter", InsertPos);
profcode.insert(OldVal);
Value *NewVal = BinaryOperator::createAdd(OldVal,
- ConstantInt::get(Type::UIntTy, 1),
+ ConstantInt::get(Type::Int32Ty, 1),
"NewCounter", InsertPos);
profcode.insert(NewVal);
profcode.insert(new StoreInst(NewVal, ElementPtr, InsertPos));
bool ProfilerRS::doInitialization(Module &M) {
switch (RandomMethod) {
case GBV:
- c = new GlobalRandomCounter(M, Type::UIntTy, (1 << 14) - 1);
+ c = new GlobalRandomCounter(M, Type::Int32Ty, (1 << 14) - 1);
break;
case GBVO:
- c = new GlobalRandomCounterOpt(M, Type::UIntTy, (1 << 14) - 1);
+ c = new GlobalRandomCounterOpt(M, Type::Int32Ty, (1 << 14) - 1);
break;
case HOSTCC:
c = new CycleCounter(M, (1 << 14) - 1);
<< "\", \"" << FnName << "\", " << BBNumber << ")\n";
Module &M = *BB->getParent ()->getParent ();
Function *InstrFn = M.getOrInsertFunction (FnName, Type::VoidTy,
- Type::UIntTy, (Type *)0);
+ Type::Int32Ty, (Type *)0);
std::vector<Value*> Args (1);
- Args[0] = ConstantInt::get (Type::UIntTy, BBNumber);
+ Args[0] = ConstantInt::get (Type::Int32Ty, BBNumber);
// Insert the call after any alloca or PHI instructions...
BasicBlock::iterator InsertPos = BB->begin();
//
void ExternalFuncs::doInitialization(Module &M) {
M.addLibrary("trace");
- const Type *SBP = PointerType::get(Type::SByteTy);
+ const Type *SBP = PointerType::get(Type::Int8Ty);
const FunctionType *MTy =
- FunctionType::get(Type::IntTy, std::vector<const Type*>(1, SBP), true);
+ FunctionType::get(Type::Int32Ty, std::vector<const Type*>(1, SBP), true);
PrintfFunc = M.getOrInsertFunction("printf", MTy);
// uint (sbyte*)
- HashPtrFunc = M.getOrInsertFunction("HashPointerToSeqNum", Type::UIntTy, SBP,
+ HashPtrFunc = M.getOrInsertFunction("HashPointerToSeqNum", Type::Int32Ty, SBP,
(Type *)0);
// void (sbyte*)
// Turn the format string into an sbyte *
Constant *GEP=ConstantExpr::getGetElementPtr(fmtVal,
- std::vector<Constant*>(2,Constant::getNullValue(Type::LongTy)));
+ std::vector<Constant*>(2,Constant::getNullValue(Type::Int64Ty)));
// Insert a call to the hash function if this is a pointer value
if (V && isa<PointerType>(V->getType()) && !DisablePtrHashing) {
- const Type *SBP = PointerType::get(Type::SByteTy);
+ const Type *SBP = PointerType::get(Type::Int8Ty);
if (V->getType() != SBP) // Cast pointer to be sbyte*
V = new BitCastInst(V, SBP, "Hash_cast", InsertBefore);
Instruction *InsertBefore,
Function* ReleasePtrFunc) {
- const Type *SBP = PointerType::get(Type::SByteTy);
+ const Type *SBP = PointerType::get(Type::Int8Ty);
if (V->getType() != SBP) // Cast pointer to be sbyte*
V = new BitCastInst(V, SBP, "RPSN_cast", InsertBefore);
InsertRecordInst(Value *V, BasicBlock *BB,
Instruction *InsertBefore,
Function* RecordPtrFunc) {
- const Type *SBP = PointerType::get(Type::SByteTy);
+ const Type *SBP = PointerType::get(Type::Int8Ty);
if (V->getType() != SBP) // Cast pointer to be sbyte*
V = new BitCastInst(V, SBP, "RP_cast", InsertBefore);
// Build the index vector, full of all zeros
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
while (CurCTy && !isa<PointerType>(CurCTy)) {
if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) {
// Check for a zero element struct type... if we have one, bail.
}
// Insert a zero to index through this type...
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
// Did we find what we're looking for?
if (ElTy->canLosslesslyBitCastTo(DestPointedTy)) break;
Value *Replacement;
public:
ValueInfo(const Type *Ty)
- : Bounds(Ty->isIntegral() ? Ty : Type::IntTy), Replacement(0) {}
+ : Bounds(Ty->isIntegral() ? Ty : Type::Int32Ty), Replacement(0) {}
// getBounds() - Return the constant bounds of the value...
const ConstantRange &getBounds() const { return Bounds; }
Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
CEIdxs);
GetElementPtrInst *NGEPI =
- new GetElementPtrInst(NCE, Constant::getNullValue(Type::IntTy),
+ new GetElementPtrInst(NCE, Constant::getNullValue(Type::Int32Ty),
NewAdd, GEPI->getName(), GEPI);
GEPI->replaceAllUsesWith(NGEPI);
GEPI->eraseFromParent();
// Now that we know the largest of of the induction variables in this loop,
// insert a canonical induction variable of the largest size.
- LargestType = LargestType->getUnsignedVersion();
Value *IndVar = Rewriter.getOrInsertCanonicalInductionVariable(L,LargestType);
++NumInserted;
Changed = true;
PHINode *PN = IndVars[i].first;
InsertedSizes[PN->getType()->getPrimitiveSize()] = true;
Instruction *New = CastInst::create(Instruction::Trunc, IndVar,
- PN->getType()->getUnsignedVersion(), "indvar", InsertPt);
+ PN->getType(), "indvar", InsertPt);
Rewriter.addInsertedValue(New, SE->getSCEV(New));
}
}
// though a va_arg area...
static const Type *getPromotedType(const Type *Ty) {
switch (Ty->getTypeID()) {
- case Type::SByteTyID:
- case Type::ShortTyID: return Type::IntTy;
- case Type::UByteTyID:
- case Type::UShortTyID: return Type::UIntTy;
+ case Type::Int8TyID:
+ case Type::Int16TyID: return Type::Int32Ty;
case Type::FloatTyID: return Type::DoubleTy;
default: return Ty;
}
/// GetConstantInType - Return a ConstantInt with the specified type and value.
///
static ConstantIntegral *GetConstantInType(const Type *Ty, uint64_t Val) {
- if (Ty->isUnsigned())
- return ConstantInt::get(Ty, Val);
- else if (Ty->getTypeID() == Type::BoolTyID)
+ if (Ty->getTypeID() == Type::BoolTyID)
return ConstantBool::get(Val);
- int64_t SVal = Val;
- SVal <<= 64-Ty->getPrimitiveSizeInBits();
- SVal >>= 64-Ty->getPrimitiveSizeInBits();
- return ConstantInt::get(Ty, SVal);
+ return ConstantInt::get(Ty, Val);
}
bool shouldApply(Value *LHS) const { return LHS == RHS; }
Instruction *apply(BinaryOperator &Add) const {
return new ShiftInst(Instruction::Shl, Add.getOperand(0),
- ConstantInt::get(Type::UByteTy, 1));
+ ConstantInt::get(Type::Int8Ty, 1));
}
};
const Type *MiddleType = 0;
switch (Size) {
default: break;
- case 32: MiddleType = Type::IntTy; break;
- case 16: MiddleType = Type::ShortTy; break;
- case 8: MiddleType = Type::SByteTy; break;
+ case 32: MiddleType = Type::Int32Ty; break;
+ case 16: MiddleType = Type::Int16Ty; break;
+ case 8: MiddleType = Type::Int8Ty; break;
}
if (MiddleType) {
Instruction *NewTrunc = new TruncInst(XorLHS, MiddleType, "sext");
TD->getIntPtrType()->getPrimitiveSize())
&& isa<PointerType>(CI->getOperand(0)->getType())) {
Value *I2 = InsertCastBefore(Instruction::BitCast, CI->getOperand(0),
- PointerType::get(Type::SByteTy), I);
+ PointerType::get(Type::Int8Ty), I);
I2 = InsertNewInstBefore(new GetElementPtrInst(I2, Other, "ctg2"), I);
return new PtrToIntInst(I2, CI->getType());
}
// Check to see if we are shifting out everything but the sign bit.
if (CU->getZExtValue() ==
SI->getType()->getPrimitiveSizeInBits()-1) {
- // Ok, the transformation is safe. Insert LShr.
- return new ShiftInst(Instruction::LShr, SI->getOperand(0),
- CU, SI->getName());
+
+ // Ok, the transformation is safe. Insert LShr.
+ return new ShiftInst(Instruction::LShr, SI->getOperand(0), CU,
+ SI->getName());
}
}
}
if (isPowerOf2_64(Val)) { // Replace X*(2^C) with X << C
uint64_t C = Log2_64(Val);
return new ShiftInst(Instruction::Shl, Op0,
- ConstantInt::get(Type::UByteTy, C));
+ ConstantInt::get(Type::Int8Ty, C));
}
} else if (ConstantFP *Op1F = dyn_cast<ConstantFP>(Op1)) {
if (Op1F->isNullValue())
if (isa<ConstantInt>(SCIOp1) &&
isSignBitCheck(SCI->getPredicate(), cast<ConstantInt>(SCIOp1))) {
// Shift the X value right to turn it into "all signbits".
- Constant *Amt = ConstantInt::get(Type::UByteTy,
+ Constant *Amt = ConstantInt::get(Type::Int8Ty,
SCOpTy->getPrimitiveSizeInBits()-1);
Value *V =
InsertNewInstBefore(new ShiftInst(Instruction::AShr, SCIOp0, Amt,
if (isPowerOf2_64(Val)) {
uint64_t ShiftAmt = Log2_64(Val);
return new ShiftInst(Instruction::LShr, Op0,
- ConstantInt::get(Type::UByteTy, ShiftAmt));
+ ConstantInt::get(Type::Int8Ty, ShiftAmt));
}
}
// Compute the shift amounts
unsigned TSA = Log2_64(TVA), FSA = Log2_64(FVA);
// Construct the "on true" case of the select
- Constant *TC = ConstantInt::get(Type::UByteTy, TSA);
+ Constant *TC = ConstantInt::get(Type::Int8Ty, TSA);
Instruction *TSI =
new ShiftInst(Instruction::LShr, Op0, TC, SI->getName()+".t");
TSI = InsertNewInstBefore(TSI, I);
// Construct the "on false" case of the select
- Constant *FC = ConstantInt::get(Type::UByteTy, FSA);
+ Constant *FC = ConstantInt::get(Type::Int8Ty, FSA);
Instruction *FSI =
new ShiftInst(Instruction::LShr, Op0, FC, SI->getName()+".f");
FSI = InsertNewInstBefore(FSI, I);
unsigned Zeros = CountTrailingZeros_64(RHS->getZExtValue());
if (Zeros != V->getType()->getPrimitiveSizeInBits())
return ConstantExpr::getShl(Result,
- ConstantInt::get(Type::UByteTy, Zeros));
+ ConstantInt::get(Type::Int8Ty, Zeros));
}
} else if (CastInst *CI = dyn_cast<CastInst>(I)) {
// Only handle int->int casts.
Instruction *Add = BinaryOperator::createAdd(LHSVal, AddCST,
LHSVal->getName()+".off");
InsertNewInstBefore(Add, I);
- const Type *UnsType = Add->getType()->getUnsignedVersion();
- Value *OffsetVal = InsertCastBefore(Instruction::BitCast, Add,
- UnsType, I);
- AddCST = ConstantExpr::getSub(RHSCst, LHSCst);
- AddCST = ConstantExpr::getBitCast(AddCST, UnsType);
- return new ICmpInst(ICmpInst::ICMP_UGT, OffsetVal, AddCST);
+ return new ICmpInst(ICmpInst::ICMP_UGT, Add, AddCST);
}
break; // (X != 13 & X != 15) -> no change
}
/// If so, insert the new bswap intrinsic and return it.
Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) {
// We can only handle bswap of unsigned integers, and cannot bswap one byte.
- if (!I.getType()->isUnsigned() || I.getType() == Type::UByteTy)
+ if (I.getType() == Type::Int8Ty)
return 0;
/// ByteValues - For each byte of the result, we keep track of which value
// bswap to make it into.
Module *M = I.getParent()->getParent()->getParent();
const char *FnName = 0;
- if (I.getType() == Type::UShortTy)
+ if (I.getType() == Type::Int16Ty)
FnName = "llvm.bswap.i16";
- else if (I.getType() == Type::UIntTy)
+ else if (I.getType() == Type::Int32Ty)
FnName = "llvm.bswap.i32";
- else if (I.getType() == Type::ULongTy)
+ else if (I.getType() == Type::Int64Ty)
FnName = "llvm.bswap.i64";
else
assert(0 && "Unknown integer type!");
ConstantInt *In2) {
Result = cast<ConstantInt>(ConstantExpr::getAdd(In1, In2));
- if (In1->getType()->isUnsigned())
- return cast<ConstantInt>(Result)->getZExtValue() <
- cast<ConstantInt>(In1)->getZExtValue();
- if (isPositive(In1) != isPositive(In2))
- return false;
- if (isPositive(In1))
- return cast<ConstantInt>(Result)->getSExtValue() <
- cast<ConstantInt>(In1)->getSExtValue();
- return cast<ConstantInt>(Result)->getSExtValue() >
- cast<ConstantInt>(In1)->getSExtValue();
+ return cast<ConstantInt>(Result)->getZExtValue() <
+ cast<ConstantInt>(In1)->getZExtValue();
}
/// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the
(CI->getZExtValue() == (uint64_t)CI->getSExtValue()))) {
ConstantInt *NewCST;
ConstantInt *NewCI;
- if (Cast->getOperand(0)->getType()->isSigned()) {
- NewCST = ConstantInt::get(Cast->getOperand(0)->getType(),
- AndCST->getZExtValue());
- NewCI = ConstantInt::get(Cast->getOperand(0)->getType(),
- CI->getZExtValue());
- } else {
- NewCST = ConstantInt::get(Cast->getOperand(0)->getType(),
- AndCST->getZExtValue());
- NewCI = ConstantInt::get(Cast->getOperand(0)->getType(),
- CI->getZExtValue());
- }
+ NewCST = ConstantInt::get(Cast->getOperand(0)->getType(),
+ AndCST->getZExtValue());
+ NewCI = ConstantInt::get(Cast->getOperand(0)->getType(),
+ CI->getZExtValue());
Instruction *NewAnd =
BinaryOperator::createAnd(Cast->getOperand(0), NewCST,
LHSI->getName());
int ShAmtVal = Ty->getPrimitiveSizeInBits()-ShAmt->getZExtValue();
if (ShAmtVal < 0) ShAmtVal = 0; // Out of range shift.
- Constant *OShAmt = ConstantInt::get(Type::UByteTy, ShAmtVal);
+ Constant *OShAmt = ConstantInt::get(Type::Int8Ty, ShAmtVal);
Constant *ShVal =
ConstantExpr::getShl(ConstantInt::getAllOnesValue(AndTy),
OShAmt);
// Otherwise strength reduce the shift into an and.
unsigned ShAmtVal = (unsigned)ShAmt->getZExtValue();
uint64_t Val = (1ULL << (TypeBits-ShAmtVal))-1;
-
- Constant *Mask;
- if (CI->getType()->isUnsigned()) {
- Mask = ConstantInt::get(CI->getType(), Val);
- } else if (ShAmtVal != 0) {
- Mask = ConstantInt::get(CI->getType(), Val);
- } else {
- Mask = ConstantInt::getAllOnesValue(CI->getType());
- }
+ Constant *Mask = ConstantInt::get(CI->getType(), Val);
Instruction *AndI =
BinaryOperator::createAnd(LHSI->getOperand(0),
// If we are comparing against bits always shifted out, the
// comparison cannot succeed.
Constant *Comp;
- if (CI->getType()->isUnsigned())
+ if (LHSI->getOpcode() == Instruction::LShr)
Comp = ConstantExpr::getLShr(ConstantExpr::getShl(CI, ShAmt),
ShAmt);
else
// Otherwise strength reduce the shift into an and.
uint64_t Val = ~0ULL; // All ones.
Val <<= ShAmtVal; // Shift over to the right spot.
-
- Constant *Mask;
- if (CI->getType()->isUnsigned()) {
- Val &= ~0ULL >> (64-TypeBits);
- Mask = ConstantInt::get(CI->getType(), Val);
- } else {
- Mask = ConstantInt::get(CI->getType(), Val);
- }
+ Val &= ~0ULL >> (64-TypeBits);
+ Constant *Mask = ConstantInt::get(CI->getType(), Val);
Instruction *AndI =
BinaryOperator::createAnd(LHSI->getOperand(0),
// Replace (and X, (1 << size(X)-1) != 0) with x s< 0
if (isSignBit(BOC)) {
Value *X = BO->getOperand(0);
- // If 'X' is not signed, insert a cast now...
- if (!BOC->getType()->isSigned()) {
- const Type *DestTy = BOC->getType()->getSignedVersion();
- X = InsertCastBefore(Instruction::BitCast, X, DestTy, I);
- }
Constant *Zero = Constant::getNullValue(X->getType());
ICmpInst::Predicate pred = isICMP_NE ?
ICmpInst::ICMP_SLT : ICmpInst::ICMP_SGE;
// icmp eq (bswap(x)), c -> icmp eq (x,bswap(c))
WorkList.push_back(II); // Dead?
I.setOperand(0, II->getOperand(1));
- I.setOperand(1, ConstantInt::get(Type::UShortTy,
+ I.setOperand(1, ConstantInt::get(Type::Int16Ty,
ByteSwap_16(CI->getZExtValue())));
return &I;
case Intrinsic::bswap_i32:
// icmp eq (bswap(x)), c -> icmp eq (x,bswap(c))
WorkList.push_back(II); // Dead?
I.setOperand(0, II->getOperand(1));
- I.setOperand(1, ConstantInt::get(Type::UIntTy,
+ I.setOperand(1, ConstantInt::get(Type::Int32Ty,
ByteSwap_32(CI->getZExtValue())));
return &I;
case Intrinsic::bswap_i64:
// icmp eq (bswap(x)), c -> icmp eq (x,bswap(c))
WorkList.push_back(II); // Dead?
I.setOperand(0, II->getOperand(1));
- I.setOperand(1, ConstantInt::get(Type::ULongTy,
+ I.setOperand(1, ConstantInt::get(Type::Int64Ty,
ByteSwap_64(CI->getZExtValue())));
return &I;
}
}
Instruction *InstCombiner::visitShiftInst(ShiftInst &I) {
- assert(I.getOperand(1)->getType() == Type::UByteTy);
+ assert(I.getOperand(1)->getType() == Type::Int8Ty);
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
// shl X, 0 == X and shr X, 0 == X
// shl 0, X == 0 and shr 0, X == 0
- if (Op1 == Constant::getNullValue(Type::UByteTy) ||
+ if (Op1 == Constant::getNullValue(Type::Int8Ty) ||
Op0 == Constant::getNullValue(Op0->getType()))
return ReplaceInstUsesWith(I, Op0);
}
if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op1))
- if (CUI->getType()->isUnsigned())
- if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
- return Res;
+ if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
+ return Res;
return 0;
}
if (isUnsignedShift || isLeftShift)
return ReplaceInstUsesWith(I, Constant::getNullValue(Op0->getType()));
else {
- I.setOperand(1, ConstantInt::get(Type::UByteTy, TypeBits-1));
+ I.setOperand(1, ConstantInt::get(Type::Int8Ty, TypeBits-1));
return &I;
}
}
Value *Op = ShiftOp->getOperand(0);
ShiftInst *ShiftResult = new ShiftInst(I.getOpcode(), Op,
- ConstantInt::get(Type::UByteTy, Amt));
+ ConstantInt::get(Type::Int8Ty, Amt));
if (I.getType() == ShiftResult->getType())
return ShiftResult;
InsertNewInstBefore(ShiftResult, I);
return ReplaceInstUsesWith(I, Mask); // (A << c) >> c === A & c2
} else if (ShiftAmt1 < ShiftAmt2) {
return new ShiftInst(I.getOpcode(), Mask,
- ConstantInt::get(Type::UByteTy, ShiftAmt2-ShiftAmt1));
+ ConstantInt::get(Type::Int8Ty, ShiftAmt2-ShiftAmt1));
} else if (isShiftOfUnsignedShift || isShiftOfLeftShift) {
if (isShiftOfUnsignedShift && !isShiftOfLeftShift && isSignedShift) {
return new ShiftInst(Instruction::LShr, Mask,
- ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2));
+ ConstantInt::get(Type::Int8Ty, ShiftAmt1-ShiftAmt2));
} else {
return new ShiftInst(ShiftOp->getOpcode(), Mask,
- ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2));
+ ConstantInt::get(Type::Int8Ty, ShiftAmt1-ShiftAmt2));
}
} else {
// (X >>s C1) << C2 where C1 > C2 === (X >>s (C1-C2)) & mask
Instruction *Shift =
new ShiftInst(ShiftOp->getOpcode(), Mask,
- ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2));
+ ConstantInt::get(Type::Int8Ty, ShiftAmt1-ShiftAmt2));
InsertNewInstBefore(Shift, I);
C = ConstantIntegral::getAllOnesValue(Shift->getType());
if (ShiftAmt1 == ShiftAmt2) {
const Type *SExtType = 0;
switch (Op0->getType()->getPrimitiveSizeInBits() - ShiftAmt1) {
- case 8 : SExtType = Type::SByteTy; break;
- case 16: SExtType = Type::ShortTy; break;
- case 32: SExtType = Type::IntTy; break;
+ case 8 : SExtType = Type::Int8Ty; break;
+ case 16: SExtType = Type::Int16Ty; break;
+ case 32: SExtType = Type::Int32Ty; break;
}
if (SExtType) {
///
static Value *DecomposeSimpleLinearExpr(Value *Val, unsigned &Scale,
unsigned &Offset) {
- assert(Val->getType() == Type::UIntTy && "Unexpected allocation size type!");
+ assert(Val->getType() == Type::Int32Ty && "Unexpected allocation size type!");
if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
- if (CI->getType()->isUnsigned()) {
- Offset = CI->getZExtValue();
- Scale = 1;
- return ConstantInt::get(Type::UIntTy, 0);
- }
+ Offset = CI->getZExtValue();
+ Scale = 1;
+ return ConstantInt::get(Type::Int32Ty, 0);
} else if (Instruction *I = dyn_cast<Instruction>(Val)) {
if (I->getNumOperands() == 2) {
if (ConstantInt *CUI = dyn_cast<ConstantInt>(I->getOperand(1))) {
- if (CUI->getType()->isUnsigned()) {
- if (I->getOpcode() == Instruction::Shl) {
- // This is a value scaled by '1 << the shift amt'.
- Scale = 1U << CUI->getZExtValue();
- Offset = 0;
- return I->getOperand(0);
- } else if (I->getOpcode() == Instruction::Mul) {
- // This value is scaled by 'CUI'.
- Scale = CUI->getZExtValue();
- Offset = 0;
- return I->getOperand(0);
- } else if (I->getOpcode() == Instruction::Add) {
- // We have X+C. Check to see if we really have (X*C2)+C1,
- // where C1 is divisible by C2.
- unsigned SubScale;
- Value *SubVal =
- DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset);
- Offset += CUI->getZExtValue();
- if (SubScale > 1 && (Offset % SubScale == 0)) {
- Scale = SubScale;
- return SubVal;
- }
+ if (I->getOpcode() == Instruction::Shl) {
+ // This is a value scaled by '1 << the shift amt'.
+ Scale = 1U << CUI->getZExtValue();
+ Offset = 0;
+ return I->getOperand(0);
+ } else if (I->getOpcode() == Instruction::Mul) {
+ // This value is scaled by 'CUI'.
+ Scale = CUI->getZExtValue();
+ Offset = 0;
+ return I->getOperand(0);
+ } else if (I->getOpcode() == Instruction::Add) {
+ // We have X+C. Check to see if we really have (X*C2)+C1,
+ // where C1 is divisible by C2.
+ unsigned SubScale;
+ Value *SubVal =
+ DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset);
+ Offset += CUI->getZExtValue();
+ if (SubScale > 1 && (Offset % SubScale == 0)) {
+ Scale = SubScale;
+ return SubVal;
}
}
}
Amt = NumElements;
} else {
// If the allocation size is constant, form a constant mul expression
- Amt = ConstantInt::get(Type::UIntTy, Scale);
- if (isa<ConstantInt>(NumElements) && NumElements->getType()->isUnsigned())
+ Amt = ConstantInt::get(Type::Int32Ty, Scale);
+ if (isa<ConstantInt>(NumElements))
Amt = ConstantExpr::getMul(
cast<ConstantInt>(NumElements), cast<ConstantInt>(Amt));
// otherwise multiply the amount and the number of elements
}
if (unsigned Offset = (AllocElTySize*ArrayOffset)/CastElTySize) {
- Value *Off = ConstantInt::get(Type::UIntTy, Offset);
+ Value *Off = ConstantInt::get(Type::Int32Ty, Offset);
Instruction *Tmp = BinaryOperator::createAdd(Amt, Off, "tmp");
Amt = InsertNewInstBefore(Tmp, AI);
}
// We need to emit an AND to clear the high bits.
assert(SrcBitSize < DestBitSize && "Not a zext?");
Constant *C =
- ConstantInt::get(Type::ULongTy, (1ULL << SrcBitSize)-1);
+ ConstantInt::get(Type::Int64Ty, (1ULL << SrcBitSize)-1);
if (DestBitSize < 64)
C = ConstantExpr::getTrunc(C, DestTy);
else {
// Insert the shift to put the result in the low bit.
In = InsertNewInstBefore(
new ShiftInst(Instruction::LShr, In,
- ConstantInt::get(Type::UByteTy, ShiftAmt),
+ ConstantInt::get(Type::Int8Ty, ShiftAmt),
In->getName()+".lobit"), CI);
}
const Type *DstElTy = DstPTy->getElementType();
const Type *SrcElTy = SrcPTy->getElementType();
- Constant *ZeroUInt = Constant::getNullValue(Type::UIntTy);
+ Constant *ZeroUInt = Constant::getNullValue(Type::Int32Ty);
unsigned NumZeros = 0;
while (SrcElTy != DstElTy &&
isa<CompositeType>(SrcElTy) && !isa<PointerType>(SrcElTy) &&
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:
- return Constant::getNullValue(Type::UByteTy);
+ return Constant::getNullValue(Type::Int8Ty);
case Instruction::And:
return ConstantInt::getAllOnesValue(I->getType());
case Instruction::Mul:
// same width. Make an all-ones value by inserting a AShr.
Value *X = IC->getOperand(0);
unsigned Bits = X->getType()->getPrimitiveSizeInBits();
- Constant *ShAmt = ConstantInt::get(Type::UByteTy, Bits-1);
+ Constant *ShAmt = ConstantInt::get(Type::Int8Ty, Bits-1);
Instruction *SRA = new ShiftInst(Instruction::AShr, X,
ShAmt, "ones");
InsertNewInstBefore(SRA, SI);
// Malloc returns maximally aligned memory.
Align = TD->getTypeAlignment(AI->getType()->getElementType());
Align = std::max(Align, (unsigned)TD->getTypeAlignment(Type::DoubleTy));
- Align = std::max(Align, (unsigned)TD->getTypeAlignment(Type::LongTy));
+ Align = std::max(Align, (unsigned)TD->getTypeAlignment(Type::Int64Ty));
}
}
return Align;
Module *M = CI.getParent()->getParent()->getParent();
const char *Name;
if (CI.getCalledFunction()->getFunctionType()->getParamType(2) ==
- Type::UIntTy)
+ Type::Int32Ty)
Name = "llvm.memcpy.i32";
else
Name = "llvm.memcpy.i64";
unsigned Alignment2 = GetKnownAlignment(MI->getOperand(2), TD);
unsigned Align = std::min(Alignment1, Alignment2);
if (MI->getAlignment()->getZExtValue() < Align) {
- MI->setAlignment(ConstantInt::get(Type::UIntTy, Align));
+ MI->setAlignment(ConstantInt::get(Type::Int32Ty, Align));
Changed = true;
}
} else if (isa<MemSetInst>(MI)) {
unsigned Alignment = GetKnownAlignment(MI->getDest(), TD);
if (MI->getAlignment()->getZExtValue() < Alignment) {
- MI->setAlignment(ConstantInt::get(Type::UIntTy, Alignment));
+ MI->setAlignment(ConstantInt::get(Type::Int32Ty, Alignment));
Changed = true;
}
}
//Either we can cast directly, or we can upconvert the argument
bool isConvertible = ActTy->canLosslesslyBitCastTo(ParamTy) ||
(ParamTy->isIntegral() && ActTy->isIntegral() &&
- ParamTy->isSigned() == ActTy->isSigned() &&
ParamTy->getPrimitiveSize() >= ActTy->getPrimitiveSize()) ||
(c && ParamTy->getPrimitiveSize() >= ActTy->getPrimitiveSize() &&
c->getSExtValue() > 0);
Args.push_back(*AI);
} else {
Instruction::CastOps opcode = CastInst::getCastOpcode(*AI,
- (*AI)->getType()->isSigned(), ParamTy, ParamTy->isSigned());
+ false, ParamTy, false);
CastInst *NewCast = CastInst::create(opcode, *AI, ParamTy, "tmp");
Args.push_back(InsertNewInstBefore(NewCast, *Caller));
}
const Type *PTy = getPromotedType((*AI)->getType());
if (PTy != (*AI)->getType()) {
// Must promote to pass through va_arg area!
- Instruction::CastOps opcode = CastInst::getCastOpcode(
- *AI, (*AI)->getType()->isSigned(), PTy, PTy->isSigned());
+ Instruction::CastOps opcode = CastInst::getCastOpcode(*AI, false,
+ PTy, false);
Instruction *Cast = CastInst::create(opcode, *AI, PTy, "tmp");
InsertNewInstBefore(Cast, *Caller);
Args.push_back(Cast);
if (Caller->getType() != NV->getType() && !Caller->use_empty()) {
if (NV->getType() != Type::VoidTy) {
const Type *CallerTy = Caller->getType();
- Instruction::CastOps opcode = CastInst::getCastOpcode(
- NC, NC->getType()->isSigned(), CallerTy, CallerTy->isSigned());
+ Instruction::CastOps opcode = CastInst::getCastOpcode(NC, false,
+ CallerTy, false);
NV = NC = CastInst::create(opcode, NC, CallerTy, "tmp");
// If this is an invoke instruction, we should insert it after the first
GEP.setOperand(i, Op);
MadeChange = true;
}
- // If this is a constant idx, make sure to canonicalize it to be a signed
- // operand, otherwise CSE and other optimizations are pessimized.
- if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op))
- if (CUI->getType()->isUnsigned()) {
- GEP.setOperand(i,
- ConstantExpr::getBitCast(CUI, CUI->getType()->getSignedVersion()));
- MadeChange = true;
- }
}
if (MadeChange) return &GEP;
TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType()) ==
TD->getTypeSize(ResElTy)) {
Value *V = InsertNewInstBefore(
- new GetElementPtrInst(X, Constant::getNullValue(Type::IntTy),
+ new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty),
GEP.getOperand(1), GEP.getName()), GEP);
// V and GEP are both pointer types --> BitCast
return new BitCastInst(V, GEP.getType());
// getelementptr [100 x double]* %arr, int 0, int %tmp.2
if (isa<ArrayType>(SrcElTy) &&
- (ResElTy == Type::SByteTy || ResElTy == Type::UByteTy)) {
+ (ResElTy == Type::Int8Ty || ResElTy == Type::Int8Ty)) {
uint64_t ArrayEltSize =
TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType());
// Insert the new GEP instruction.
Instruction *NewGEP =
- new GetElementPtrInst(X, Constant::getNullValue(Type::IntTy),
+ new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty),
NewIdx, GEP.getName());
NewGEP = InsertNewInstBefore(NewGEP, GEP);
// The NewGEP must be pointer typed, so must the old one -> BitCast
// Now that I is pointing to the first non-allocation-inst in the block,
// insert our getelementptr instruction...
//
- Value *NullIdx = Constant::getNullValue(Type::IntTy);
+ Value *NullIdx = Constant::getNullValue(Type::Int32Ty);
Value *V = new GetElementPtrInst(New, NullIdx, NullIdx,
New->getName()+".sub", It);
if (const ArrayType *ASrcTy = dyn_cast<ArrayType>(SrcPTy))
if (Constant *CSrc = dyn_cast<Constant>(CastOp))
if (ASrcTy->getNumElements() != 0) {
- std::vector<Value*> Idxs(2, Constant::getNullValue(Type::IntTy));
+ std::vector<Value*> Idxs(2, Constant::getNullValue(Type::Int32Ty));
CastOp = ConstantExpr::getGetElementPtr(CSrc, Idxs);
SrcTy = cast<PointerType>(CastOp->getType());
SrcPTy = SrcTy->getElementType();
if (const ArrayType *ASrcTy = dyn_cast<ArrayType>(SrcPTy))
if (Constant *CSrc = dyn_cast<Constant>(CastOp))
if (ASrcTy->getNumElements() != 0) {
- std::vector<Value*> Idxs(2, Constant::getNullValue(Type::IntTy));
+ std::vector<Value*> Idxs(2, Constant::getNullValue(Type::Int32Ty));
CastOp = ConstantExpr::getGetElementPtr(CSrc, Idxs);
SrcTy = cast<PointerType>(CastOp->getType());
SrcPTy = SrcTy->getElementType();
unsigned NumElts = cast<PackedType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) {
- Mask.assign(NumElts, UndefValue::get(Type::UIntTy));
+ Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
return true;
} else if (V == LHS) {
for (unsigned i = 0; i != NumElts; ++i)
- Mask.push_back(ConstantInt::get(Type::UIntTy, i));
+ Mask.push_back(ConstantInt::get(Type::Int32Ty, i));
return true;
} else if (V == RHS) {
for (unsigned i = 0; i != NumElts; ++i)
- Mask.push_back(ConstantInt::get(Type::UIntTy, i+NumElts));
+ Mask.push_back(ConstantInt::get(Type::Int32Ty, i+NumElts));
return true;
} else if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
// If this is an insert of an extract from some other vector, include it.
// transitively ok.
if (CollectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
// If so, update the mask to reflect the inserted undef.
- Mask[InsertedIdx] = UndefValue::get(Type::UIntTy);
+ Mask[InsertedIdx] = UndefValue::get(Type::Int32Ty);
return true;
}
} else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
// If so, update the mask to reflect the inserted value.
if (EI->getOperand(0) == LHS) {
Mask[InsertedIdx & (NumElts-1)] =
- ConstantInt::get(Type::UIntTy, ExtractedIdx);
+ ConstantInt::get(Type::Int32Ty, ExtractedIdx);
} else {
assert(EI->getOperand(0) == RHS);
Mask[InsertedIdx & (NumElts-1)] =
- ConstantInt::get(Type::UIntTy, ExtractedIdx+NumElts);
+ ConstantInt::get(Type::Int32Ty, ExtractedIdx+NumElts);
}
return true;
unsigned NumElts = cast<PackedType>(V->getType())->getNumElements();
if (isa<UndefValue>(V)) {
- Mask.assign(NumElts, UndefValue::get(Type::UIntTy));
+ Mask.assign(NumElts, UndefValue::get(Type::Int32Ty));
return V;
} else if (isa<ConstantAggregateZero>(V)) {
- Mask.assign(NumElts, ConstantInt::get(Type::UIntTy, 0));
+ Mask.assign(NumElts, ConstantInt::get(Type::Int32Ty, 0));
return V;
} else if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
// If this is an insert of an extract from some other vector, include it.
RHS = EI->getOperand(0);
Value *V = CollectShuffleElements(VecOp, Mask, RHS);
Mask[InsertedIdx & (NumElts-1)] =
- ConstantInt::get(Type::UIntTy, NumElts+ExtractedIdx);
+ ConstantInt::get(Type::Int32Ty, NumElts+ExtractedIdx);
return V;
}
// Everything but the extracted element is replaced with the RHS.
for (unsigned i = 0; i != NumElts; ++i) {
if (i != InsertedIdx)
- Mask[i] = ConstantInt::get(Type::UIntTy, NumElts+i);
+ Mask[i] = ConstantInt::get(Type::Int32Ty, NumElts+i);
}
return V;
}
// Otherwise, can't do anything fancy. Return an identity vector.
for (unsigned i = 0; i != NumElts; ++i)
- Mask.push_back(ConstantInt::get(Type::UIntTy, i));
+ Mask.push_back(ConstantInt::get(Type::Int32Ty, i));
return V;
}
// Build a new shuffle mask.
std::vector<Constant*> Mask;
if (isa<UndefValue>(VecOp))
- Mask.assign(NumVectorElts, UndefValue::get(Type::UIntTy));
+ Mask.assign(NumVectorElts, UndefValue::get(Type::Int32Ty));
else {
assert(isa<ConstantAggregateZero>(VecOp) && "Unknown thing");
- Mask.assign(NumVectorElts, ConstantInt::get(Type::UIntTy,
+ Mask.assign(NumVectorElts, ConstantInt::get(Type::Int32Ty,
NumVectorElts));
}
- Mask[InsertedIdx] = ConstantInt::get(Type::UIntTy, ExtractedIdx);
+ Mask[InsertedIdx] = ConstantInt::get(Type::Int32Ty, ExtractedIdx);
return new ShuffleVectorInst(EI->getOperand(0), VecOp,
ConstantPacked::get(Mask));
}
std::vector<Constant*> Elts;
for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
if (Mask[i] >= 2*e)
- Elts.push_back(UndefValue::get(Type::UIntTy));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
else {
if ((Mask[i] >= e && isa<UndefValue>(RHS)) ||
(Mask[i] < e && isa<UndefValue>(LHS)))
Mask[i] = 2*e; // Turn into undef.
else
Mask[i] &= (e-1); // Force to LHS.
- Elts.push_back(ConstantInt::get(Type::UIntTy, Mask[i]));
+ Elts.push_back(ConstantInt::get(Type::Int32Ty, Mask[i]));
}
}
SVI.setOperand(0, SVI.getOperand(1));
std::vector<Constant*> Elts;
for (unsigned i = 0, e = NewMask.size(); i != e; ++i) {
if (NewMask[i] >= e*2) {
- Elts.push_back(UndefValue::get(Type::UIntTy));
+ Elts.push_back(UndefValue::get(Type::Int32Ty));
} else {
- Elts.push_back(ConstantInt::get(Type::UIntTy, NewMask[i]));
+ Elts.push_back(ConstantInt::get(Type::Int32Ty, NewMask[i]));
}
}
return new ShuffleVectorInst(LHSSVI->getOperand(0),
Value *IncV;
IVExpr()
- : Stride(SCEVUnknown::getIntegerSCEV(0, Type::UIntTy)),
- Base (SCEVUnknown::getIntegerSCEV(0, Type::UIntTy)) {}
+ : Stride(SCEVUnknown::getIntegerSCEV(0, Type::Int32Ty)),
+ Base (SCEVUnknown::getIntegerSCEV(0, Type::Int32Ty)) {}
IVExpr(const SCEVHandle &stride, const SCEVHandle &base, PHINode *phi,
Value *incv)
: Stride(stride), Base(base), PHI(phi), IncV(incv) {}
<< "] Variable stride: " << *AddRec << "\n";
Stride = AddRec->getOperand(1);
- // Check that all constant strides are the unsigned type, we don't want to
- // have two IV's one of signed stride 4 and one of unsigned stride 4 to not be
- // merged.
- assert((!isa<SCEVConstant>(Stride) || Stride->getType()->isUnsigned()) &&
- "Constants should be canonicalized to unsigned!");
-
return true;
}
if (unsigned(abs(SInt)) < Scale || (SInt % Scale) != 0)
continue;
std::map<SCEVHandle, IVsOfOneStride>::iterator SI =
- IVsByStride.find(SCEVUnknown::getIntegerSCEV(SInt/Scale, Type::UIntTy));
+ IVsByStride.find(SCEVUnknown::getIntegerSCEV(SInt/Scale, Type::Int32Ty));
if (SI == IVsByStride.end())
continue;
for (std::vector<IVExpr>::iterator II = SI->second.IVs.begin(),
MainRootRecordType ? (Type*)MainRootRecordType : (Type*)OpaqueType::get();
ST.clear();
ST.push_back(PointerType::get(RootListH)); // Prev pointer
- ST.push_back(Type::UIntTy); // NumElements in array
+ ST.push_back(Type::Int32Ty); // NumElements in array
ST.push_back(PairArrTy); // The pairs
StructType *RootList = StructType::get(ST);
if (MainRootRecordType)
GCWriteInt = M.getNamedFunction("llvm.gcwrite");
if (!GCRootInt && !GCReadInt && !GCWriteInt) return false;
- PointerType *VoidPtr = PointerType::get(Type::SByteTy);
+ PointerType *VoidPtr = PointerType::get(Type::Int8Ty);
PointerType *VoidPtrPtr = PointerType::get(VoidPtr);
// If the program is using read/write barriers, find the implementations of
// Quick exit for programs that are not using GC mechanisms.
if (!GCRootInt && !GCReadInt && !GCWriteInt) return false;
- PointerType *VoidPtr = PointerType::get(Type::SByteTy);
+ PointerType *VoidPtr = PointerType::get(Type::Int8Ty);
PointerType *VoidPtrPtr = PointerType::get(VoidPtr);
// If there are read/write barriers in the program, perform a quick pass over
BasicBlock::iterator IP = AI;
while (isa<AllocaInst>(IP)) ++IP;
- Constant *Zero = ConstantInt::get(Type::UIntTy, 0);
- Constant *One = ConstantInt::get(Type::UIntTy, 1);
+ Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
+ Constant *One = ConstantInt::get(Type::Int32Ty, 1);
// Get a pointer to the prev pointer.
std::vector<Value*> Par;
new StoreInst(PrevPtr, PrevPtrPtr, IP);
// Set the number of elements in this record.
- Par[1] = ConstantInt::get(Type::UIntTy, 1);
+ Par[1] = ConstantInt::get(Type::Int32Ty, 1);
Value *NumEltsPtr = new GetElementPtrInst(AI, Par, "numeltsptr", IP);
- new StoreInst(ConstantInt::get(Type::UIntTy, GCRoots.size()), NumEltsPtr,IP);
+ new StoreInst(ConstantInt::get(Type::Int32Ty, GCRoots.size()), NumEltsPtr,IP);
- Par[1] = ConstantInt::get(Type::UIntTy, 2);
+ Par[1] = ConstantInt::get(Type::Int32Ty, 2);
Par.resize(4);
const PointerType *PtrLocTy =
// Initialize all of the gcroot records now, and eliminate them as we go.
for (unsigned i = 0, e = GCRoots.size(); i != e; ++i) {
// Initialize the meta-data pointer.
- Par[2] = ConstantInt::get(Type::UIntTy, i);
+ Par[2] = ConstantInt::get(Type::Int32Ty, i);
Par[3] = One;
Value *MetaDataPtr = new GetElementPtrInst(AI, Par, "MetaDataPtr", IP);
assert(isa<Constant>(GCRoots[i]->getOperand(2)) && "Must be a constant");
if (const PackedType* PKT = dyn_cast<PackedType>(LI.getType())) {
// Initialization, Idx is needed for getelementptr needed later
std::vector<Value*> Idx(2);
- Idx[0] = ConstantInt::get(Type::UIntTy,0);
+ Idx[0] = ConstantInt::get(Type::Int32Ty,0);
ArrayType* AT = ArrayType::get(PKT->getContainedType(0),
PKT->getNumElements());
for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
// Calculate the second index we will need
- Idx[1] = ConstantInt::get(Type::UIntTy,i);
+ Idx[1] = ConstantInt::get(Type::Int32Ty,i);
// Get the pointer
Value* val = new GetElementPtrInst(array,
dyn_cast<PackedType>(SI.getOperand(0)->getType())) {
// We will need this for getelementptr
std::vector<Value*> Idx(2);
- Idx[0] = ConstantInt::get(Type::UIntTy,0);
+ Idx[0] = ConstantInt::get(Type::Int32Ty,0);
ArrayType* AT = ArrayType::get(PKT->getContainedType(0),
PKT->getNumElements());
for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) {
// Generate the indices for getelementptr
- Idx[1] = ConstantInt::get(Type::UIntTy,i);
+ Idx[1] = ConstantInt::get(Type::Int32Ty,i);
Value* val = new GetElementPtrInst(array,
Idx,
"store.ge." +
} else {
AllocaInst *alloca =
new AllocaInst(PTy->getElementType(),
- ConstantInt::get(Type::UIntTy, PTy->getNumElements()),
+ ConstantInt::get(Type::Int32Ty, PTy->getNumElements()),
EI.getName() + ".alloca",
EI.getParent()->getParent()->getEntryBlock().begin());
for (unsigned i = 0; i < PTy->getNumElements(); ++i) {
GetElementPtrInst *GEP =
- new GetElementPtrInst(alloca, ConstantInt::get(Type::UIntTy, i),
+ new GetElementPtrInst(alloca, ConstantInt::get(Type::Int32Ty, i),
"store.ge", &EI);
new StoreInst(op0Vals[i], GEP, &EI);
}
for (unsigned i = 0; i != Vals.size(); ++i) {
ICmpInst *icmp =
new ICmpInst(ICmpInst::ICMP_EQ, Idx,
- ConstantInt::get(Type::UIntTy, i),
+ ConstantInt::get(Type::Int32Ty, i),
"icmp", &IE);
SelectInst *select =
new SelectInst(icmp, Elt, Vals[i], "select", &IE);
//
std::string OldName = GEPI->getName(); // Steal the old name.
std::vector<Value*> NewArgs;
- NewArgs.push_back(Constant::getNullValue(Type::IntTy));
+ NewArgs.push_back(Constant::getNullValue(Type::Int32Ty));
NewArgs.insert(NewArgs.end(), GEPI->op_begin()+3, GEPI->op_end());
GEPI->setName("");
RepValue = new GetElementPtrInst(AllocaToUse, NewArgs, OldName, GEPI);
if (!isa<ConstantInt>(I.getOperand())) {
if (NumElements == 1) {
- GEPI->setOperand(2, Constant::getNullValue(Type::IntTy));
+ GEPI->setOperand(2, Constant::getNullValue(Type::Int32Ty));
} else {
assert(NumElements == 2 && "Unhandled case!");
// All users of the GEP must be loads. At each use of the GEP, insert
"isone", GEPI);
// Insert the new GEP instructions, which are properly indexed.
std::vector<Value*> Indices(GEPI->op_begin()+1, GEPI->op_end());
- Indices[1] = Constant::getNullValue(Type::IntTy);
+ Indices[1] = Constant::getNullValue(Type::Int32Ty);
Value *ZeroIdx = new GetElementPtrInst(GEPI->getOperand(0), Indices,
GEPI->getName()+".0", GEPI);
- Indices[1] = ConstantInt::get(Type::IntTy, 1);
+ Indices[1] = ConstantInt::get(Type::Int32Ty, 1);
Value *OneIdx = new GetElementPtrInst(GEPI->getOperand(0), Indices,
GEPI->getName()+".1", GEPI);
// Replace all loads of the variable index GEP with loads from both
// Pointer/FP/Integer unions merge together as integers.
switch (Accum->getTypeID()) {
case Type::PointerTyID: Accum = TD.getIntPtrType(); break;
- case Type::FloatTyID: Accum = Type::UIntTy; break;
- case Type::DoubleTyID: Accum = Type::ULongTy; break;
+ case Type::FloatTyID: Accum = Type::Int32Ty; break;
+ case Type::DoubleTyID: Accum = Type::Int64Ty; break;
default:
assert(Accum->isIntegral() && "Unknown FP type!");
break;
switch (In->getTypeID()) {
case Type::PointerTyID: In = TD.getIntPtrType(); break;
- case Type::FloatTyID: In = Type::UIntTy; break;
- case Type::DoubleTyID: In = Type::ULongTy; break;
+ case Type::FloatTyID: In = Type::Int32Ty; break;
+ case Type::DoubleTyID: In = Type::Int64Ty; break;
default:
assert(In->isIntegral() && "Unknown FP type!");
break;
/// null.
const Type *getUIntAtLeastAsBitAs(unsigned NumBits) {
if (NumBits > 64) return 0;
- if (NumBits > 32) return Type::ULongTy;
- if (NumBits > 16) return Type::UIntTy;
- if (NumBits > 8) return Type::UShortTy;
- return Type::UByteTy;
+ if (NumBits > 32) return Type::Int64Ty;
+ if (NumBits > 16) return Type::Int32Ty;
+ if (NumBits > 8) return Type::Int16Ty;
+ return Type::Int8Ty;
}
/// CanConvertToScalar - V is a pointer. If we can convert the pointee to a
"Not in the entry block!");
EntryBlock->getInstList().remove(AI); // Take the alloca out of the program.
- if (ActualTy->isInteger())
- ActualTy = ActualTy->getUnsignedVersion();
-
// Create and insert the alloca.
AllocaInst *NewAI = new AllocaInst(ActualTy, 0, AI->getName(),
EntryBlock->begin());
} else {
// Must be an element access.
unsigned Elt = Offset/(TD.getTypeSize(PTy->getElementType())*8);
- NV = new ExtractElementInst(NV, ConstantInt::get(Type::UIntTy, Elt),
+ NV = new ExtractElementInst(NV, ConstantInt::get(Type::Int32Ty, Elt),
"tmp", LI);
}
} else if (isa<PointerType>(NV->getType())) {
assert(NV->getType()->isInteger() && "Unknown promotion!");
if (Offset && Offset < TD.getTypeSize(NV->getType())*8) {
NV = new ShiftInst(Instruction::LShr, NV,
- ConstantInt::get(Type::UByteTy, Offset),
+ ConstantInt::get(Type::Int8Ty, Offset),
LI->getName(), LI);
}
switch (LI->getType()->getTypeID()) {
default: assert(0 && "Unknown FP type!");
case Type::FloatTyID:
- NV = new TruncInst(NV, Type::UIntTy, LI->getName(), LI);
+ NV = new TruncInst(NV, Type::Int32Ty, LI->getName(), LI);
break;
case Type::DoubleTyID:
- NV = new TruncInst(NV, Type::ULongTy, LI->getName(), LI);
+ NV = new TruncInst(NV, Type::Int64Ty, LI->getName(), LI);
break;
}
}
// Must be an element insertion.
unsigned Elt = Offset/(TD.getTypeSize(PTy->getElementType())*8);
SV = new InsertElementInst(Old, SV,
- ConstantInt::get(Type::UIntTy, Elt),
+ ConstantInt::get(Type::Int32Ty, Elt),
"tmp", SI);
}
} else {
assert(!SV->getType()->isFloatingPoint() && "Unknown FP type!");
break;
case Type::FloatTyID:
- SV = new BitCastInst(SV, Type::UIntTy, SV->getName(), SI);
+ SV = new BitCastInst(SV, Type::Int32Ty, SV->getName(), SI);
break;
case Type::DoubleTyID:
- SV = new BitCastInst(SV, Type::ULongTy, SV->getName(), SI);
+ SV = new BitCastInst(SV, Type::Int64Ty, SV->getName(), SI);
break;
case Type::PointerTyID:
if (isa<PointerType>(AllocaType))
SV->getName(), SI);
if (Offset && Offset < AllocaType->getPrimitiveSizeInBits())
SV = new ShiftInst(Instruction::Shl, SV,
- ConstantInt::get(Type::UByteTy, Offset),
+ ConstantInt::get(Type::Int8Ty, Offset),
SV->getName()+".adj", SI);
// Mask out the bits we are about to insert from the old value.
unsigned TotalBits = TD.getTypeSize(SV->getType())*8;
(i == SL->MemberOffsets.size()-1 || Offset < SL->MemberOffsets[i+1]));
// Make sure to save the current index...
- Indices.push_back(ConstantInt::get(Type::UIntTy, i));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty, i));
Offset = SL->MemberOffsets[i];
return STy->getContainedType(i);
}
NextType = ATy->getElementType();
unsigned ChildSize = (unsigned)TD.getTypeSize(NextType);
- if (ConstantInt::isValueValidForType(Type::IntTy,
+ if (ConstantInt::isValueValidForType(Type::Int32Ty,
uint64_t(Offset/ChildSize)))
- Indices.push_back(ConstantInt::get(Type::IntTy, Offset/ChildSize));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty, Offset/ChildSize));
else
- Indices.push_back(ConstantInt::get(Type::LongTy, Offset/ChildSize));
+ Indices.push_back(ConstantInt::get(Type::Int64Ty, Offset/ChildSize));
ThisOffset = (Offset/ChildSize)*ChildSize;
} else {
Offset = 0; // Return the offset that we were able to achieve
case 0:
case 1: RetTy = Type::VoidTy; break;
case 2: RetTy = Type::BoolTy; break;
- default: RetTy = Type::UShortTy; break;
+ default: RetTy = Type::Int16Ty; break;
}
std::vector<const Type*> paramTy;
Value *RewriteVal;
if (AggregateArgs) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantInt::get(Type::UIntTy, i));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty, i));
std::string GEPname = "gep_" + inputs[i]->getName();
TerminatorInst *TI = newFunction->begin()->getTerminator();
GetElementPtrInst *GEP = new GetElementPtrInst(AI, Indices, GEPname, TI);
for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantInt::get(Type::UIntTy, i));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty, i));
GetElementPtrInst *GEP =
new GetElementPtrInst(Struct, Indices,
"gep_" + StructValues[i]->getName());
Value *Output = 0;
if (AggregateArgs) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantInt::get(Type::UIntTy, FirstOut + i));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty, FirstOut + i));
GetElementPtrInst *GEP
= new GetElementPtrInst(Struct, Indices,
"gep_reload_" + outputs[i]->getName());
// Now we can emit a switch statement using the call as a value.
SwitchInst *TheSwitch =
- new SwitchInst(ConstantInt::getNullValue(Type::UShortTy),
+ new SwitchInst(ConstantInt::getNullValue(Type::Int16Ty),
codeReplacer, 0, codeReplacer);
// Since there may be multiple exits from the original region, make the new
brVal = ConstantBool::get(!SuccNum);
break;
default:
- brVal = ConstantInt::get(Type::UShortTy, SuccNum);
+ brVal = ConstantInt::get(Type::Int16Ty, SuccNum);
break;
}
ReturnInst *NTRet = new ReturnInst(brVal, NewTarget);
// Update the switch instruction.
- TheSwitch->addCase(ConstantInt::get(Type::UShortTy, SuccNum),
+ TheSwitch->addCase(ConstantInt::get(Type::Int16Ty, SuccNum),
OldTarget);
// Restore values just before we exit
if (DominatesDef) {
if (AggregateArgs) {
std::vector<Value*> Indices;
- Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantInt::get(Type::UIntTy,FirstOut+out));
+ Indices.push_back(Constant::getNullValue(Type::Int32Ty));
+ Indices.push_back(ConstantInt::get(Type::Int32Ty,FirstOut+out));
GetElementPtrInst *GEP =
new GetElementPtrInst(OAI, Indices,
"gep_" + outputs[out]->getName(),
// code with llvm.stacksave/llvm.stackrestore intrinsics.
if (InlinedFunctionInfo.ContainsDynamicAllocas) {
Module *M = Caller->getParent();
- const Type *SBytePtr = PointerType::get(Type::SByteTy);
+ const Type *SBytePtr = PointerType::get(Type::Int8Ty);
// Get the two intrinsics we care about.
Function *StackSave, *StackRestore;
StackSave = M->getOrInsertFunction("llvm.stacksave", SBytePtr, NULL);
// This function is always successful.
//
bool LowerAllocations::doInitialization(Module &M) {
- const Type *SBPTy = PointerType::get(Type::SByteTy);
+ const Type *SBPTy = PointerType::get(Type::Int8Ty);
MallocFunc = M.getNamedFunction("malloc");
FreeFunc = M.getNamedFunction("free");
// malloc(type) becomes sbyte *malloc(size)
Value *MallocArg;
if (LowerMallocArgToInteger)
- MallocArg = ConstantInt::get(Type::ULongTy, TD.getTypeSize(AllocTy));
+ MallocArg = ConstantInt::get(Type::Int64Ty, TD.getTypeSize(AllocTy));
else
MallocArg = ConstantExpr::getSizeOf(AllocTy);
MallocArg = ConstantExpr::getTruncOrBitCast(cast<Constant>(MallocArg),
MallocArg = CastInst::createIntegerCast(MallocArg, IntPtrTy,
false /*ZExt*/, "", I);
} else if (MallocFTy->getNumParams() > 0 &&
- MallocFTy->getParamType(0) != Type::UIntTy)
+ MallocFTy->getParamType(0) != Type::Int32Ty)
MallocArg = CastInst::createIntegerCast(
MallocArg, MallocFTy->getParamType(0), false/*ZExt*/, "",I);
MallocArgs.push_back(MallocArg);
// doInitialization - Make sure that there is a prototype for abort in the
// current module.
bool LowerInvoke::doInitialization(Module &M) {
- const Type *VoidPtrTy = PointerType::get(Type::SByteTy);
+ const Type *VoidPtrTy = PointerType::get(Type::Int8Ty);
AbortMessage = 0;
if (ExpensiveEHSupport) {
// Insert a type for the linked list of jump buffers.
Constant::getNullValue(PtrJBList),
"llvm.sjljeh.jblist", &M);
}
- SetJmpFn = M.getOrInsertFunction("llvm.setjmp", Type::IntTy,
+ SetJmpFn = M.getOrInsertFunction("llvm.setjmp", Type::Int32Ty,
PointerType::get(JmpBufTy), (Type *)0);
LongJmpFn = M.getOrInsertFunction("llvm.longjmp", Type::VoidTy,
PointerType::get(JmpBufTy),
- Type::IntTy, (Type *)0);
+ Type::Int32Ty, (Type *)0);
}
// We need the 'write' and 'abort' functions for both models.
else
WriteFn = 0;
} else {
- WriteFn = M.getOrInsertFunction("write", Type::VoidTy, Type::IntTy,
- VoidPtrTy, Type::IntTy, (Type *)0);
+ WriteFn = M.getOrInsertFunction("write", Type::VoidTy, Type::Int32Ty,
+ VoidPtrTy, Type::Int32Ty, (Type *)0);
}
return true;
}
GlobalVariable *MsgGV = new GlobalVariable(Msg->getType(), true,
GlobalValue::InternalLinkage,
Msg, "abortmsg", &M);
- std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::IntTy));
+ std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::Int32Ty));
AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, GEPIdx);
} else {
// The abort message for cheap EH support tells the user that EH is not
GlobalVariable *MsgGV = new GlobalVariable(Msg->getType(), true,
GlobalValue::InternalLinkage,
Msg, "abortmsg", &M);
- std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::IntTy));
+ std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::Int32Ty));
AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, GEPIdx);
}
}
// These are the arguments we WANT...
std::vector<Value*> Args;
- Args.push_back(ConstantInt::get(Type::IntTy, 2));
+ Args.push_back(ConstantInt::get(Type::Int32Ty, 2));
Args.push_back(AbortMessage);
- Args.push_back(ConstantInt::get(Type::IntTy, AbortMessageLength));
+ Args.push_back(ConstantInt::get(Type::Int32Ty, AbortMessageLength));
// If the actual declaration of write disagrees, insert casts as
// appropriate.
void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo,
AllocaInst *InvokeNum,
SwitchInst *CatchSwitch) {
- ConstantInt *InvokeNoC = ConstantInt::get(Type::UIntTy, InvokeNo);
+ ConstantInt *InvokeNoC = ConstantInt::get(Type::Int32Ty, InvokeNo);
// Insert a store of the invoke num before the invoke and store zero into the
// location afterward.
BasicBlock::iterator NI = II->getNormalDest()->begin();
while (isa<PHINode>(NI)) ++NI;
// nonvolatile.
- new StoreInst(Constant::getNullValue(Type::UIntTy), InvokeNum, false, NI);
+ new StoreInst(Constant::getNullValue(Type::Int32Ty), InvokeNum, false, NI);
// Add a switch case to our unwind block.
CatchSwitch->addCase(InvokeNoC, II->getUnwindDest());
new AllocaInst(JBLinkTy, 0, Align, "jblink", F.begin()->begin());
std::vector<Value*> Idx;
- Idx.push_back(Constant::getNullValue(Type::IntTy));
- Idx.push_back(ConstantInt::get(Type::UIntTy, 1));
+ Idx.push_back(Constant::getNullValue(Type::Int32Ty));
+ Idx.push_back(ConstantInt::get(Type::Int32Ty, 1));
OldJmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "OldBuf",
EntryBB->getTerminator());
// Create an alloca which keeps track of which invoke is currently
// executing. For normal calls it contains zero.
- AllocaInst *InvokeNum = new AllocaInst(Type::UIntTy, 0, "invokenum",
+ AllocaInst *InvokeNum = new AllocaInst(Type::Int32Ty, 0, "invokenum",
EntryBB->begin());
- new StoreInst(ConstantInt::get(Type::UIntTy, 0), InvokeNum, true,
+ new StoreInst(ConstantInt::get(Type::Int32Ty, 0), InvokeNum, true,
EntryBB->getTerminator());
// Insert a load in the Catch block, and a switch on its value. By default,
BasicBlock *ContBlock = EntryBB->splitBasicBlock(EntryBB->getTerminator(),
"setjmp.cont");
- Idx[1] = ConstantInt::get(Type::UIntTy, 0);
+ Idx[1] = ConstantInt::get(Type::Int32Ty, 0);
Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "TheJmpBuf",
EntryBB->getTerminator());
Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret",
// Create the block to do the longjmp.
// Get a pointer to the jmpbuf and longjmp.
std::vector<Value*> Idx;
- Idx.push_back(Constant::getNullValue(Type::IntTy));
- Idx.push_back(ConstantInt::get(Type::UIntTy, 0));
+ Idx.push_back(Constant::getNullValue(Type::Int32Ty));
+ Idx.push_back(ConstantInt::get(Type::Int32Ty, 0));
Idx[0] = new GetElementPtrInst(BufPtr, Idx, "JmpBuf", UnwindBlock);
- Idx[1] = ConstantInt::get(Type::IntTy, 1);
+ Idx[1] = ConstantInt::get(Type::Int32Ty, 1);
new CallInst(LongJmpFn, Idx, "", UnwindBlock);
new UnreachableInst(UnwindBlock);
const ConstantInt* CI1 = cast<const ConstantInt>(C1.first);
const ConstantInt* CI2 = cast<const ConstantInt>(C2.first);
- if (CI1->getType()->isUnsigned())
- return CI1->getZExtValue() < CI2->getZExtValue();
- return CI1->getSExtValue() < CI2->getSExtValue();
+ return CI1->getZExtValue() < CI2->getZExtValue();
}
};
projects / oota-llvm.git / commitdiff