path: root/lib/Target/SparcV9/SparcV9RegInfo.cpp

//===-- SparcV9RegInfo.cpp - SparcV9 Target Register Information ----------===//
// 
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This file contains implementations of SparcV9 specific helper methods
// used for register allocation.
//
//===----------------------------------------------------------------------===//

#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "MachineInstrAnnot.h"
#include "RegAlloc/LiveRangeInfo.h"
#include "RegAlloc/LiveRange.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "SparcV9Internals.h"
#include "SparcV9RegClassInfo.h"
#include "SparcV9RegInfo.h"
#include "SparcV9TargetMachine.h"
#include <iostream>

namespace llvm {

enum {
  BadRegClass = ~0
};

SparcV9RegInfo::SparcV9RegInfo(const SparcV9TargetMachine &tgt)
  : target (tgt), NumOfIntArgRegs (6), NumOfFloatArgRegs (32)
{
  MachineRegClassArr.push_back(new SparcV9IntRegClass(IntRegClassID));
  MachineRegClassArr.push_back(new SparcV9FloatRegClass(FloatRegClassID));
  MachineRegClassArr.push_back(new SparcV9IntCCRegClass(IntCCRegClassID));
  MachineRegClassArr.push_back(new SparcV9FloatCCRegClass(FloatCCRegClassID));
  MachineRegClassArr.push_back(new SparcV9SpecialRegClass(SpecialRegClassID));
  
  assert(SparcV9FloatRegClass::StartOfNonVolatileRegs == 32 && 
         "32 Float regs are used for float arg passing");
}


// getZeroRegNum - returns the register that contains always zero.
// this is the unified register number
//
unsigned SparcV9RegInfo::getZeroRegNum() const {
  return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
                          SparcV9IntRegClass::g0);
}

// getCallAddressReg - returns the reg used for pushing the address when a
// method is called. This can be used for other purposes between calls
//
unsigned SparcV9RegInfo::getCallAddressReg() const {
  return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
                          SparcV9IntRegClass::o7);
}

// Returns the register containing the return address.
// It should be made sure that this  register contains the return 
// value when a return instruction is reached.
//
unsigned SparcV9RegInfo::getReturnAddressReg() const {
  return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
                          SparcV9IntRegClass::i7);
}

// Register get name implementations...

// Int register names in same order as enum in class SparcV9IntRegClass
static const char * const IntRegNames[] = {
  "o0", "o1", "o2", "o3", "o4", "o5",       "o7",
  "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
  "i0", "i1", "i2", "i3", "i4", "i5",  
  "i6", "i7",
  "g0", "g1", "g2", "g3", "g4", "g5",  "g6", "g7", 
  "o6"
}; 

const char * const SparcV9IntRegClass::getRegName(unsigned reg) const {
  assert(reg < NumOfAllRegs);
  return IntRegNames[reg];
}

static const char * const FloatRegNames[] = {    
  "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",  "f8",  "f9", 
  "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19",
  "f20", "f21", "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29",
  "f30", "f31", "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
  "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47", "f48", "f49",
  "f50", "f51", "f52", "f53", "f54", "f55", "f56", "f57", "f58", "f59",
  "f60", "f61", "f62", "f63"
};

const char * const SparcV9FloatRegClass::getRegName(unsigned reg) const {
  assert (reg < NumOfAllRegs);
  return FloatRegNames[reg];
}

static const char * const IntCCRegNames[] = {    
  "xcc",  "icc",  "ccr"
};

const char * const SparcV9IntCCRegClass::getRegName(unsigned reg) const {
  assert(reg < 3);
  return IntCCR