memory allocate functions in llvm - llvm

Question

How to detect malloc and free function calls in a llvm pass and replace it with a new function calls by getting the arguments and return type in llvm?
i.e. Is there a way to create new functions (Malloc and free) and then create function calls whenever Malloc and free are detected?
1.Create malloc and free
Type *BPTy = PointerType::getUnqual(Type::getInt8Ty(M.getContext()));
FunctionType *malloc_Fty = FunctionType::get(BPTy, llvm::ArrayRef<Type*>(), true);
Function *malloc_func = cast<Function>(M.getOrInsertFunction("malloc", malloc_Fty));
FunctionType *free_Fty = FunctionType::get(Type::getVoidTy(M.getContext()), BPTy, false);
Function *free_func = cast<Function>(M.getOrInsertFunction("free",free_Fty));
2. Detect malloc and free and replace it with new malloc and free function calls
if(CallInst *CI = dyn_cast<CallInst>(I)) {
Function *Callee = CI->getCalledFunction();
if (Callee->getName() == "malloc") {
FunctionType *Ty = Callee->getFunctionType();
PointerType *PtrTy = dyn_cast<PointerType>(Ty);
Type *AllocTy = PtrTy->getElementType();
const DataLayout &DL = M.getDataLayout();
Type *IntPtrTy = DL.getIntPtrType(M.getContext());
Value *mallocArgs;
mallocArgs = ConstantExpr::getSizeOf(AllocTy);
mallocArgs = ConstantExpr::getTruncOrBitCast(cast<Constant>(mallocArgs), IntPtrTy);
if (const AllocaInst *AI = dyn_cast<AllocaInst>(&*I)) {
if (AI->isArrayAllocation()) {
if (isa<ConstantInt>(mallocArgs) && cast<ConstantInt>(mallocArgs)->isOne()) {
mallocArgs = I->getOperand(0);
} else if (Constant *CO = dyn_cast<Constant>(I->getOperand(0))) {
CO = ConstantExpr::getIntegerCast(CO, IntPtrTy, false );
mallocArgs = ConstantExpr::getMul(CO, cast<Constant>(mallocArgs));
} else {
Value *Scale = I->getOperand(0);
if (Scale->getType() != IntPtrTy)
Scale = CastInst::CreateIntegerCast(Scale, IntPtrTy, false,"", &*I);
// Multiply it by the array size if necessary...
mallocArgs =BinaryOperator::Create(Instruction::Mul, Scale, mallocArgs, "", &*I);
}
}
}
// Create the call to malloc
CallInst *malloc_Call = CallInst::Create(malloc_func, mallocArgs, "", &*I);
// Cast the instruction to convert to the correct type
Value *malloc_PtrCast;
Type * voidty=Type::getVoidTy (M.getContext());
if (malloc_Call->getType() !=voidty )
malloc_PtrCast = new BitCastInst(malloc_Call, I->getType(), "", &*I);
else
malloc_PtrCast = Constant::getNullValue(I->getType());
Instruction *II=dyn_cast<Instruction>(&*I);
II->replaceAllUsesWith(malloc_PtrCast);
}
if (Callee->getName() == "free") {
Value *free_PtrCast =
new BitCastInst(I->getOperand(0), PointerType::getUnqual(Type::getInt8Ty(M.getContext())), "", &*I);
// Create the call to free function
CallInst::Create(free_func, free_PtrCast, "", &*I);
Instruction *II=dyn_cast<Instruction>(&*I);
II->replaceAllUsesWith(free_PtrCast);
}
}
3. Example on which I am testing
void* ptr;
void malloc_func()
{
ptr = malloc(512);
}
void free_func()
{
free(ptr);
}
But, I am getting segmentation fault, is this the correct way to replace malloc and free function calls with the new functions?