blob: f64c60377ca5bad18cd8d2d101ed20b4be773321 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
//===-- X86/Printer.cpp - Convert X86 code to human readable rep. ---------===//
//
// This file contains a printer that converts from our internal representation
// of LLVM code to a nice human readable form that is suitable for debuggging.
//
//===----------------------------------------------------------------------===//
#include "X86.h"
#include "X86InstrInfo.h"
#include "llvm/Pass.h"
#include "llvm/Function.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
namespace {
struct Printer : public FunctionPass {
TargetMachine &TM;
std::ostream &O;
Printer(TargetMachine &tm, std::ostream &o) : TM(tm), O(o) {}
bool runOnFunction(Function &F);
};
}
/// createX86CodePrinterPass - Print out the specified machine code function to
/// the specified stream. This function should work regardless of whether or
/// not the function is in SSA form or not.
///
Pass *createX86CodePrinterPass(TargetMachine &TM, std::ostream &O) {
return new Printer(TM, O);
}
/// runOnFunction - This uses the X86InstructionInfo::print method
/// to print assembly for each instruction.
bool Printer::runOnFunction (Function & F)
{
static unsigned bbnumber = 0;
MachineFunction & MF = MachineFunction::get (&F);
const MachineInstrInfo & MII = TM.getInstrInfo ();
O << "; x86 printing only sorta implemented so far!\n";
// Print out labels for the function.
O << "\t.globl\t" << F.getName () << "\n";
O << "\t.type\t" << F.getName () << ", @function\n";
O << F.getName () << ":\n";
// Print out code for the function.
for (MachineFunction::const_iterator bb_i = MF.begin (), bb_e = MF.end ();
bb_i != bb_e; ++bb_i)
{
// Print a label for the basic block.
O << ".BB" << bbnumber++ << ":\n";
for (MachineBasicBlock::const_iterator i_i = bb_i->begin (), i_e =
bb_i->end (); i_i != i_e; ++i_i)
{
// Print the assembly for the instruction.
O << "\t";
MII.print(*i_i, O, TM);
}
}
// We didn't modify anything.
return false;
}
// print - Print out an x86 instruction in intel syntax
void X86InstrInfo::print(const MachineInstr *MI, std::ostream &O,
const TargetMachine &TM) const {
// FIXME: This sucks.
O << getName(MI->getOpCode()) << "\n";
}
|
