//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/Support/Debug.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Transforms/IPO.h"
+#include <cstring>
using namespace llvm;
/// This statistic keeps track of the total number of library calls that have
Constant *get_puts() {
if (!puts_func)
puts_func = M->getOrInsertFunction("puts", Type::Int32Ty,
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
NULL);
return puts_func;
}
Constant *get_fputs(const Type* FILEptr_type) {
if (!fputs_func)
fputs_func = M->getOrInsertFunction("fputs", Type::Int32Ty,
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
FILEptr_type, NULL);
return fputs_func;
}
Constant *get_fwrite(const Type* FILEptr_type) {
if (!fwrite_func)
fwrite_func = M->getOrInsertFunction("fwrite", TD->getIntPtrType(),
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
TD->getIntPtrType(),
TD->getIntPtrType(),
FILEptr_type, NULL);
Constant *get_strcpy() {
if (!strcpy_func)
strcpy_func = M->getOrInsertFunction("strcpy",
- PointerType::get(Type::Int8Ty),
- PointerType::get(Type::Int8Ty),
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
NULL);
return strcpy_func;
}
Constant *get_strlen() {
if (!strlen_func)
strlen_func = M->getOrInsertFunction("strlen", TD->getIntPtrType(),
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
NULL);
return strlen_func;
}
Constant *get_memchr() {
if (!memchr_func)
memchr_func = M->getOrInsertFunction("memchr",
- PointerType::get(Type::Int8Ty),
- PointerType::get(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
+ PointerType::getUnqual(Type::Int8Ty),
Type::Int32Ty, TD->getIntPtrType(),
NULL);
return memchr_func;
/// @brief Return a Function* for the memcpy libcall
Constant *get_memcpy() {
if (!memcpy_func) {
- const Type *SBP = PointerType::get(Type::Int8Ty);
+ const Type *SBP = PointerType::getUnqual(Type::Int8Ty);
const char *N = TD->getIntPtrType() == Type::Int32Ty ?
"llvm.memcpy.i32" : "llvm.memcpy.i64";
memcpy_func = M->getOrInsertFunction(N, Type::VoidTy, SBP, SBP,
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 2 &&
- FT->getReturnType() == PointerType::get(Type::Int8Ty) &&
+ FT->getReturnType() == PointerType::getUnqual(Type::Int8Ty) &&
FT->getParamType(0) == FT->getReturnType() &&
FT->getParamType(1) == FT->getReturnType();
}
ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1), // copy nul byte.
ConstantInt::get(Type::Int32Ty, 1) // alignment
};
- new CallInst(SLC.get_memcpy(), Vals, 4, "", CI);
+ new CallInst(SLC.get_memcpy(), Vals, Vals + 4, "", CI);
return ReplaceCallWith(CI, Dst);
}
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 2 &&
- FT->getReturnType() == PointerType::get(Type::Int8Ty) &&
+ FT->getReturnType() == PointerType::getUnqual(Type::Int8Ty) &&
FT->getParamType(0) == FT->getReturnType() &&
isa<IntegerType>(FT->getParamType(1));
}
CI->getOperand(2),
ConstantInt::get(SLC.getIntPtrType(), Str.size()+1)
};
- return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, 3,
+ return ReplaceCallWith(CI, new CallInst(SLC.get_memchr(), Args, Args + 3,
CI->getName(), CI));
}
const FunctionType *FT = F->getFunctionType();
return FT->getReturnType() == Type::Int32Ty && FT->getNumParams() == 2 &&
FT->getParamType(0) == FT->getParamType(1) &&
- FT->getParamType(0) == PointerType::get(Type::Int8Ty);
+ FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty);
}
/// @brief Perform the strcmp optimization
const FunctionType *FT = F->getFunctionType();
return FT->getReturnType() == Type::Int32Ty && FT->getNumParams() == 3 &&
FT->getParamType(0) == FT->getParamType(1) &&
- FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+ FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
isa<IntegerType>(FT->getParamType(2));
return false;
}
return FT->getNumParams() == 2 &&
FT->getParamType(0) == FT->getParamType(1) &&
FT->getReturnType() == FT->getParamType(0) &&
- FT->getParamType(0) == PointerType::get(Type::Int8Ty);
+ FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty);
}
/// @brief Perform the strcpy optimization
// 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 (SrcStr.size() == 0) {
+ if (SrcStr.empty()) {
new StoreInst(ConstantInt::get(Type::Int8Ty, 0), Dst, CI);
return ReplaceCallWith(CI, Dst);
}
ConstantInt::get(SLC.getIntPtrType(), SrcStr.size()+1),
ConstantInt::get(Type::Int32Ty, 1) // alignment
};
- new CallInst(SLC.get_memcpy(), MemcpyOps, 4, "", CI);
+ new CallInst(SLC.get_memcpy(), MemcpyOps, MemcpyOps + 4, "", CI);
return ReplaceCallWith(CI, Dst);
}
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 1 &&
- FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+ FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
isa<IntegerType>(FT->getReturnType());
}
return ReplaceCallWith(CI, Constant::getNullValue(CI->getType()));
case 1: {
// memcmp(S1,S2,1) -> *(ubyte*)S1 - *(ubyte*)S2
- const Type *UCharPtr = PointerType::get(Type::Int8Ty);
+ const Type *UCharPtr = PointerType::getUnqual(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::Int8Ty);
+ const Type *UCharPtr = PointerType::getUnqual(Type::Int8Ty);
CastInst *Op1Cast = CastInst::create(
Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
CastInst *Op2Cast = CastInst::create(
}
} memcmpOptimizer;
+/// This LibCallOptimization will simplify a call to the memcpy library
+/// function. It simply converts them into calls to llvm.memcpy.*;
+/// the resulting call should be optimized later.
+/// @brief Simplify the memcpy library function.
+struct VISIBILITY_HIDDEN MemCpyOptimization : public LibCallOptimization {
+public:
+ MemCpyOptimization() : LibCallOptimization("memcpy",
+ "Number of 'memcpy' calls simplified") {}
+
+ /// @brief Make sure that the "memcpy" function has the right prototype
+ virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
+ const FunctionType *FT = F->getFunctionType();
+ const Type* voidPtr = PointerType::getUnqual(Type::Int8Ty);
+ return FT->getReturnType() == voidPtr && FT->getNumParams() == 3 &&
+ FT->getParamType(0) == voidPtr &&
+ FT->getParamType(1) == voidPtr &&
+ FT->getParamType(2) == SLC.getIntPtrType();
+ }
+
+ /// @brief Perform the memcpy optimization
+ virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) {
+ Value *MemcpyOps[] = {
+ CI->getOperand(1), CI->getOperand(2), CI->getOperand(3),
+ ConstantInt::get(Type::Int32Ty, 1) // align = 1 always.
+ };
+ new CallInst(SLC.get_memcpy(), MemcpyOps, MemcpyOps + 4, "", CI);
+ // memcpy always returns the destination
+ return ReplaceCallWith(CI, CI->getOperand(1));
+ }
+} MemCpyOptimizer;
/// This LibCallOptimization will simplify a call to the memcpy library
/// function by expanding it out to a single store of size 0, 1, 2, 4, or 8
// Cast source and dest to the right sized primitive and then load/store
CastInst* SrcCast = CastInst::create(Instruction::BitCast,
- src, PointerType::get(castType), src->getName()+".cast", ci);
+ src, PointerType::getUnqual(castType), src->getName()+".cast", ci);
CastInst* DestCast = CastInst::create(Instruction::BitCast,
- dest, PointerType::get(castType),dest->getName()+".cast", ci);
+ dest, PointerType::getUnqual(castType),dest->getName()+".cast", ci);
LoadInst* LI = new LoadInst(SrcCast,SrcCast->getName()+".val",ci);
new StoreInst(LI, DestCast, ci);
return ReplaceCallWith(ci, 0);
}
// Cast dest to the right sized primitive and then load/store
- CastInst* DestCast = new BitCastInst(dest, PointerType::get(castType),
+ CastInst* DestCast = new BitCastInst(dest, PointerType::getUnqual(castType),
dest->getName()+".cast", ci);
new StoreInst(ConstantInt::get(castType,fill_value),DestCast, ci);
return ReplaceCallWith(ci, 0);
/// @brief Perform the pow optimization.
virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) {
const Type *Ty = cast<Function>(ci->getOperand(0))->getReturnType();
+ if (Ty!=Type::FloatTy && Ty!=Type::DoubleTy)
+ return false; // FIXME long double not yet supported
Value* base = ci->getOperand(1);
Value* expn = ci->getOperand(2);
if (ConstantFP *Op1 = dyn_cast<ConstantFP>(base)) {
- double Op1V = Op1->getValue();
- if (Op1V == 1.0) // pow(1.0,x) -> 1.0
- return ReplaceCallWith(ci, ConstantFP::get(Ty, 1.0));
+ if (Op1->isExactlyValue(1.0)) // pow(1.0,x) -> 1.0
+ return ReplaceCallWith(ci, ConstantFP::get(Ty,
+ Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)));
} else if (ConstantFP* Op2 = dyn_cast<ConstantFP>(expn)) {
- double Op2V = Op2->getValue();
- if (Op2V == 0.0) {
+ if (Op2->getValueAPF().isZero()) {
// pow(x,0.0) -> 1.0
- return ReplaceCallWith(ci, ConstantFP::get(Ty,1.0));
- } else if (Op2V == 0.5) {
+ return ReplaceCallWith(ci, ConstantFP::get(Ty,
+ Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)));
+ } else if (Op2->isExactlyValue(0.5)) {
// pow(x,0.5) -> sqrt(x)
CallInst* sqrt_inst = new CallInst(SLC.get_sqrt(), base,
ci->getName()+".pow",ci);
return ReplaceCallWith(ci, sqrt_inst);
- } else if (Op2V == 1.0) {
+ } else if (Op2->isExactlyValue(1.0)) {
// pow(x,1.0) -> x
return ReplaceCallWith(ci, base);
- } else if (Op2V == -1.0) {
+ } else if (Op2->isExactlyValue(-1.0)) {
// pow(x,-1.0) -> 1.0/x
Value *div_inst =
- BinaryOperator::createFDiv(ConstantFP::get(Ty, 1.0), base,
- ci->getName()+".pow", ci);
+ BinaryOperator::createFDiv(ConstantFP::get(Ty,
+ Ty==Type::FloatTy ? APFloat(1.0f) : APFloat(1.0)),
+ base, ci->getName()+".pow", ci);
return ReplaceCallWith(ci, div_inst);
}
}
Init, "str",
CI->getParent()->getParent()->getParent());
// Cast GV to be a pointer to char.
- GV = ConstantExpr::getBitCast(GV, PointerType::get(Type::Int8Ty));
+ GV = ConstantExpr::getBitCast(GV, PointerType::getUnqual(Type::Int8Ty));
new CallInst(SLC.get_puts(), GV, "", CI);
if (CI->use_empty()) return ReplaceCallWith(CI, 0);
+ // The return value from printf includes the \n we just removed, so +1.
return ReplaceCallWith(CI,
- ConstantInt::get(CI->getType(), FormatStr.size()));
+ ConstantInt::get(CI->getType(),
+ FormatStr.size()+1));
}
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 2 && // two fixed arguments.
- FT->getParamType(1) == PointerType::get(Type::Int8Ty) &&
+ FT->getParamType(1) == PointerType::getUnqual(Type::Int8Ty) &&
isa<PointerType>(FT->getParamType(0)) &&
isa<IntegerType>(FT->getReturnType());
}
ConstantInt::get(SLC.getIntPtrType(), 1),
CI->getOperand(1)
};
- new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, 4, CI->getName(), CI);
+ new CallInst(SLC.get_fwrite(FILEty), FWriteArgs, FWriteArgs + 4, CI->getName(), CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(),
FormatStr.size()));
}
const Type *FILETy = CI->getOperand(1)->getType();
Value *C = CastInst::createZExtOrBitCast(CI->getOperand(3), Type::Int32Ty,
CI->getName()+".int", CI);
- new CallInst(SLC.get_fputc(FILETy), C, CI->getOperand(1), "", CI);
+ SmallVector<Value *, 2> Args;
+ Args.push_back(C);
+ Args.push_back(CI->getOperand(1));
+ new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
}
case 's': {
return false;
// fprintf(file,"%s",str) -> fputs(str,file)
- new CallInst(SLC.get_fputs(FILETy), CastToCStr(CI->getOperand(3), CI),
- CI->getOperand(1), CI->getName(), CI);
+ SmallVector<Value *, 2> Args;
+ Args.push_back(CastToCStr(CI->getOperand(3), CI));
+ Args.push_back(CI->getOperand(1));
+ new CallInst(SLC.get_fputs(FILETy), Args.begin(),
+ Args.end(), CI->getName(), CI);
return ReplaceCallWith(CI, 0);
}
default:
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 2 && // two fixed arguments.
- FT->getParamType(1) == PointerType::get(Type::Int8Ty) &&
+ FT->getParamType(1) == PointerType::getUnqual(Type::Int8Ty) &&
FT->getParamType(0) == FT->getParamType(1) &&
isa<IntegerType>(FT->getReturnType());
}
FormatStr.size()+1), // Copy the nul byte.
ConstantInt::get(Type::Int32Ty, 1)
};
- new CallInst(SLC.get_memcpy(), MemCpyArgs, 4, "", CI);
+ new CallInst(SLC.get_memcpy(), MemCpyArgs, MemCpyArgs + 4, "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(),
FormatStr.size()));
}
Len,
ConstantInt::get(Type::Int32Ty, 1)
};
- new CallInst(SLC.get_memcpy(), MemcpyArgs, 4, "", CI);
+ new CallInst(SLC.get_memcpy(), MemcpyArgs, MemcpyArgs + 4, "", CI);
// The strlen result is the unincremented number of bytes in the string.
if (!CI->use_empty()) {
ConstantInt::get(SLC.getIntPtrType(), 1),
CI->getOperand(2)
};
- new CallInst(SLC.get_fwrite(FILETy), FWriteParms, 4, "", CI);
+ new CallInst(SLC.get_fwrite(FILETy), FWriteParms, FWriteParms + 4, "", CI);
return ReplaceCallWith(CI, 0); // Known to have no uses (see above).
}
} FPutsOptimizer;
virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
const FunctionType *FT = F->getFunctionType();
return FT->getNumParams() == 4 &&
- FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+ FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
FT->getParamType(1) == FT->getParamType(2) &&
isa<IntegerType>(FT->getParamType(1)) &&
isa<PointerType>(FT->getParamType(3)) &&
// If this is writing one byte, turn it into fputc.
if (EltSize == 1 && EltCount == 1) {
+ SmallVector<Value *, 2> Args;
// fwrite(s,1,1,F) -> fputc(s[0],F)
Value *Ptr = CI->getOperand(1);
Value *Val = new LoadInst(Ptr, Ptr->getName()+".byte", CI);
- Val = new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI);
+ Args.push_back(new ZExtInst(Val, Type::Int32Ty, Val->getName()+".int", CI));
+ Args.push_back(CI->getOperand(4));
const Type *FILETy = CI->getOperand(4)->getType();
- new CallInst(SLC.get_fputc(FILETy), Val, CI->getOperand(4), "", CI);
+ new CallInst(SLC.get_fputc(FILETy), Args.begin(), Args.end(), "", CI);
return ReplaceCallWith(CI, ConstantInt::get(CI->getType(), 1));
}
return false;
static 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::Int8Ty);
+ const Type *SBPTy = PointerType::getUnqual(Type::Int8Ty);
if (V->getType() != SBPTy)
return new BitCastInst(V, SBPTy, V->getName(), IP);
return V;
projects / oota-llvm.git / blobdiff