#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Target/TargetData.h"
-#include "llvm/Target/TargetLowering.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Config/config.h"
#include <fstream>
static AnnotationID MF_AID(
AnnotationManager::getID("CodeGen::MachineCodeForFunction"));
-// Out of line virtual function to home classes.
-void MachineFunctionPass::virtfn() {}
+bool MachineFunctionPass::runOnFunction(Function &F) {
+ // Do not codegen any 'available_externally' functions at all, they have
+ // definitions outside the translation unit.
+ if (F.hasAvailableExternallyLinkage())
+ return false;
+
+ return runOnMachineFunction(MachineFunction::get(&F));
+}
namespace {
struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass {
std::ostream *OS;
const std::string Banner;
- Printer (std::ostream *_OS, const std::string &_Banner)
- : MachineFunctionPass((intptr_t)&ID), OS (_OS), Banner (_Banner) { }
+ Printer (std::ostream *os, const std::string &banner)
+ : MachineFunctionPass(&ID), OS(os), Banner(banner) {}
const char *getPassName() const { return "MachineFunction Printer"; }
namespace {
struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass {
static char ID;
- Deleter() : MachineFunctionPass((intptr_t)&ID) {}
+ Deleter() : MachineFunctionPass(&ID) {}
const char *getPassName() const { return "Machine Code Deleter"; }
// MachineFunction implementation
//===---------------------------------------------------------------------===//
-void alist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
+void ilist_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {
MBB->getParent()->DeleteMachineBasicBlock(MBB);
}
MachineFunction::MachineFunction(const Function *F,
const TargetMachine &TM)
: Annotation(MF_AID), Fn(F), Target(TM) {
- RegInfo = new (Allocator.Allocate<MachineRegisterInfo>())
- MachineRegisterInfo(*TM.getRegisterInfo());
+ if (TM.getRegisterInfo())
+ RegInfo = new (Allocator.Allocate<MachineRegisterInfo>())
+ MachineRegisterInfo(*TM.getRegisterInfo());
+ else
+ RegInfo = 0;
MFInfo = 0;
FrameInfo = new (Allocator.Allocate<MachineFrameInfo>())
MachineFrameInfo(*TM.getFrameInfo());
BasicBlocks.clear();
InstructionRecycler.clear(Allocator);
BasicBlockRecycler.clear(Allocator);
- MemOperandRecycler.clear(Allocator);
- RegInfo->~MachineRegisterInfo(); Allocator.Deallocate(RegInfo);
+ if (RegInfo)
+ RegInfo->~MachineRegisterInfo(); Allocator.Deallocate(RegInfo);
if (MFInfo) {
MFInfo->~MachineFunctionInfo(); Allocator.Deallocate(MFInfo);
}
/// of `new MachineInstr'.
///
MachineInstr *
-MachineFunction::CreateMachineInstr(const TargetInstrDesc &TID, bool NoImp) {
+MachineFunction::CreateMachineInstr(const TargetInstrDesc &TID,
+ DebugLoc DL, bool NoImp) {
return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
- MachineInstr(TID, NoImp);
+ MachineInstr(TID, DL, NoImp);
}
/// CloneMachineInstr - Create a new MachineInstr which is a copy of the
BasicBlockRecycler.Deallocate(Allocator, MBB);
}
-/// CreateMachineMemOperand - Allocate a new MachineMemOperand. Use this
-/// instead of `new MachineMemOperand'.
-///
-MachineMemOperand *
-MachineFunction::CreateMachineMemOperand(const MachineMemOperand &MMO) {
- return new (MemOperandRecycler.Allocate<MachineMemOperand>(Allocator))
- MachineMemOperand(MMO);
-}
-
-/// DeleteMachineMemOperand - Delete the given MachineMemOperand.
-///
-void
-MachineFunction::DeleteMachineMemOperand(MachineMemOperand *MO) {
- MO->~MachineMemOperand();
- MemOperandRecycler.Deallocate(Allocator, MO);
-}
-
void MachineFunction::dump() const {
print(*cerr.stream());
}
JumpTableInfo->print(OS);
// Print Constant Pool
- ConstantPool->print(OS);
+ {
+ raw_os_ostream OSS(OS);
+ ConstantPool->print(OSS);
+ }
const TargetRegisterInfo *TRI = getTarget().getRegisterInfo();
- if (!RegInfo->livein_empty()) {
+ if (RegInfo && !RegInfo->livein_empty()) {
OS << "Live Ins:";
for (MachineRegisterInfo::livein_iterator
I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
}
OS << "\n";
}
- if (!RegInfo->liveout_empty()) {
+ if (RegInfo && !RegInfo->liveout_empty()) {
OS << "Live Outs:";
for (MachineRegisterInfo::liveout_iterator
I = RegInfo->liveout_begin(), E = RegInfo->liveout_end(); I != E; ++I)
return *mc;
}
+/// addLiveIn - Add the specified physical register as a live-in value and
+/// create a corresponding virtual register for it.
+unsigned MachineFunction::addLiveIn(unsigned PReg,
+ const TargetRegisterClass *RC) {
+ assert(RC->contains(PReg) && "Not the correct regclass!");
+ unsigned VReg = getRegInfo().createVirtualRegister(RC);
+ getRegInfo().addLiveIn(PReg, VReg);
+ return VReg;
+}
+
+/// getOrCreateDebugLocID - Look up the DebugLocTuple index with the given
+/// source file, line, and column. If none currently exists, create a new
+/// DebugLocTuple, and insert it into the DebugIdMap.
+unsigned MachineFunction::getOrCreateDebugLocID(GlobalVariable *CompileUnit,
+ unsigned Line, unsigned Col) {
+ DebugLocTuple Tuple(CompileUnit, Line, Col);
+ DenseMap<DebugLocTuple, unsigned>::iterator II
+ = DebugLocInfo.DebugIdMap.find(Tuple);
+ if (II != DebugLocInfo.DebugIdMap.end())
+ return II->second;
+ // Add a new tuple.
+ unsigned Id = DebugLocInfo.DebugLocations.size();
+ DebugLocInfo.DebugLocations.push_back(Tuple);
+ DebugLocInfo.DebugIdMap[Tuple] = Id;
+ return Id;
+}
+
+/// getDebugLocTuple - Get the DebugLocTuple for a given DebugLoc object.
+DebugLocTuple MachineFunction::getDebugLocTuple(DebugLoc DL) const {
+ unsigned Idx = DL.getIndex();
+ assert(Idx < DebugLocInfo.DebugLocations.size() &&
+ "Invalid index into debug locations!");
+ return DebugLocInfo.DebugLocations[Idx];
+}
+
//===----------------------------------------------------------------------===//
// MachineFrameInfo implementation
//===----------------------------------------------------------------------===//
void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{
- int ValOffset = MF.getTarget().getFrameInfo()->getOffsetOfLocalArea();
+ const TargetFrameInfo *FI = MF.getTarget().getFrameInfo();
+ int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0);
for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
const StackObject &SO = Objects[i];
- OS << " <fi #" << (int)(i-NumFixedObjects) << ">: ";
+ OS << " <fi#" << (int)(i-NumFixedObjects) << ">: ";
if (SO.Size == ~0ULL) {
OS << "dead\n";
continue;
return JumpTables.size()-1;
}
+/// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update
+/// the jump tables to branch to New instead.
+bool
+MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,
+ MachineBasicBlock *New) {
+ assert(Old != New && "Not making a change?");
+ bool MadeChange = false;
+ for (size_t i = 0, e = JumpTables.size(); i != e; ++i) {
+ MachineJumpTableEntry &JTE = JumpTables[i];
+ for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
+ if (JTE.MBBs[j] == Old) {
+ JTE.MBBs[j] = New;
+ MadeChange = true;
+ }
+ }
+ return MadeChange;
+}
void MachineJumpTableInfo::print(std::ostream &OS) const {
// FIXME: this is lame, maybe we could print out the MBB numbers or something
// like {1, 2, 4, 5, 3, 0}
for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
- OS << " <jt #" << i << "> has " << JumpTables[i].MBBs.size()
+ OS << " <jt#" << i << "> has " << JumpTables[i].MBBs.size()
<< " entries\n";
}
}
}
/// getConstantPoolIndex - Create a new entry in the constant pool or return
-/// an existing one. User must specify an alignment in bytes for the object.
+/// an existing one. User must specify the log2 of the minimum required
+/// alignment for the object.
///
unsigned MachineConstantPool::getConstantPoolIndex(Constant *C,
unsigned Alignment) {
// Check to see if we already have this constant.
//
// FIXME, this could be made much more efficient for large constant pools.
- unsigned AlignMask = (1 << Alignment)-1;
for (unsigned i = 0, e = Constants.size(); i != e; ++i)
- if (Constants[i].Val.ConstVal == C && (Constants[i].Offset & AlignMask)== 0)
+ if (Constants[i].Val.ConstVal == C &&
+ (Constants[i].getAlignment() & (Alignment - 1)) == 0)
return i;
- unsigned Offset = 0;
- if (!Constants.empty()) {
- Offset = Constants.back().getOffset();
- Offset += TD->getABITypeSize(Constants.back().getType());
- Offset = (Offset+AlignMask)&~AlignMask;
- }
-
- Constants.push_back(MachineConstantPoolEntry(C, Offset));
+ Constants.push_back(MachineConstantPoolEntry(C, Alignment));
return Constants.size()-1;
}
// Check to see if we already have this constant.
//
// FIXME, this could be made much more efficient for large constant pools.
- unsigned AlignMask = (1 << Alignment)-1;
int Idx = V->getExistingMachineCPValue(this, Alignment);
if (Idx != -1)
return (unsigned)Idx;
-
- unsigned Offset = 0;
- if (!Constants.empty()) {
- Offset = Constants.back().getOffset();
- Offset += TD->getABITypeSize(Constants.back().getType());
- Offset = (Offset+AlignMask)&~AlignMask;
- }
-
- Constants.push_back(MachineConstantPoolEntry(V, Offset));
+
+ Constants.push_back(MachineConstantPoolEntry(V, Alignment));
return Constants.size()-1;
}
-
-void MachineConstantPool::print(std::ostream &OS) const {
+void MachineConstantPool::print(raw_ostream &OS) const {
for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
- OS << " <cp #" << i << "> is";
+ OS << " <cp#" << i << "> is";
if (Constants[i].isMachineConstantPoolEntry())
Constants[i].Val.MachineCPVal->print(OS);
else
OS << *(Value*)Constants[i].Val.ConstVal;
- OS << " , offset=" << Constants[i].getOffset();
+ OS << " , alignment=" << Constants[i].getAlignment();
OS << "\n";
}
}
-void MachineConstantPool::dump() const { print(*cerr.stream()); }
+void MachineConstantPool::dump() const { print(errs()); }
projects / oota-llvm.git / blobdiff