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/DerivedTypes.h"
  14 #include "llvm/iMemory.h"
  15 #include "llvm/iOther.h"
  16 #include "llvm/SymbolTable.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   bool Changed = false;
  77   const MethodType *MallocType =
  78     MethodType::get(PointerType::get(Type::SByteTy),
  79                     vector<const Type*>(1, Type::UIntTy), false);
  80
  81   SymbolTable *SymTab = M->getSymbolTableSure();
  82
  83   // Check for a definition of malloc
  84   if (Value *V = SymTab->lookup(PointerType::get(MallocType), "malloc")) {
  85     MallocFunc = cast<Function>(V);      // Yup, got it
  86   } else {                             // Nope, add one
  87     M->getFunctionList().push_back(MallocFunc = new Function(MallocType, false,
  88                                                              "malloc"));
  89     Changed = true;
  90   }
  91
  92   const MethodType *FreeType =
  93     MethodType::get(Type::VoidTy,
  94                     vector<const Type*>(1, PointerType::get(Type::SByteTy)),
  95                     false);
  96
  97   // Check for a definition of free
  98   if (Value *V = SymTab->lookup(PointerType::get(FreeType), "free")) {
  99     FreeFunc = cast<Function>(V);      // Yup, got it
 100   } else {                             // Nope, add one
 101     FreeFunc = new Function(FreeType, false,"free");
 102     M->getFunctionList().push_back(FreeFunc);
 103     Changed = true;
 104   }
 105
 106   return Changed;
 107 }
 108
 109 // runOnBasicBlock - This method does the actual work of converting
 110 // instructions over, assuming that the pass has already been initialized.
 111 //
 112 bool LowerAllocations::runOnBasicBlock(BasicBlock *BB) {
 113   bool Changed = false;
 114   assert(MallocFunc && FreeFunc && BB && "Pass not initialized!");
 115
 116   // Loop over all of the instructions, looking for malloc or free instructions
 117   for (unsigned i = 0; i < BB->size(); ++i) {
 118     BasicBlock::InstListType &BBIL = BB->getInstList();
 119     if (MallocInst *MI = dyn_cast<MallocInst>(*(BBIL.begin()+i))) {
 120       BBIL.remove(BBIL.begin()+i);   // remove the malloc instr...
 121
 122       const Type *AllocTy =cast<PointerType>(MI->getType())->getElementType();
 123
 124       // Get the number of bytes to be allocated for one element of the
 125       // requested type...
 126       unsigned Size = DataLayout.getTypeSize(AllocTy);
 127
 128       // malloc(type) becomes sbyte *malloc(constint)
 129       Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
 130       if (MI->getNumOperands() && Size == 1) {
 131         MallocArg = MI->getOperand(0);         // Operand * 1 = Operand
 132       } else if (MI->getNumOperands()) {
 133         // Multiply it by the array size if neccesary...
 134         MallocArg = BinaryOperator::create(Instruction::Mul,MI->getOperand(0),
 135                                            MallocArg);
 136         BBIL.insert(BBIL.begin()+i++, cast<Instruction>(MallocArg));
 137       }
 138
 139       // Create the call to Malloc...
 140       CallInst *MCall = new CallInst(MallocFunc,
 141                                      vector<Value*>(1, MallocArg));
 142       BBIL.insert(BBIL.begin()+i, MCall);
 143
 144       // Create a cast instruction to convert to the right type...
 145       CastInst *MCast = new CastInst(MCall, MI->getType());
 146       BBIL.insert(BBIL.begin()+i+1, MCast);
 147
 148       // Replace all uses of the old malloc inst with the cast inst
 149       MI->replaceAllUsesWith(MCast);
 150       delete MI;                          // Delete the malloc inst
 151       Changed = true;
 152     } else if (FreeInst *FI = dyn_cast<FreeInst>(*(BBIL.begin()+i))) {
 153       BBIL.remove(BB->getInstList().begin()+i);
 154
 155       // Cast the argument to free into a ubyte*...
 156       CastInst *MCast = new CastInst(FI->getOperand(0),
 157                                      PointerType::get(Type::UByteTy));
 158       BBIL.insert(BBIL.begin()+i, MCast);
 159
 160       // Insert a call to the free function...
 161       CallInst *FCall = new CallInst(FreeFunc,
 162                                      vector<Value*>(1, MCast));
 163       BBIL.insert(BBIL.begin()+i+1, FCall);
 164
 165       // Delete the old free instruction
 166       delete FI;
 167       Changed = true;
 168     }
 169   }
 170
 171   return Changed;
 172 }
 173
 174 bool RaiseAllocations::doInitialization(Module *M) {
 175   SymbolTable *ST = M->getSymbolTable();
 176   if (!ST) return false;
 177
 178   // If the module has a symbol table, they might be referring to the malloc
 179   // and free functions.  If this is the case, grab the method pointers that
 180   // the module is using.
 181   //
 182   // Lookup %malloc and %free in the symbol table, for later use.  If they
 183   // don't exist, or are not external, we do not worry about converting calls
 184   // to that function into the appropriate instruction.
 185   //
 186   const PointerType *MallocType =   // Get the type for malloc
 187     PointerType::get(MethodType::get(PointerType::get(Type::SByteTy),
 188                                   vector<const Type*>(1, Type::UIntTy), false));
 189   MallocFunc = cast_or_null<Function>(ST->lookup(MallocType, "malloc"));
 190   if (MallocFunc && !MallocFunc->isExternal())
 191     MallocFunc = 0;  // Don't mess with locally defined versions of the fn
 192
 193   const PointerType *FreeType =     // Get the type for free
 194     PointerType::get(MethodType::get(Type::VoidTy,
 195             vector<const Type*>(1, PointerType::get(Type::SByteTy)), false));
 196   FreeFunc = cast_or_null<Function>(ST->lookup(FreeType, "free"));
 197   if (FreeFunc && !FreeFunc->isExternal())
 198     FreeFunc = 0;  // Don't mess with locally defined versions of the fn
 199
 200   return false;
 201 }
 202
 203 // doOneCleanupPass - Do one pass over the input method, fixing stuff up.
 204 //
 205 bool RaiseAllocations::runOnBasicBlock(BasicBlock *BB) {
 206   bool Changed = false;
 207   BasicBlock::InstListType &BIL = BB->getInstList();
 208
 209   for (BasicBlock::iterator BI = BB->begin(); BI != BB->end();) {
 210     Instruction *I = *BI;
 211
 212     if (CallInst *CI = dyn_cast<CallInst>(I)) {
 213       if (CI->getCalledValue() == MallocFunc) {      // Replace call to malloc?
 214         const Type *PtrSByte = PointerType::get(Type::SByteTy);
 215         MallocInst *MallocI = new MallocInst(PtrSByte, CI->getOperand(1),
 216                                              CI->getName());
 217         CI->setName("");
 218         ReplaceInstWithInst(BIL, BI, MallocI);
 219         Changed = true;
 220         continue;  // Skip the ++BI
 221       } else if (CI->getCalledValue() == FreeFunc) { // Replace call to free?
 222         ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1)));
 223         Changed = true;
 224         continue;  // Skip the ++BI
 225       }
 226     }
 227
 228     ++BI;
 229   }
 230
 231   return Changed;
 232 }
 233
 234 Pass *createLowerAllocationsPass(const TargetData &TD) {
 235   return new LowerAllocations(TD);
 236 }
 237 Pass *createRaiseAllocationsPass() {
 238   return new RaiseAllocations();
 239 }
 240
 241