lib/Transforms/Utils/LowerAllocations.cpp

   1 //===- ChangeAllocations.cpp - Modify %malloc & %free calls -----------------=//
   2 //
   3 // This file defines two passes that convert malloc and free instructions to
   4 // calls to and from %malloc & %free function calls.  The LowerAllocations
   5 // transformation is a target dependant tranformation because it depends on the
   6 // size of data types and alignment constraints.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Transforms/ChangeAllocations.h"
  11 #include "llvm/Target/TargetData.h"
  12 #include "llvm/Module.h"
  13 #include "llvm/Function.h"
  14 #include "llvm/DerivedTypes.h"
  15 #include "llvm/iMemory.h"
  16 #include "llvm/iOther.h"
  17 #include "llvm/ConstantVals.h"
  18 #include "llvm/Pass.h"
  19 #include "TransformInternals.h"
  20 using std::vector;
  21
  22 namespace {
  23
  24 // LowerAllocations - Turn malloc and free instructions into %malloc and %free
  25 // calls.
  26 //
  27 class LowerAllocations : public BasicBlockPass {
  28   Function *MallocFunc;   // Functions in the module we are processing
  29   Function *FreeFunc;     // Initialized by doInitialization
  30
  31   const TargetData &DataLayout;
  32 public:
  33   inline LowerAllocations(const TargetData &TD) : DataLayout(TD) {
  34     MallocFunc = FreeFunc = 0;
  35   }
  36
  37   // doPassInitialization - For the lower allocations pass, this ensures that a
  38   // module contains a declaration for a malloc and a free function.
  39   //
  40   bool doInitialization(Module *M);
  41
  42   // runOnBasicBlock - This method does the actual work of converting
  43   // instructions over, assuming that the pass has already been initialized.
  44   //
  45   bool runOnBasicBlock(BasicBlock *BB);
  46 };
  47
  48 // RaiseAllocations - Turn %malloc and %free calls into the appropriate
  49 // instruction.
  50 //
  51 class RaiseAllocations : public BasicBlockPass {
  52   Function *MallocFunc;   // Functions in the module we are processing
  53   Function *FreeFunc;     // Initialized by doPassInitializationVirt
  54 public:
  55   inline RaiseAllocations() : MallocFunc(0), FreeFunc(0) {}
  56
  57   // doPassInitialization - For the raise allocations pass, this finds a
  58   // declaration for malloc and free if they exist.
  59   //
  60   bool doInitialization(Module *M);
  61
  62   // runOnBasicBlock - This method does the actual work of converting
  63   // instructions over, assuming that the pass has already been initialized.
  64   //
  65   bool runOnBasicBlock(BasicBlock *BB);
  66 };
  67
  68 }  // end anonymous namespace
  69
  70 // doInitialization - For the lower allocations pass, this ensures that a
  71 // module contains a declaration for a malloc and a free function.
  72 //
  73 // This function is always successful.
  74 //
  75 bool LowerAllocations::doInitialization(Module *M) {
  76   const FunctionType *MallocType =
  77     FunctionType::get(PointerType::get(Type::SByteTy),
  78                       vector<const Type*>(1, Type::UIntTy), false);
  79   const FunctionType *FreeType =
  80     FunctionType::get(Type::VoidTy,
  81                       vector<const Type*>(1, PointerType::get(Type::SByteTy)),
  82                       false);
  83
  84   MallocFunc = M->getOrInsertFunction("malloc", MallocType);
  85   FreeFunc   = M->getOrInsertFunction("free"  , FreeType);
  86
  87   return false;
  88 }
  89
  90 // runOnBasicBlock - This method does the actual work of converting
  91 // instructions over, assuming that the pass has already been initialized.
  92 //
  93 bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) {
  94   bool Changed = false;
  95   assert(MallocFunc && FreeFunc && BB && "Pass not initialized!");
  96
  97   // Loop over all of the instructions, looking for malloc or free instructions
  98   for (unsigned i = 0; i < BB->size(); ++i) {
  99     BasicBlock::InstListType &BBIL = BB->getInstList();
 100     if (MallocInst *MI = dyn_cast<MallocInst>(*(BBIL.begin()+i))) {
 101       BBIL.remove(BBIL.begin()+i);   // remove the malloc instr...
 102
 103       const Type *AllocTy =cast<PointerType>(MI->getType())->getElementType();
 104
 105       // Get the number of bytes to be allocated for one element of the
 106       // requested type...
 107       unsigned Size = DataLayout.getTypeSize(AllocTy);
 108
 109       // malloc(type) becomes sbyte *malloc(constint)
 110       Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
 111       if (MI->getNumOperands() && Size == 1) {
 112         MallocArg = MI->getOperand(0);         // Operand * 1 = Operand
 113       } else if (MI->getNumOperands()) {
 114         // Multiply it by the array size if neccesary...
 115         MallocArg = BinaryOperator::create(Instruction::Mul,MI->getOperand(0),
 116                                            MallocArg);
 117         BBIL.insert(BBIL.begin()+i++, cast<Instruction>(MallocArg));
 118       }
 119
 120       // Create the call to Malloc...
 121       CallInst *MCall = new CallInst(MallocFunc,
 122                                      vector<Value*>(1, MallocArg));
 123       BBIL.insert(BBIL.begin()+i, MCall);
 124
 125       // Create a cast instruction to convert to the right type...
 126       CastInst *MCast = new CastInst(MCall, MI->getType());
 127       BBIL.insert(BBIL.begin()+i+1, MCast);
 128
 129       // Replace all uses of the old malloc inst with the cast inst
 130       MI->replaceAllUsesWith(MCast);
 131       delete MI;                          // Delete the malloc inst
 132       Changed = true;
 133     } else if (FreeInst *FI = dyn_cast<FreeInst>(*(BBIL.begin()+i))) {
 134       BBIL.remove(BB->getInstList().begin()+i);
 135
 136       // Cast the argument to free into a ubyte*...
 137       CastInst *MCast = new CastInst(FI->getOperand(0),
 138                                      PointerType::get(Type::UByteTy));
 139       BBIL.insert(BBIL.begin()+i, MCast);
 140
 141       // Insert a call to the free function...
 142       CallInst *FCall = new CallInst(FreeFunc,
 143                                      vector<Value*>(1, MCast));
 144       BBIL.insert(BBIL.begin()+i+1, FCall);
 145
 146       // Delete the old free instruction
 147       delete FI;
 148       Changed = true;
 149     }
 150   }
 151
 152   return Changed;
 153 }
 154
 155 bool RaiseAllocations::doInitialization(Module *M) {
 156   // If the module has a symbol table, they might be referring to the malloc
 157   // and free functions.  If this is the case, grab the method pointers that
 158   // the module is using.
 159   //
 160   // Lookup %malloc and %free in the symbol table, for later use.  If they
 161   // don't exist, or are not external, we do not worry about converting calls
 162   // to that function into the appropriate instruction.
 163   //
 164   const FunctionType *MallocType =   // Get the type for malloc
 165     FunctionType::get(PointerType::get(Type::SByteTy),
 166                       vector<const Type*>(1, Type::UIntTy), false);
 167
 168   const FunctionType *FreeType =     // Get the type for free
 169     FunctionType::get(Type::VoidTy,
 170                       vector<const Type*>(1, PointerType::get(Type::SByteTy)),
 171                       false);
 172
 173   MallocFunc = M->getFunction("malloc", MallocType);
 174   FreeFunc   = M->getFunction("free"  , FreeType);
 175
 176   // Don't mess with locally defined versions of these functions...
 177   if (MallocFunc && !MallocFunc->isExternal()) MallocFunc = 0;
 178   if (FreeFunc && !FreeFunc->isExternal())     FreeFunc = 0;
 179   return false;
 180 }
 181
 182 // doOneCleanupPass - Do one pass over the input method, fixing stuff up.
 183 //
 184 bool RaiseAllocations::runOnBasicBlock(BasicBlock *BB) {
 185   bool Changed = false;
 186   BasicBlock::InstListType &BIL = BB->getInstList();
 187
 188   for (BasicBlock::iterator BI = BB->begin(); BI != BB->end();) {
 189     Instruction *I = *BI;
 190
 191     if (CallInst *CI = dyn_cast<CallInst>(I)) {
 192       if (CI->getCalledValue() == MallocFunc) {      // Replace call to malloc?
 193         const Type *PtrSByte = PointerType::get(Type::SByteTy);
 194         MallocInst *MallocI = new MallocInst(PtrSByte, CI->getOperand(1),
 195                                              CI->getName());
 196         CI->setName("");
 197         ReplaceInstWithInst(BIL, BI, MallocI);
 198         Changed = true;
 199         continue;  // Skip the ++BI
 200       } else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
 201         ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1)));
 202         Changed = true;
 203         continue;  // Skip the ++BI
 204       }
 205     }
 206
 207     ++BI;
 208   }
 209
 210   return Changed;
 211 }
 212
 213 Pass *createLowerAllocationsPass(const TargetData &TD) {
 214   return new LowerAllocations(TD);
 215 }
 216 Pass *createRaiseAllocationsPass() {
 217   return new RaiseAllocations();
 218 }
 219
 220