lib/CodeGen/MachineFunction.cpp

   1 //===-- MachineCodeForMethod.cpp --------------------------------------------=//
   2 //
   3 // Purpose:
   4 //   Collect native machine code information for a method.
   5 //   This allows target-specific information about the generated code
   6 //   to be stored with each method.
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/CodeGen/MachineCodeForMethod.h"
  10 #include "llvm/CodeGen/MachineInstr.h"  // For debug output
  11 #include "llvm/Target/TargetMachine.h"
  12 #include "llvm/Target/MachineFrameInfo.h"
  13 #include "llvm/Target/MachineCacheInfo.h"
  14 #include "llvm/Method.h"
  15 #include "llvm/iOther.h"
  16 #include <limits.h>
  17
  18 const int INVALID_FRAME_OFFSET = INT_MAX; // std::numeric_limits<int>::max();
  19
  20 static AnnotationID MCFM_AID(
  21                  AnnotationManager::getID("CodeGen::MachineCodeForMethod"));
  22
  23 // The next two methods are used to construct and to retrieve
  24 // the MachineCodeForMethod object for the given method.
  25 // construct() -- Allocates and initializes for a given method and target
  26 // get()       -- Returns a handle to the object.
  27 //                This should not be called before "construct()"
  28 //                for a given Method.
  29 //
  30 MachineCodeForMethod &MachineCodeForMethod::construct(const Method *M,
  31                                                       const TargetMachine &Tar){
  32   assert(M->getAnnotation(MCFM_AID) == 0 &&
  33          "Object already exists for this method!");
  34   MachineCodeForMethod* mcInfo = new MachineCodeForMethod(M, Tar);
  35   M->addAnnotation(mcInfo);
  36   return *mcInfo;
  37 }
  38
  39 void MachineCodeForMethod::destruct(const Method *M) {
  40   bool Deleted = M->deleteAnnotation(MCFM_AID);
  41   assert(Deleted && "Machine code did not exist for method!");
  42 }
  43
  44
  45 MachineCodeForMethod &MachineCodeForMethod::get(const Method* method) {
  46   MachineCodeForMethod* mc = (MachineCodeForMethod*)
  47     method->getAnnotation(MCFM_AID);
  48   assert(mc && "Call construct() method first to allocate the object");
  49   return *mc;
  50 }
  51
  52 static unsigned
  53 ComputeMaxOptionalArgsSize(const TargetMachine& target, const Method* method)
  54 {
  55   const MachineFrameInfo& frameInfo = target.getFrameInfo();
  56
  57   unsigned int maxSize = 0;
  58
  59   for (Method::const_inst_iterator I=method->inst_begin(),E=method->inst_end();
  60        I != E; ++I)
  61     if ((*I)->getOpcode() == Instruction::Call)
  62       {
  63         CallInst* callInst = cast<CallInst>(*I);
  64         unsigned int numOperands = callInst->getNumOperands() - 1;
  65         int numExtra = (int) numOperands - frameInfo.getNumFixedOutgoingArgs();
  66         if (numExtra <= 0)
  67           continue;
  68
  69         unsigned int sizeForThisCall;
  70         if (frameInfo.argsOnStackHaveFixedSize())
  71           {
  72             int argSize = frameInfo.getSizeOfEachArgOnStack();
  73             sizeForThisCall = numExtra * (unsigned) argSize;
  74           }
  75         else
  76           {
  77             assert(0 && "UNTESTED CODE: Size per stack argument is not fixed on this architecture: use actual arg sizes to compute MaxOptionalArgsSize");
  78             sizeForThisCall = 0;
  79             for (unsigned i=0; i < numOperands; ++i)
  80               sizeForThisCall += target.findOptimalStorageSize(callInst->
  81                                                     getOperand(i)->getType());
  82           }
  83
  84         if (maxSize < sizeForThisCall)
  85           maxSize = sizeForThisCall;
  86       }
  87
  88   return maxSize;
  89 }
  90
  91 // Align data larger than one L1 cache line on L1 cache line boundaries.
  92 // Align all smaller data on the next higher 2^x boundary (4, 8, ...).
  93 //
  94 // THIS FUNCTION HAS BEEN COPIED FROM EMITASSEMBLY.CPP AND
  95 // SHOULD BE USED DIRECTLY THERE
  96 //
  97 inline unsigned int
  98 SizeToAlignment(unsigned int size, const TargetMachine& target)
  99 {
 100   unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1);
 101   if (size > (unsigned) cacheLineSize / 2)
 102     return cacheLineSize;
 103   else
 104     for (unsigned sz=1; /*no condition*/; sz *= 2)
 105       if (sz >= size)
 106         return sz;
 107 }
 108
 109
 110
 111 /*ctor*/
 112 MachineCodeForMethod::MachineCodeForMethod(const Method* _M,
 113                                            const TargetMachine& target)
 114   : Annotation(MCFM_AID),
 115     method(_M), compiledAsLeaf(false), staticStackSize(0),
 116     automaticVarsSize(0), regSpillsSize(0),
 117     currentOptionalArgsSize(0), maxOptionalArgsSize(0),
 118     currentTmpValuesSize(0)
 119 {
 120   maxOptionalArgsSize = ComputeMaxOptionalArgsSize(target, method);
 121   staticStackSize = maxOptionalArgsSize +
 122                     target.getFrameInfo().getMinStackFrameSize();
 123 }
 124
 125 int
 126 MachineCodeForMethod::allocateLocalVar(const TargetMachine& target,
 127                                        const Value* val,
 128                                        unsigned int size)
 129 {
 130   // Check if we've allocated a stack slot for this value already
 131   //
 132   int offset = getOffset(val);
 133   if (offset == INVALID_FRAME_OFFSET)
 134     {
 135       bool growUp;
 136       int firstOffset =target.getFrameInfo().getFirstAutomaticVarOffset(*this,
 137                                                                        growUp);
 138       unsigned char align;
 139       if (size == 0)
 140         {
 141           size  = target.findOptimalStorageSize(val->getType());
 142           // align = target.DataLayout.getTypeAlignment(val->getType());
 143         }
 144
 145       align = SizeToAlignment(size, target);
 146
 147       offset = getAutomaticVarsSize();
 148       if (! growUp)
 149         offset += size;
 150
 151       if (unsigned int mod = offset % align)
 152         {
 153           offset += align - mod;
 154           size   += align - mod;
 155         }
 156
 157       offset = growUp? firstOffset + offset
 158                      : firstOffset - offset;
 159
 160       offsets[val] = offset;
 161
 162       incrementAutomaticVarsSize(size);
 163     }
 164   return offset;
 165 }
 166
 167 int
 168 MachineCodeForMethod::allocateSpilledValue(const TargetMachine& target,
 169                                            const Type* type)
 170 {
 171   unsigned int size  = target.findOptimalStorageSize(type);
 172   unsigned char align = target.DataLayout.getTypeAlignment(type);
 173
 174   bool growUp;
 175   int firstOffset = target.getFrameInfo().getRegSpillAreaOffset(*this, growUp);
 176
 177   int offset = getRegSpillsSize();
 178   if (! growUp)
 179     offset += size;
 180
 181   if (unsigned int mod = offset % align)
 182     {
 183       offset    += align - mod;
 184       size += align - mod;
 185     }
 186
 187   offset = growUp? firstOffset + offset
 188                  : firstOffset - offset;
 189
 190   incrementRegSpillsSize(size);
 191
 192   return offset;
 193 }
 194
 195 int
 196 MachineCodeForMethod::allocateOptionalArg(const TargetMachine& target,
 197                                           const Type* type)
 198 {
 199   const MachineFrameInfo& frameInfo = target.getFrameInfo();
 200
 201   int size = INT_MAX;
 202   if (frameInfo.argsOnStackHaveFixedSize())
 203     size = frameInfo.getSizeOfEachArgOnStack();
 204   else
 205     {
 206       size = target.findOptimalStorageSize(type);
 207       assert(0 && "UNTESTED CODE: Size per stack argument is not fixed on this architecture: use actual argument sizes for computing optional arg offsets");
 208     }
 209   unsigned char align = target.DataLayout.getTypeAlignment(type);
 210
 211   bool growUp;
 212   int firstOffset = frameInfo.getFirstOptionalOutgoingArgOffset(*this, growUp);
 213
 214   int offset = getCurrentOptionalArgsSize();
 215   if (! growUp)
 216     offset += size;
 217
 218   if (unsigned int mod = offset % align)
 219     {
 220       offset += align - mod;
 221       size   += align - mod;
 222     }
 223
 224   offset = growUp? firstOffset + offset
 225                  : firstOffset - offset;
 226
 227   incrementCurrentOptionalArgsSize(size);
 228
 229   return offset;
 230 }
 231
 232 void
 233 MachineCodeForMethod::resetOptionalArgs(const TargetMachine& target)
 234 {
 235   currentOptionalArgsSize = 0;
 236 }
 237
 238 int
 239 MachineCodeForMethod::pushTempValue(const TargetMachine& target,
 240                                     unsigned int size)
 241 {
 242   // Compute a power-of-2 alignment according to the possible sizes,
 243   // but not greater than the alignment of the largest type we support
 244   // (currently a double word -- see class TargetData).
 245   unsigned char align = 1;
 246   for (; align < size && align < target.DataLayout.getDoubleAlignment();
 247          align = 2*align)
 248     ;
 249
 250   bool growUp;
 251   int firstTmpOffset = target.getFrameInfo().getTmpAreaOffset(*this, growUp);
 252
 253   int offset = currentTmpValuesSize;
 254   if (! growUp)
 255     offset += size;
 256
 257   if (unsigned int mod = offset % align)
 258     {
 259       offset += align - mod;
 260       size   += align - mod;
 261     }
 262
 263   offset = growUp ? firstTmpOffset + offset : firstTmpOffset - offset;
 264
 265   currentTmpValuesSize += size;
 266   return offset;
 267 }
 268
 269 void
 270 MachineCodeForMethod::popAllTempValues(const TargetMachine& target)
 271 {
 272   currentTmpValuesSize = 0;
 273 }
 274
 275 int
 276 MachineCodeForMethod::getOffset(const Value* val) const
 277 {
 278   std::hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
 279   return (pair == offsets.end())? INVALID_FRAME_OFFSET : pair->second;
 280 }
 281
 282 void
 283 MachineCodeForMethod::dump() const
 284 {
 285   cerr << "\n" << method->getReturnType()
 286        << " \"" << method->getName() << "\"\n";
 287
 288   for (Method::const_iterator BI = method->begin(); BI != method->end(); ++BI)
 289     {
 290       BasicBlock* bb = *BI;
 291       cerr << "\n"
 292            << (bb->hasName()? bb->getName() : "Label")
 293            << " (" << bb << ")" << ":\n";
 294
 295       MachineCodeForBasicBlock& mvec = bb->getMachineInstrVec();
 296       for (unsigned i=0; i < mvec.size(); i++)
 297         cerr << "\t" << *mvec[i];
 298     }
 299   cerr << "\nEnd method \"" << method->getName() << "\"\n\n";
 300 }