diff options
Diffstat (limited to 'lib/VMCore/AsmWriter.cpp')
-rw-r--r-- | lib/VMCore/AsmWriter.cpp | 328 |
1 files changed, 328 insertions, 0 deletions
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp new file mode 100644 index 0000000000..e23403b0d0 --- /dev/null +++ b/lib/VMCore/AsmWriter.cpp @@ -0,0 +1,328 @@ +//===-- Writer.cpp - Library for Printing VM assembly files ------*- C++ -*--=// +// +// This library implements the functionality defined in llvm/Assembly/Writer.h +// +// This library uses the Analysis library to figure out offsets for +// variables in the method tables... +// +// TODO: print out the type name instead of the full type if a particular type +// is in the symbol table... +// +//===----------------------------------------------------------------------===// + +#include "llvm/Assembly/Writer.h" +#include "llvm/Analysis/SlotCalculator.h" +#include "llvm/Module.h" +#include "llvm/Method.h" +#include "llvm/BasicBlock.h" +#include "llvm/ConstPoolVals.h" +#include "llvm/iOther.h" +#include "llvm/iMemory.h" + +class AssemblyWriter : public ModuleAnalyzer { + ostream &Out; + SlotCalculator &Table; +public: + inline AssemblyWriter(ostream &o, SlotCalculator &Tab) : Out(o), Table(Tab) { + } + + inline void write(const Module *M) { processModule(M); } + inline void write(const Method *M) { processMethod(M); } + inline void write(const BasicBlock *BB) { processBasicBlock(BB); } + inline void write(const Instruction *I) { processInstruction(I); } + inline void write(const ConstPoolVal *CPV) { processConstant(CPV); } + +protected: + virtual bool visitMethod(const Method *M); + virtual bool processConstPool(const ConstantPool &CP, bool isMethod); + virtual bool processConstant(const ConstPoolVal *CPV); + virtual bool processMethod(const Method *M); + virtual bool processMethodArgument(const MethodArgument *MA); + virtual bool processBasicBlock(const BasicBlock *BB); + virtual bool processInstruction(const Instruction *I); + +private : + void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); +}; + + + +// visitMethod - This member is called after the above two steps, visting each +// method, because they are effectively values that go into the constant pool. +// +bool AssemblyWriter::visitMethod(const Method *M) { + return false; +} + +bool AssemblyWriter::processConstPool(const ConstantPool &CP, bool isMethod) { + // Done printing arguments... + if (isMethod) Out << ")\n"; + + ModuleAnalyzer::processConstPool(CP, isMethod); + + if (isMethod) + Out << "begin"; + else + Out << "implementation\n"; + return false; +} + + +// processConstant - Print out a constant pool entry... +// +bool AssemblyWriter::processConstant(const ConstPoolVal *CPV) { + Out << "\t"; + + // Print out name if it exists... + if (CPV->hasName()) + Out << "%" << CPV->getName() << " = "; + + // Print out the opcode... + Out << CPV->getType(); + + // Write the value out now... + writeOperand(CPV, false, false); + + if (!CPV->hasName() && CPV->getType() != Type::VoidTy) { + int Slot = Table.getValSlot(CPV); // Print out the def slot taken... + Out << "\t\t; <" << CPV->getType() << ">:"; + if (Slot >= 0) Out << Slot; + else Out << "<badref>"; + } + + Out << endl; + return false; +} + +// processMethod - Process all aspects of a method. +// +bool AssemblyWriter::processMethod(const Method *M) { + // Print out the return type and name... + Out << "\n" << M->getReturnType() << " \"" << M->getName() << "\"("; + Table.incorporateMethod(M); + ModuleAnalyzer::processMethod(M); + Table.purgeMethod(); + Out << "end\n"; + return false; +} + +// processMethodArgument - This member is called for every argument that +// is passed into the method. Simply print it out +// +bool AssemblyWriter::processMethodArgument(const MethodArgument *Arg) { + // Insert commas as we go... the first arg doesn't get a comma + if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", "; + + // Output type... + Out << Arg->getType(); + + // Output name, if available... + if (Arg->hasName()) + Out << " %" << Arg->getName(); + else if (Table.getValSlot(Arg) < 0) + Out << "<badref>"; + + return false; +} + +// processBasicBlock - This member is called for each basic block in a methd. +// +bool AssemblyWriter::processBasicBlock(const BasicBlock *BB) { + if (BB->hasName()) { // Print out the label if it exists... + Out << "\n" << BB->getName() << ":\n"; + } else { + int Slot = Table.getValSlot(BB); + Out << "\t\t\t\t; <label>:"; + if (Slot >= 0) + Out << Slot << endl; // Extra newline seperates out label's + else + Out << "<badref>\n"; + } + + ModuleAnalyzer::processBasicBlock(BB); + return false; +} + +// processInstruction - This member is called for each Instruction in a methd. +// +bool AssemblyWriter::processInstruction(const Instruction *I) { + Out << "\t"; + + // Print out name if it exists... + if (I && I->hasName()) + Out << "%" << I->getName() << " = "; + + // Print out the opcode... + Out << I->getOpcode(); + + // Print out the type of the operands... + const Value *Operand = I->getOperand(0); + + // Special case conditional branches to swizzle the condition out to the front + if (I->getInstType() == Instruction::Br && I->getOperand(1)) { + writeOperand(I->getOperand(2), true); + Out << ","; + writeOperand(Operand, true); + Out << ","; + writeOperand(I->getOperand(1), true); + + } else if (I->getInstType() == Instruction::Switch) { + // Special case switch statement to get formatting nice and correct... + writeOperand(Operand , true); Out << ","; + writeOperand(I->getOperand(1), true); Out << " ["; + + for (unsigned op = 2; (Operand = I->getOperand(op)); op += 2) { + Out << "\n\t\t"; + writeOperand(Operand, true); Out << ","; + writeOperand(I->getOperand(op+1), true); + } + Out << "\n\t]"; + + } else if (I->getInstType() == Instruction::Ret && !Operand) { + Out << " void"; + } else if (I->getInstType() == Instruction::Call) { + writeOperand(Operand, true); + Out << "("; + Operand = I->getOperand(1); + if (Operand) writeOperand(Operand, true); + for (unsigned op = 2; (Operand = I->getOperand(op)); ++op) { + Out << ","; + writeOperand(Operand, true); + } + + Out << " )"; + } else if (I->getInstType() == Instruction::Malloc || + I->getInstType() == Instruction::Alloca) { + Out << " " << ((const PointerType*)((ConstPoolType*)Operand) + ->getValue())->getValueType(); + if ((Operand = I->getOperand(1))) { + Out << ","; writeOperand(Operand, true); + } + + } else if (Operand) { // Print the normal way... + + // PrintAllTypes - Instructions who have operands of all the same type + // omit the type from all but the first operand. If the instruction has + // different type operands (for example br), then they are all printed. + bool PrintAllTypes = false; + const Type *TheType = Operand->getType(); + unsigned i; + + for (i = 1; (Operand = I->getOperand(i)); i++) { + if (Operand->getType() != TheType) { + PrintAllTypes = true; // We have differing types! Print them all! + break; + } + } + + if (!PrintAllTypes) + Out << " " << I->getOperand(0)->getType(); + + for (unsigned i = 0; (Operand = I->getOperand(i)); i++) { + if (i) Out << ","; + writeOperand(Operand, PrintAllTypes); + } + } + + // Print a little comment after the instruction indicating which slot it + // occupies. + // + if (!I->hasName() && I->getType() != Type::VoidTy) { + int Slot = Table.getValSlot(I); // Print out the def slot taken... + Out << "\t\t; <" << I->getType() << ">:"; + if (Slot >= 0) Out << Slot; + else Out << "<badref>"; + + Out << "\t[#uses=" << I->use_size() << "]"; // Output # uses + } + + Out << endl; + + return false; +} + + +void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, + bool PrintName) { + if (PrintType) + Out << " " << Operand->getType(); + + if (Operand->hasName() && PrintName) { + Out << " %" << Operand->getName(); + } else { + int Slot = Table.getValSlot(Operand); + + if (Operand->getValueType() == Value::ConstantVal) { + Out << " " << ((ConstPoolVal*)Operand)->getStrValue(); + } else { + if (Slot >= 0) Out << " %" << Slot; + else if (PrintName) + Out << "<badref>"; // Not embeded into a location? + } + } +} + + +//===----------------------------------------------------------------------===// +// External Interface declarations +//===----------------------------------------------------------------------===// + + + +void WriteToAssembly(const Module *M, ostream &o) { + if (M == 0) { o << "<null> module\n"; return; } + SlotCalculator SlotTable(M, true); + AssemblyWriter W(o, SlotTable); + + W.write(M); +} + +void WriteToAssembly(const Method *M, ostream &o) { + if (M == 0) { o << "<null> method\n"; return; } + SlotCalculator SlotTable(M->getParent(), true); + AssemblyWriter W(o, SlotTable); + + W.write(M); +} + + +void WriteToAssembly(const BasicBlock *BB, ostream &o) { + if (BB == 0) { o << "<null> basic block\n"; return; } + + SlotCalculator SlotTable(BB->getParent(), true); + AssemblyWriter W(o, SlotTable); + + W.write(BB); +} + +void WriteToAssembly(const ConstPoolVal *CPV, ostream &o) { + if (CPV == 0) { o << "<null> constant pool value\n"; return; } + + SlotCalculator *SlotTable; + + // A Constant pool value may have a parent that is either a method or a + // module. Untangle this now... + // + if (CPV->getParent() == 0 || + CPV->getParent()->getValueType() == Value::MethodVal) { + SlotTable = new SlotCalculator((Method*)CPV->getParent(), true); + } else { + assert(CPV->getParent()->getValueType() == Value::ModuleVal); + SlotTable = new SlotCalculator((Module*)CPV->getParent(), true); + } + + AssemblyWriter W(o, *SlotTable); + W.write(CPV); + + delete SlotTable; +} + +void WriteToAssembly(const Instruction *I, ostream &o) { + if (I == 0) { o << "<null> instruction\n"; return; } + + SlotCalculator SlotTable(I->getParent() ? I->getParent()->getParent() : 0, + true); + AssemblyWriter W(o, SlotTable); + + W.write(I); +} |