path: root/lib/CodeGen/RegAlloc/PhyRegAlloc.cpp

// $Id$
//***************************************************************************
// File:
//	PhyRegAlloc.cpp
// 
// Purpose:
//      Register allocation for LLVM.
//	
// History:
//	9/10/01	 -  Ruchira Sasanka - created.
//**************************************************************************/

#include "llvm/CodeGen/RegisterAllocation.h"
#include "llvm/CodeGen/PhyRegAlloc.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineCodeForMethod.h"
#include "llvm/Analysis/LiveVar/FunctionLiveVarInfo.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/MachineFrameInfo.h"
#include "llvm/BasicBlock.h"
#include "llvm/Function.h"
#include "llvm/Type.h"
#include <iostream>
#include <math.h>
using std::cerr;


// ***TODO: There are several places we add instructions. Validate the order
//          of adding these instructions.

cl::Enum<RegAllocDebugLevel_t> DEBUG_RA("dregalloc", cl::NoFlags,
  "enable register allocation debugging information",
  clEnumValN(RA_DEBUG_None   , "n", "disable debug output"),
  clEnumValN(RA_DEBUG_Normal , "y", "enable debug output"),
  clEnumValN(RA_DEBUG_Verbose, "v", "enable extra debug output"), 0);


//----------------------------------------------------------------------------
// RegisterAllocation pass front end...
//----------------------------------------------------------------------------
namespace {
  class RegisterAllocator : public FunctionPass {
    TargetMachine &Target;
  public:
    inline RegisterAllocator(TargetMachine &T) : Target(T) {}
    
    bool runOnFunction(Function *F) {
      if (DEBUG_RA)
        cerr << "\n******************** Function "<< F->getName()
             << " ********************\n";
      
      PhyRegAlloc PRA(F, Target, &getAnalysis<FunctionLiveVarInfo>(),
                      &getAnalysis<cfg::LoopInfo>());
      PRA.allocateRegisters();
      
      if (DEBUG_RA) cerr << "\nRegister allocation complete!\n";
      return false;
    }

    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
      AU.addRequired(cfg::LoopInfo::ID);
      AU.addRequired(FunctionLiveVarInfo::ID);
    }
  };
}

Pass *getRegisterAllocator(TargetMachine &T) {
  return new RegisterAllocator(T);
}

//----------------------------------------------------------------------------
// Constructor: Init local composite objects and create register classes.
//----------------------------------------------------------------------------
PhyRegAlloc::PhyRegAlloc(Function *F, 
			 const TargetMachine& tm, 
			 FunctionLiveVarInfo *Lvi,
                         cfg::LoopInfo *LDC) 
                       :  TM(tm), Meth(F),
                          mcInfo(MachineCodeForMethod::get(F)),
                          LVI(Lvi), LRI(F, tm, RegClassList), 
			  MRI(tm.getRegInfo()),
                          NumOfRegClasses(MRI.getNumOfRegClasses()),
			  LoopDepthCalc(LDC) {

  // create each RegisterClass and put in RegClassList
  //
  for(unsigned