lib/Transforms/Utils/LowerAllocations.cpp

   1 //===- LowerAllocations.cpp - Reduce malloc & free insts to calls ---------===//
   2 //
   3 // The LowerAllocations transformation is a target dependant tranformation
   4 // because it depends on the size of data types and alignment constraints.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "llvm/Transforms/ChangeAllocations.h"
   9 #include "llvm/Module.h"
  10 #include "llvm/Function.h"
  11 #include "llvm/BasicBlock.h"
  12 #include "llvm/DerivedTypes.h"
  13 #include "llvm/iMemory.h"
  14 #include "llvm/iOther.h"
  15 #include "llvm/Constants.h"
  16 #include "llvm/Pass.h"
  17 #include "llvm/Target/TargetData.h"
  18 #include "Support/StatisticReporter.h"
  19
  20 static Statistic<> NumLowered("lowerallocs\t- Number of allocations lowered");
  21 using std::vector;
  22
  23 namespace {
  24
  25 // LowerAllocations - Turn malloc and free instructions into %malloc and %free
  26 // calls.
  27 //
  28 class LowerAllocations : public BasicBlockPass {
  29   Function *MallocFunc;   // Functions in the module we are processing
  30   Function *FreeFunc;     // Initialized by doInitialization
  31
  32   const TargetData &DataLayout;
  33 public:
  34   inline LowerAllocations(const TargetData &TD) : DataLayout(TD) {
  35     MallocFunc = FreeFunc = 0;
  36   }
  37
  38   const char *getPassName() const { return "Lower Allocations"; }
  39
  40   // doPassInitialization - For the lower allocations pass, this ensures that a
  41   // module contains a declaration for a malloc and a free function.
  42   //
  43   bool doInitialization(Module &M);
  44
  45   // runOnBasicBlock - This method does the actual work of converting
  46   // instructions over, assuming that the pass has already been initialized.
  47   //
  48   bool runOnBasicBlock(BasicBlock &BB);
  49 };
  50
  51 }
  52
  53 // createLowerAllocationsPass - Interface to this file...
  54 Pass *createLowerAllocationsPass(const TargetData &TD) {
  55   return new LowerAllocations(TD);
  56 }
  57
  58
  59 // doInitialization - For the lower allocations pass, this ensures that a
  60 // module contains a declaration for a malloc and a free function.
  61 //
  62 // This function is always successful.
  63 //
  64 bool LowerAllocations::doInitialization(Module &M) {
  65   const FunctionType *MallocType =
  66     FunctionType::get(PointerType::get(Type::SByteTy),
  67                       vector<const Type*>(1, Type::UIntTy), false);
  68   const FunctionType *FreeType =
  69     FunctionType::get(Type::VoidTy,
  70                       vector<const Type*>(1, PointerType::get(Type::SByteTy)),
  71                       false);
  72
  73   MallocFunc = M.getOrInsertFunction("malloc", MallocType);
  74   FreeFunc   = M.getOrInsertFunction("free"  , FreeType);
  75
  76   return true;
  77 }
  78
  79 // runOnBasicBlock - This method does the actual work of converting
  80 // instructions over, assuming that the pass has already been initialized.
  81 //
  82 bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
  83   bool Changed = false;
  84   assert(MallocFunc && FreeFunc && "Pass not initialized!");
  85
  86   BasicBlock::InstListType &BBIL = BB.getInstList();
  87
  88   // Loop over all of the instructions, looking for malloc or free instructions
  89   for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) {
  90     if (MallocInst *MI = dyn_cast<MallocInst>(&*I)) {
  91       BBIL.remove(I);   // remove the malloc instr...
  92
  93       const Type *AllocTy = MI->getType()->getElementType();
  94
  95       // Get the number of bytes to be allocated for one element of the
  96       // requested type...
  97       unsigned Size = DataLayout.getTypeSize(AllocTy);
  98
  99       // malloc(type) becomes sbyte *malloc(constint)
 100       Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
 101       if (MI->getNumOperands() && Size == 1) {
 102         MallocArg = MI->getOperand(0);         // Operand * 1 = Operand
 103       } else if (MI->getNumOperands()) {
 104         // Multiply it by the array size if neccesary...
 105         MallocArg = BinaryOperator::create(Instruction::Mul,MI->getOperand(0),
 106                                            MallocArg);
 107         I = ++BBIL.insert(I, cast<Instruction>(MallocArg));
 108       }
 109
 110       // Create the call to Malloc...
 111       CallInst *MCall = new CallInst(MallocFunc,
 112                                      vector<Value*>(1, MallocArg));
 113       I = BBIL.insert(I, MCall);
 114
 115       // Create a cast instruction to convert to the right type...
 116       CastInst *MCast = new CastInst(MCall, MI->getType());
 117       I = BBIL.insert(++I, MCast);
 118
 119       // Replace all uses of the old malloc inst with the cast inst
 120       MI->replaceAllUsesWith(MCast);
 121       delete MI;                          // Delete the malloc inst
 122       Changed = true;
 123       ++NumLowered;
 124     } else if (FreeInst *FI = dyn_cast<FreeInst>(&*I)) {
 125       BBIL.remove(I);
 126
 127       // Cast the argument to free into a ubyte*...
 128       CastInst *MCast = new CastInst(FI->getOperand(0),
 129                                      PointerType::get(Type::UByteTy));
 130       I = ++BBIL.insert(I, MCast);
 131
 132       // Insert a call to the free function...
 133       CallInst *FCall = new CallInst(FreeFunc, vector<Value*>(1, MCast));
 134       I = BBIL.insert(I, FCall);
 135
 136       // Delete the old free instruction
 137       delete FI;
 138       Changed = true;
 139       ++NumLowered;
 140     }
 141   }
 142
 143   return Changed;
 144 }