//===-- MachineFunction.cpp -----------------------------------------------===//
//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+//
// Collect native machine code information for a function. This allows
// target-specific information about the generated code to be stored with each
// function.
//
//===----------------------------------------------------------------------===//
-#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/SSARegMap.h"
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/CodeGen/Passes.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetFrameInfo.h"
-#include "llvm/Target/TargetCacheInfo.h"
#include "llvm/Function.h"
#include "llvm/iOther.h"
-#include "llvm/Pass.h"
-#include <limits.h>
-
-const int INVALID_FRAME_OFFSET = INT_MAX; // std::numeric_limits<int>::max();
+using namespace llvm;
static AnnotationID MF_AID(
AnnotationManager::getID("CodeGen::MachineCodeForFunction"));
-//===---------------------------------------------------------------------===//
-// Code generation/destruction passes
-//===---------------------------------------------------------------------===//
-
namespace {
- class ConstructMachineFunction : public FunctionPass {
- TargetMachine &Target;
- public:
- ConstructMachineFunction(TargetMachine &T) : Target(T) {}
-
- const char *getPassName() const {
- return "ConstructMachineFunction";
- }
-
- bool runOnFunction(Function &F) {
- MachineFunction::construct(&F, Target).getInfo()->CalculateArgSize();
- return false;
- }
- };
+ struct Printer : public MachineFunctionPass {
+ std::ostream *OS;
+ const std::string Banner;
- struct DestroyMachineFunction : public FunctionPass {
- const char *getPassName() const { return "FreeMachineFunction"; }
-
- static void freeMachineCode(Instruction &I) {
- MachineCodeForInstruction::destroy(&I);
- }
-
- bool runOnFunction(Function &F) {
- for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI)
- for (BasicBlock::iterator I = FI->begin(), E = FI->end(); I != E; ++I)
- MachineCodeForInstruction::get(I).dropAllReferences();
-
- for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI)
- for_each(FI->begin(), FI->end(), freeMachineCode);
-
- return false;
- }
- };
+ Printer (std::ostream *_OS, const std::string &_Banner) :
+ OS (_OS), Banner (_Banner) { }
- struct Printer : public FunctionPass {
const char *getPassName() const { return "MachineFunction Printer"; }
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
}
- bool runOnFunction(Function &F) {
- MachineFunction::get(&F).dump();
+ bool runOnMachineFunction(MachineFunction &MF) {
+ (*OS) << Banner;
+ MF.print (*OS);
return false;
}
};
}
-Pass *createMachineCodeConstructionPass(TargetMachine &Target) {
- return new ConstructMachineFunction(Target);
+/// Returns a newly-created MachineFunction Printer pass. The default output
+/// stream is std::cerr; the default banner is empty.
+///
+FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS,
+ const std::string &Banner) {
+ return new Printer(OS, Banner);
}
-Pass *createMachineCodeDestructionPass() {
- return new DestroyMachineFunction();
+namespace {
+ struct Deleter : public MachineFunctionPass {
+ const char *getPassName() const { return "Machine Code Deleter"; }
+
+ bool runOnMachineFunction(MachineFunction &MF) {
+ // Delete the annotation from the function now.
+ MachineFunction::destruct(MF.getFunction());
+ return true;
+ }
+ };
}
-Pass *createMachineFunctionPrinterPass() {
- return new Printer();
+/// MachineCodeDeletion Pass - This pass deletes all of the machine code for
+/// the current function, which should happen after the function has been
+/// emitted to a .s file or to memory.
+FunctionPass *llvm::createMachineCodeDeleter() {
+ return new Deleter();
}
+
//===---------------------------------------------------------------------===//
// MachineFunction implementation
//===---------------------------------------------------------------------===//
void MachineFunction::dump() const { print(std::cerr); }
void MachineFunction::print(std::ostream &OS) const {
- OS << "\n" << *(Value*)Fn->getFunctionType() << " \"" << Fn->getName()
- << "\"\n";
+ OS << "# Machine code for " << Fn->getName () << "():\n";
// Print Frame Information
getFrameInfo()->print(*this, OS);
// Print Constant Pool
getConstantPool()->print(OS);
- for (const_iterator BB = begin(); BB != end(); ++BB) {
- BasicBlock *LBB = BB->getBasicBlock();
- OS << "\n" << LBB->getName() << " (" << (const void*)LBB << "):\n";
- for (MachineBasicBlock::const_iterator I = BB->begin(); I != BB->end();++I){
- OS << "\t";
- (*I)->print(OS, Target);
- }
- }
- OS << "\nEnd function \"" << Fn->getName() << "\"\n\n";
-}
+ for (const_iterator BB = begin(); BB != end(); ++BB)
+ BB->print(OS);
+ OS << "\n# End machine code for " << Fn->getName () << "().\n\n";
+}
// The next two methods are used to construct and to retrieve
// the MachineCodeForFunction object for the given function.
return *mcInfo;
}
-void
-MachineFunction::destruct(const Function *Fn)
-{
+void MachineFunction::destruct(const Function *Fn) {
bool Deleted = Fn->deleteAnnotation(MF_AID);
assert(Deleted && "Machine code did not exist for function!");
}
for (Function::const_iterator BB = F->begin(), BBE = F->end(); BB !=BBE; ++BB)
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
- if (const CallInst *callInst = dyn_cast<CallInst>(&*I))
+ if (const CallInst *callInst = dyn_cast<CallInst>(I))
{
unsigned numOperands = callInst->getNumOperands() - 1;
int numExtra = (int)numOperands-frameInfo.getNumFixedOutgoingArgs();
inline unsigned
SizeToAlignment(unsigned size, const TargetMachine& target)
{
- unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1);
+ const unsigned short cacheLineSize = 16;
if (size > (unsigned) cacheLineSize / 2)
return cacheLineSize;
else
return aligned;
}
-int
-MachineFunctionInfo::allocateLocalVar(const Value* val,
- unsigned sizeToUse)
-{
+
+int MachineFunctionInfo::allocateLocalVar(const Value* val,
+ unsigned sizeToUse) {
assert(! automaticVarsAreaFrozen &&
"Size of auto vars area has been used to compute an offset so "
"no more automatic vars should be allocated!");
// Check if we've allocated a stack slot for this value already
//
- int offset = getOffset(val);
- if (offset == INVALID_FRAME_OFFSET)
- {
- unsigned getPaddedSize;
- offset = computeOffsetforLocalVar(val, getPaddedSize, sizeToUse);
- offsets[val] = offset;
- incrementAutomaticVarsSize(getPaddedSize);
- }
+ hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
+ if (pair != offsets.end())
+ return pair->second;
+
+ unsigned getPaddedSize;
+ unsigned offset = computeOffsetforLocalVar(val, getPaddedSize, sizeToUse);
+ offsets[val] = offset;
+ incrementAutomaticVarsSize(getPaddedSize);
return offset;
}
resetTmpAreaSize(); // clear tmp area to reuse
}
-int
-MachineFunctionInfo::getOffset(const Value* val) const
-{
- hash_map<const Value*, int>::const_iterator pair = offsets.find(val);
- return (pair == offsets.end()) ? INVALID_FRAME_OFFSET : pair->second;
-}