llvm-6502/lib/Bytecode/Writer/WriterInternals.h
Chris Lattner 009505452b Initial revision
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8
2001-06-06 20:29:01 +00:00

75 lines
2.4 KiB
C++

//===-- WriterInternals.h - Data structures shared by the Writer -*- C++ -*--=//
//
// This header defines the interface used between components of the bytecode
// writer.
//
// Note that the performance of this library is not terribly important, because
// it shouldn't be used by JIT type applications... so it is not a huge focus
// at least. :)
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
#define LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
#include "llvm/Bytecode/Writer.h"
#include "llvm/Bytecode/Format.h"
#include "llvm/Bytecode/Primitives.h"
#include "llvm/Analysis/SlotCalculator.h"
#include "llvm/Tools/DataTypes.h"
#include "llvm/Instruction.h"
class BytecodeWriter : public ModuleAnalyzer {
vector<unsigned char> &Out;
SlotCalculator Table;
public:
BytecodeWriter(vector<unsigned char> &o, const Module *M);
protected:
virtual bool processConstPool(const ConstantPool &CP, bool isMethod);
virtual bool processMethod(const Method *M);
virtual bool processBasicBlock(const BasicBlock *BB);
virtual bool processInstruction(const Instruction *I);
private :
inline void outputSignature() {
static const unsigned char *Sig = (const unsigned char*)"llvm";
Out.insert(Out.end(), Sig, Sig+4); // output the bytecode signature...
}
void outputModuleInfoBlock(const Module *C);
void outputSymbolTable(const SymbolTable &ST);
bool outputConstant(const ConstPoolVal *CPV);
void outputType(const Type *T);
};
// BytecodeBlock - Little helper class that helps us do backpatching of bytecode
// block sizes really easily. It backpatches when it goes out of scope.
//
class BytecodeBlock {
unsigned Loc;
vector<unsigned char> &Out;
BytecodeBlock(const BytecodeBlock &); // do not implement
void operator=(const BytecodeBlock &); // do not implement
public:
inline BytecodeBlock(unsigned ID, vector<unsigned char> &o) : Out(o) {
output(ID, Out);
output((unsigned)0, Out); // Reserve the space for the block size...
Loc = Out.size();
}
inline ~BytecodeBlock() { // Do backpatch when block goes out
// of scope...
// cerr << "OldLoc = " << Loc << " NewLoc = " << NewLoc << " diff = " << (NewLoc-Loc) << endl;
output((unsigned)(Out.size()-Loc), Out, (int)Loc-4);
align32(Out); // Blocks must ALWAYS be aligned
}
};
#endif