lib/Bytecode/Writer/WriterInternals.h

   1 //===-- WriterInternals.h - Data structures shared by the Writer -*- C++ -*--=//
   2 //
   3 // This header defines the interface used between components of the bytecode
   4 // writer.
   5 //
   6 // Note that the performance of this library is not terribly important, because
   7 // it shouldn't be used by JIT type applications... so it is not a huge focus
   8 // at least.  :)
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #ifndef LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
  13 #define LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
  14
  15 #include "llvm/Bytecode/Writer.h"
  16 #include "llvm/Bytecode/Format.h"
  17 #include "llvm/Bytecode/Primitives.h"
  18 #include "llvm/Analysis/SlotCalculator.h"
  19 #include "llvm/Support/DataTypes.h"
  20 #include "llvm/Instruction.h"
  21
  22 class BytecodeWriter : public ModuleAnalyzer {
  23   vector<unsigned char> &Out;
  24   SlotCalculator Table;
  25 public:
  26   BytecodeWriter(vector<unsigned char> &o, const Module *M);
  27
  28 protected:
  29   virtual bool processConstPool(const ConstantPool &CP, bool isMethod);
  30   virtual bool processMethod(const Method *M);
  31   virtual bool processBasicBlock(const BasicBlock *BB);
  32   virtual bool processInstruction(const Instruction *I);
  33
  34 private :
  35   inline void outputSignature() {
  36     static const unsigned char *Sig =  (const unsigned char*)"llvm";
  37     Out.insert(Out.end(), Sig, Sig+4); // output the bytecode signature...
  38   }
  39
  40   void outputModuleInfoBlock(const Module *C);
  41   void outputSymbolTable(const SymbolTable &ST);
  42   bool outputConstant(const ConstPoolVal *CPV);
  43   void outputType(const Type *T);
  44 };
  45
  46
  47
  48
  49 // BytecodeBlock - Little helper class that helps us do backpatching of bytecode
  50 // block sizes really easily.  It backpatches when it goes out of scope.
  51 //
  52 class BytecodeBlock {
  53   unsigned Loc;
  54   vector<unsigned char> &Out;
  55
  56   BytecodeBlock(const BytecodeBlock &);   // do not implement
  57   void operator=(const BytecodeBlock &);  // do not implement
  58 public:
  59   inline BytecodeBlock(unsigned ID, vector<unsigned char> &o) : Out(o) {
  60     output(ID, Out);
  61     output((unsigned)0, Out);         // Reserve the space for the block size...
  62     Loc = Out.size();
  63   }
  64
  65   inline ~BytecodeBlock() {           // Do backpatch when block goes out
  66                                       // of scope...
  67     //    cerr << "OldLoc = " << Loc << " NewLoc = " << NewLoc << " diff = " << (NewLoc-Loc) << endl;
  68     output((unsigned)(Out.size()-Loc), Out, (int)Loc-4);
  69     align32(Out);  // Blocks must ALWAYS be aligned
  70   }
  71 };
  72
  73
  74 #endif