/// This statistic keeps track of the total number of library calls that have
/// been simplified regardless of which call it is.
-Statistic<> SimplifiedLibCalls("simplify-libcalls",
+Statistic SimplifiedLibCalls("simplify-libcalls",
"Number of library calls simplified");
// Forward declarations
LibCallOptimization **Prev, *Next;
const char *FunctionName; ///< Name of the library call we optimize
#ifndef NDEBUG
- Statistic<> occurrences; ///< debug statistic (-debug-only=simplify-libcalls)
+ Statistic occurrences; ///< debug statistic (-debug-only=simplify-libcalls)
#endif
public:
/// The \p fname argument must be the name of the library function being
// All the "well-known" functions are external and have external linkage
// because they live in a runtime library somewhere and were (probably)
// not compiled by LLVM. So, we only act on external functions that
- // have external linkage and non-empty uses.
- if (!FI->isExternal() || !FI->hasExternalLinkage() || FI->use_empty())
+ // have external or dllimport linkage and non-empty uses.
+ if (!FI->isExternal() ||
+ !(FI->hasExternalLinkage() || FI->hasDLLImportLinkage()) ||
+ FI->use_empty())
continue;
// Get the optimization class that pertains to this function
};
// Register the pass
-RegisterOpt<SimplifyLibCalls>
-X("simplify-libcalls","Simplify well-known library calls");
+RegisterPass<SimplifyLibCalls>
+X("simplify-libcalls", "Simplify well-known library calls");
} // anonymous namespace
std::vector<Value*> vals;
vals.push_back(gep); // destination
vals.push_back(ci->getOperand(2)); // source
- vals.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); // length
- vals.push_back(ConstantUInt::get(Type::UIntTy,1)); // alignment
+ vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length
+ vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment
new CallInst(SLC.get_memcpy(), vals, "", ci);
// Finally, substitute the first operand of the strcat call for the
// Check that the first argument to strchr is a constant array of sbyte.
// If it is, get the length and data, otherwise return false.
uint64_t len = 0;
- ConstantArray* CA;
+ ConstantArray* CA = 0;
if (!getConstantStringLength(ci->getOperand(1),len,&CA))
return false;
- // Check that the second argument to strchr is a constant int, return false
- // if it isn't
- ConstantSInt* CSI = dyn_cast<ConstantSInt>(ci->getOperand(2));
- if (!CSI) {
- // Just lower this to memchr since we know the length of the string as
- // it is constant.
+ // 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() ) {
+ // 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(ConstantUInt::get(SLC.getIntPtrType(),len));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
ci->replaceAllUsesWith( new CallInst(f,args,ci->getName(),ci));
ci->eraseFromParent();
return true;
}
// Get the character we're looking for
- int64_t chr = CSI->getValue();
+ int64_t chr = CSI->getSExtValue();
// Compute the offset
uint64_t offset = 0;
bool char_found = false;
for (uint64_t i = 0; i < len; ++i) {
- if (ConstantSInt* CI = dyn_cast<ConstantSInt>(CA->getOperand(i))) {
+ if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) {
// Check for the null terminator
if (CI->isNullValue())
break; // we found end of string
- else if (CI->getValue() == chr) {
+ else if (CI->getSExtValue() == chr) {
char_found = true;
offset = i;
break;
// (if c is a constant integer and s is a constant string)
if (char_found) {
std::vector<Value*> indices;
- indices.push_back(ConstantUInt::get(Type::ULongTy,offset));
+ indices.push_back(ConstantInt::get(Type::ULongTy,offset));
GetElementPtrInst* GEP = new GetElementPtrInst(ci->getOperand(1),indices,
ci->getOperand(1)->getName()+".strchr",ci);
ci->replaceAllUsesWith(GEP);
LoadInst* load =
new LoadInst(CastToCStr(s2,*ci), ci->getName()+".load",ci);
CastInst* cast =
- new CastInst(load,Type::IntTy,ci->getName()+".int",ci);
+ CastInst::create(Instruction::SExt, load, Type::IntTy,
+ ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
return true;
LoadInst* load =
new LoadInst(CastToCStr(s1,*ci),ci->getName()+".val",ci);
CastInst* cast =
- new CastInst(load,Type::IntTy,ci->getName()+".int",ci);
+ CastInst::create(Instruction::SExt, load, Type::IntTy,
+ ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
return true;
std::string str1 = A1->getAsString();
std::string str2 = A2->getAsString();
int result = strcmp(str1.c_str(), str2.c_str());
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,result));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result));
ci->eraseFromParent();
return true;
}
bool len_arg_is_const = false;
if (ConstantInt* len_CI = dyn_cast<ConstantInt>(ci->getOperand(3))) {
len_arg_is_const = true;
- len_arg = len_CI->getRawValue();
+ len_arg = len_CI->getZExtValue();
if (len_arg == 0) {
// strncmp(x,y,0) -> 0
ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
// strncmp("",x) -> *x
LoadInst* load = new LoadInst(s1,ci->getName()+".load",ci);
CastInst* cast =
- new CastInst(load,Type::IntTy,ci->getName()+".int",ci);
+ CastInst::create(Instruction::SExt, load, Type::IntTy,
+ ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
return true;
// strncmp(x,"") -> *x
LoadInst* load = new LoadInst(s2,ci->getName()+".val",ci);
CastInst* cast =
- new CastInst(load,Type::IntTy,ci->getName()+".int",ci);
+ CastInst::create(Instruction::SExt, load, Type::IntTy,
+ ci->getName()+".int", ci);
ci->replaceAllUsesWith(cast);
ci->eraseFromParent();
return true;
std::string str1 = A1->getAsString();
std::string str2 = A2->getAsString();
int result = strncmp(str1.c_str(), str2.c_str(), len_arg);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,result));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result));
ci->eraseFromParent();
return true;
}
std::vector<Value*> vals;
vals.push_back(dest); // destination
vals.push_back(src); // source
- vals.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); // length
- vals.push_back(ConstantUInt::get(Type::UIntTy,1)); // alignment
+ vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length
+ vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment
new CallInst(SLC.get_memcpy(), vals, "", ci);
// Finally, substitute the first operand of the strcat call for the
if (ConstantInt* CI = dyn_cast<ConstantInt>(bop->getOperand(1)))
{
// Get the value the strlen result is compared to
- uint64_t val = CI->getRawValue();
+ uint64_t val = CI->getZExtValue();
// If its compared against length 0 with == or !=
if (val == 0 &&
// strlen(x) == 0 -> *x == 0
LoadInst* load = new LoadInst(str,str->getName()+".first",ci);
BinaryOperator* rbop = BinaryOperator::create(bop->getOpcode(),
- load, ConstantSInt::get(Type::SByteTy,0),
+ load, ConstantInt::get(Type::SByteTy,0),
bop->getName()+".strlen", ci);
bop->replaceAllUsesWith(rbop);
bop->eraseFromParent();
// strlen("xyz") -> 3 (for example)
const Type *Ty = SLC.getTargetData()->getIntPtrType();
if (Ty->isSigned())
- ci->replaceAllUsesWith(ConstantSInt::get(Ty, len));
+ ci->replaceAllUsesWith(ConstantInt::get(Ty, len));
else
- ci->replaceAllUsesWith(ConstantUInt::get(Ty, len));
+ ci->replaceAllUsesWith(ConstantInt::get(Ty, len));
ci->eraseFromParent();
return true;
// Make sure we have a constant length.
ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getOperand(3));
if (!LenC) return false;
- uint64_t Len = LenC->getRawValue();
+ uint64_t Len = LenC->getZExtValue();
// If the length is zero, this returns 0.
switch (Len) {
case 1: {
// memcmp(S1,S2,1) -> *(ubyte*)S1 - *(ubyte*)S2
const Type *UCharPtr = PointerType::get(Type::UByteTy);
- CastInst *Op1Cast = new CastInst(LHS, UCharPtr, LHS->getName(), CI);
- CastInst *Op2Cast = new CastInst(RHS, UCharPtr, RHS->getName(), CI);
+ CastInst *Op1Cast = CastInst::create(
+ Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
+ CastInst *Op2Cast = CastInst::create(
+ Instruction::BitCast, RHS, UCharPtr, RHS->getName(), CI);
Value *S1V = new LoadInst(Op1Cast, LHS->getName()+".val", CI);
Value *S2V = new LoadInst(Op2Cast, RHS->getName()+".val", CI);
Value *RV = BinaryOperator::createSub(S1V, S2V, CI->getName()+".diff",CI);
if (RV->getType() != CI->getType())
- RV = new CastInst(RV, CI->getType(), RV->getName(), CI);
+ RV = CastInst::createIntegerCast(RV, CI->getType(), false,
+ RV->getName(), CI);
CI->replaceAllUsesWith(RV);
CI->eraseFromParent();
return true;
// memcmp(S1,S2,2) -> S1[0]-S2[0] | S1[1]-S2[1] iff only ==/!= 0 matters
const Type *UCharPtr = PointerType::get(Type::UByteTy);
- CastInst *Op1Cast = new CastInst(LHS, UCharPtr, LHS->getName(), CI);
- CastInst *Op2Cast = new CastInst(RHS, UCharPtr, RHS->getName(), CI);
+ CastInst *Op1Cast = CastInst::create(
+ Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
+ CastInst *Op2Cast = CastInst::create(
+ Instruction::BitCast, RHS, UCharPtr, RHS->getName(), CI);
Value *S1V1 = new LoadInst(Op1Cast, LHS->getName()+".val1", CI);
Value *S2V1 = new LoadInst(Op2Cast, RHS->getName()+".val1", CI);
Value *D1 = BinaryOperator::createSub(S1V1, S2V1,
CI->getName()+".d1", CI);
Value *Or = BinaryOperator::createOr(D1, D2, CI->getName()+".res", CI);
if (Or->getType() != CI->getType())
- Or = new CastInst(Or, CI->getType(), Or->getName(), CI);
+ Or = CastInst::createIntegerCast(Or, CI->getType(), false /*ZExt*/,
+ Or->getName(), CI);
CI->replaceAllUsesWith(Or);
CI->eraseFromParent();
return true;
return false;
// If the length is larger than the alignment, we can't optimize
- uint64_t len = LEN->getRawValue();
- uint64_t alignment = ALIGN->getRawValue();
+ uint64_t len = LEN->getZExtValue();
+ uint64_t alignment = ALIGN->getZExtValue();
if (alignment == 0)
alignment = 1; // Alignment 0 is identity for alignment 1
if (len > alignment)
}
// Cast source and dest to the right sized primitive and then load/store
- CastInst* SrcCast =
- new CastInst(src,PointerType::get(castType),src->getName()+".cast",ci);
- CastInst* DestCast =
- new CastInst(dest,PointerType::get(castType),dest->getName()+".cast",ci);
+ CastInst* SrcCast = CastInst::create(Instruction::BitCast,
+ src, PointerType::get(castType), src->getName()+".cast", ci);
+ CastInst* DestCast = CastInst::create(Instruction::BitCast,
+ dest, PointerType::get(castType),dest->getName()+".cast", ci);
LoadInst* LI = new LoadInst(SrcCast,SrcCast->getName()+".val",ci);
- StoreInst* SI = new StoreInst(LI, DestCast, ci);
+ new StoreInst(LI, DestCast, ci);
ci->eraseFromParent();
return true;
}
return false;
// Extract the length and alignment
- uint64_t len = LEN->getRawValue();
- uint64_t alignment = ALIGN->getRawValue();
+ uint64_t len = LEN->getZExtValue();
+ uint64_t alignment = ALIGN->getZExtValue();
// Alignment 0 is identity for alignment 1
if (alignment == 0)
// Make sure we have a constant ubyte to work with so we can extract
// the value to be filled.
- ConstantUInt* FILL = dyn_cast<ConstantUInt>(ci->getOperand(2));
+ ConstantInt* FILL = dyn_cast<ConstantInt>(ci->getOperand(2));
if (!FILL)
return false;
if (FILL->getType() != Type::UByteTy)
// memset(s,c,n) -> store s, c (for n=1,2,4,8)
// Extract the fill character
- uint64_t fill_char = FILL->getValue();
+ uint64_t fill_char = FILL->getZExtValue();
uint64_t fill_value = fill_char;
// Get the type we will cast to, based on size of memory area to fill, and
}
// Cast dest to the right sized primitive and then load/store
- CastInst* DestCast =
- new CastInst(dest,PointerType::get(castType),dest->getName()+".cast",ci);
- new StoreInst(ConstantUInt::get(castType,fill_value),DestCast, ci);
+ CastInst* DestCast = new BitCastInst(dest, PointerType::get(castType),
+ dest->getName()+".cast", ci);
+ new StoreInst(ConstantInt::get(castType,fill_value),DestCast, ci);
ci->eraseFromParent();
return true;
}
return true;
} else if (Op2V == -1.0) {
// pow(x,-1.0) -> 1.0/x
- BinaryOperator* div_inst= BinaryOperator::createDiv(
+ BinaryOperator* div_inst= BinaryOperator::createFDiv(
ConstantFP::get(Ty,1.0), base, ci->getName()+".pow", ci);
ci->replaceAllUsesWith(div_inst);
ci->eraseFromParent();
// The first character has to be a %
if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0)))
- if (CI->getRawValue() != '%')
+ if (CI->getZExtValue() != '%')
return false;
// Get the second character and switch on its value
ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1));
- switch (CI->getRawValue()) {
+ switch (CI->getZExtValue()) {
case 's':
{
if (len != 3 ||
- dyn_cast<ConstantInt>(CA->getOperand(2))->getRawValue() != '\n')
+ dyn_cast<ConstantInt>(CA->getOperand(2))->getZExtValue() != '\n')
return false;
// printf("%s\n",str) -> puts(str)
if (!puts_func)
return false;
std::vector<Value*> args;
- args.push_back(ci->getOperand(2));
+ args.push_back(CastToCStr(ci->getOperand(2), *ci));
new CallInst(puts_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
break;
}
case 'c':
Function* putchar_func = SLC.get_putchar();
if (!putchar_func)
return false;
- CastInst* cast = new CastInst(ci->getOperand(2), Type::IntTy,
- CI->getName()+".int", ci);
+ CastInst* cast = CastInst::createSExtOrBitCast(
+ ci->getOperand(2), Type::IntTy, CI->getName()+".int", ci);
new CallInst(putchar_func, cast, "", ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy, 1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy, 1));
break;
}
default:
for (unsigned i = 0; i < len; ++i) {
if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) {
// Check for the null terminator
- if (CI->getRawValue() == '%')
+ if (CI->getZExtValue() == '%')
return false; // we found end of string
} else {
return false;
std::vector<Value*> args;
args.push_back(ci->getOperand(2));
- args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len));
- args.push_back(ConstantUInt::get(SLC.getIntPtrType(),1));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),1));
args.push_back(ci->getOperand(1));
new CallInst(fwrite_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
ci->eraseFromParent();
return true;
}
// The first character has to be a %
if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0)))
- if (CI->getRawValue() != '%')
+ if (CI->getZExtValue() != '%')
return false;
// Get the second character and switch on its value
ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1));
- switch (CI->getRawValue()) {
+ switch (CI->getZExtValue()) {
case 's':
{
uint64_t len = 0;
return false;
std::vector<Value*> args;
args.push_back(CastToCStr(ci->getOperand(3), *ci));
- args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len));
- args.push_back(ConstantUInt::get(SLC.getIntPtrType(),1));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),1));
args.push_back(ci->getOperand(1));
new CallInst(fwrite_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
} else {
// fprintf(file,"%s",str) -> fputs(str,file)
const Type* FILEptr_type = ci->getOperand(1)->getType();
if (!fputs_func)
return false;
std::vector<Value*> args;
- args.push_back(ci->getOperand(3));
+ args.push_back(CastToCStr(ci->getOperand(3), *ci));
args.push_back(ci->getOperand(1));
new CallInst(fputs_func,args,ci->getName(),ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
}
break;
}
Function* fputc_func = SLC.get_fputc(FILEptr_type);
if (!fputc_func)
return false;
- CastInst* cast = new CastInst(ci->getOperand(3), Type::IntTy,
- CI->getName()+".int", ci);
+ CastInst* cast = CastInst::createSExtOrBitCast(
+ ci->getOperand(3), Type::IntTy, CI->getName()+".int", ci);
new CallInst(fputc_func,cast,ci->getOperand(1),"",ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
break;
}
default:
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(ConstantSInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
ci->eraseFromParent();
return true;
}
for (unsigned i = 0; i < len; ++i) {
if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) {
// Check for the null terminator
- if (CI->getRawValue() == '%')
+ if (CI->getZExtValue() == '%')
return false; // we found a %, can't optimize
} else {
return false; // initializer is not constant int, can't optimize
std::vector<Value*> args;
args.push_back(ci->getOperand(1));
args.push_back(ci->getOperand(2));
- args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len));
- args.push_back(ConstantUInt::get(Type::UIntTy,1));
+ args.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
+ args.push_back(ConstantInt::get(Type::UIntTy,1));
new CallInst(memcpy_func,args,"",ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len));
ci->eraseFromParent();
return true;
}
// The first character has to be a %
if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0)))
- if (CI->getRawValue() != '%')
+ if (CI->getZExtValue() != '%')
return false;
// Get the second character and switch on its value
ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1));
- switch (CI->getRawValue()) {
+ switch (CI->getZExtValue()) {
case 's': {
// sprintf(dest,"%s",str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
Function* strlen_func = SLC.get_strlen();
ConstantInt::get(Len->getType(), 1),
Len->getName()+"1", ci);
if (Len1->getType() != SLC.getIntPtrType())
- Len1 = new CastInst(Len1, SLC.getIntPtrType(), Len1->getName(), ci);
+ Len1 = CastInst::createIntegerCast(Len1, SLC.getIntPtrType(), false,
+ Len1->getName(), ci);
std::vector<Value*> args;
args.push_back(CastToCStr(ci->getOperand(1), *ci));
args.push_back(CastToCStr(ci->getOperand(3), *ci));
args.push_back(Len1);
- args.push_back(ConstantUInt::get(Type::UIntTy,1));
+ args.push_back(ConstantInt::get(Type::UIntTy,1));
new CallInst(memcpy_func, args, "", ci);
// The strlen result is the unincremented number of bytes in the string.
if (!ci->use_empty()) {
if (Len->getType() != ci->getType())
- Len = new CastInst(Len, ci->getType(), Len->getName(), ci);
+ Len = CastInst::createIntegerCast(Len, ci->getType(), false,
+ Len->getName(), ci);
ci->replaceAllUsesWith(Len);
}
ci->eraseFromParent();
}
case 'c': {
// sprintf(dest,"%c",chr) -> store chr, dest
- CastInst* cast = new CastInst(ci->getOperand(3),Type::SByteTy,"char",ci);
+ CastInst* cast = CastInst::createTruncOrBitCast(
+ ci->getOperand(3), Type::SByteTy, "char", ci);
new StoreInst(cast, ci->getOperand(1), ci);
GetElementPtrInst* gep = new GetElementPtrInst(ci->getOperand(1),
- ConstantUInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end",
+ ConstantInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end",
ci);
new StoreInst(ConstantInt::get(Type::SByteTy,0),gep,ci);
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
ci->eraseFromParent();
return true;
}
return false;
LoadInst* loadi = new LoadInst(ci->getOperand(1),
ci->getOperand(1)->getName()+".byte",ci);
- CastInst* casti = new CastInst(loadi,Type::IntTy,
- loadi->getName()+".int",ci);
+ CastInst* casti = new SExtInst(loadi, Type::IntTy,
+ loadi->getName()+".int", ci);
new CallInst(fputc_func,casti,ci->getOperand(2),"",ci);
break;
}
return false;
std::vector<Value*> parms;
parms.push_back(ci->getOperand(1));
- parms.push_back(ConstantUInt::get(SLC.getIntPtrType(),len));
- parms.push_back(ConstantUInt::get(SLC.getIntPtrType(),1));
+ parms.push_back(ConstantInt::get(SLC.getIntPtrType(),len));
+ parms.push_back(ConstantInt::get(SLC.getIntPtrType(),1));
parms.push_back(ci->getOperand(2));
new CallInst(fwrite_func,parms,"",ci);
break;
virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) {
if (ConstantInt* CI = dyn_cast<ConstantInt>(ci->getOperand(1))) {
// isdigit(c) -> 0 or 1, if 'c' is constant
- uint64_t val = CI->getRawValue();
+ uint64_t val = CI->getZExtValue();
if (val >= '0' && val <='9')
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1));
else
- ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,0));
+ ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0));
ci->eraseFromParent();
return true;
}
// isdigit(c) -> (unsigned)c - '0' <= 9
- CastInst* cast =
- new CastInst(ci->getOperand(1),Type::UIntTy,
- ci->getOperand(1)->getName()+".uint",ci);
+ CastInst* cast = CastInst::createIntegerCast(ci->getOperand(1),
+ Type::UIntTy, false/*ZExt*/, ci->getOperand(1)->getName()+".uint", ci);
BinaryOperator* sub_inst = BinaryOperator::createSub(cast,
- ConstantUInt::get(Type::UIntTy,0x30),
+ ConstantInt::get(Type::UIntTy,0x30),
ci->getOperand(1)->getName()+".sub",ci);
SetCondInst* setcond_inst = new SetCondInst(Instruction::SetLE,sub_inst,
- ConstantUInt::get(Type::UIntTy,9),
+ ConstantInt::get(Type::UIntTy,9),
ci->getOperand(1)->getName()+".cmp",ci);
- CastInst* c2 =
- new CastInst(setcond_inst,Type::IntTy,
- ci->getOperand(1)->getName()+".isdigit",ci);
+ CastInst* c2 = new ZExtInst(setcond_inst, Type::IntTy,
+ ci->getOperand(1)->getName()+".isdigit", ci);
ci->replaceAllUsesWith(c2);
ci->eraseFromParent();
return true;
// isascii(c) -> (unsigned)c < 128
Value *V = CI->getOperand(1);
if (V->getType()->isSigned())
- V = new CastInst(V, V->getType()->getUnsignedVersion(), V->getName(), CI);
- Value *Cmp = BinaryOperator::createSetLT(V, ConstantUInt::get(V->getType(),
+ V = new BitCastInst(V, V->getType()->getUnsignedVersion(), V->getName(),
+ CI);
+ Value *Cmp = BinaryOperator::createSetLT(V, ConstantInt::get(V->getType(),
128),
V->getName()+".isascii", CI);
if (Cmp->getType() != CI->getType())
- Cmp = new CastInst(Cmp, CI->getType(), Cmp->getName(), CI);
+ Cmp = new BitCastInst(Cmp, CI->getType(), Cmp->getName(), CI);
CI->replaceAllUsesWith(Cmp);
CI->eraseFromParent();
return true;
// ffs(cnst) -> bit#
// ffsl(cnst) -> bit#
// ffsll(cnst) -> bit#
- uint64_t val = CI->getRawValue();
+ uint64_t val = CI->getZExtValue();
int result = 0;
if (val) {
++result;
val >>= 1;
}
}
- TheCall->replaceAllUsesWith(ConstantSInt::get(Type::IntTy, result));
+ TheCall->replaceAllUsesWith(ConstantInt::get(Type::IntTy, result));
TheCall->eraseFromParent();
return true;
}
Function *F = SLC.getModule()->getOrInsertFunction(CTTZName, ArgType,
ArgType, NULL);
- Value *V = new CastInst(TheCall->getOperand(1), ArgType, "tmp", TheCall);
+ Value *V = CastInst::createIntegerCast(TheCall->getOperand(1), ArgType,
+ false/*ZExt*/, "tmp", TheCall);
Value *V2 = new CallInst(F, V, "tmp", TheCall);
- V2 = new CastInst(V2, Type::IntTy, "tmp", TheCall);
- V2 = BinaryOperator::createAdd(V2, ConstantSInt::get(Type::IntTy, 1),
+ V2 = CastInst::createIntegerCast(V2, Type::IntTy, false/*ZExt*/,
+ "tmp", TheCall);
+ V2 = BinaryOperator::createAdd(V2, ConstantInt::get(Type::IntTy, 1),
"tmp", TheCall);
Value *Cond =
BinaryOperator::createSetEQ(V, Constant::getNullValue(V->getType()),
if (Cast->getOperand(0)->getType() == Type::FloatTy) {
Value *New = new CallInst((SLC.*FP)(), Cast->getOperand(0),
CI->getName(), CI);
- New = new CastInst(New, Type::DoubleTy, CI->getName(), CI);
+ New = new FPExtInst(New, Type::DoubleTy, CI->getName(), CI);
CI->replaceAllUsesWith(New);
CI->eraseFromParent();
if (Cast->use_empty())
// value. We'll need this later for indexing the ConstantArray.
uint64_t start_idx = 0;
if (ConstantInt* CI = dyn_cast<ConstantInt>(GEP->getOperand(2)))
- start_idx = CI->getRawValue();
+ start_idx = CI->getZExtValue();
else
return false;
Constant* INTLZR = GV->getInitializer();
// Handle the ConstantAggregateZero case
- if (ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(INTLZR)) {
+ if (isa<ConstantAggregateZero>(INTLZR)) {
// This is a degenerate case. The initializer is constant zero so the
// length of the string must be zero.
len = 0;
/// inserting the cast before IP, and return the cast.
/// @brief Cast a value to a "C" string.
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);
if (V->getType() != SBPTy)
- return new CastInst(V, SBPTy, V->getName(), &IP);
+ return new BitCastInst(V, SBPTy, V->getName(), &IP);
return V;
}
projects / oota-llvm.git / blobdiff