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/SlotCalculator.h"
  19 #include "llvm/Instruction.h"
  20
  21 class BytecodeWriter {
  22   std::deque<unsigned char> &Out;
  23   SlotCalculator Table;
  24 public:
  25   BytecodeWriter(std::deque<unsigned char> &o, const Module *M);
  26
  27 protected:
  28   void outputConstants(bool isMethod);
  29   void processMethod(const Function *F);
  30   void processBasicBlock(const BasicBlock &BB);
  31   void processInstruction(const Instruction &I);
  32
  33 private :
  34   inline void outputSignature() {
  35     static const unsigned char *Sig =  (const unsigned char*)"llvm";
  36     Out.insert(Out.end(), Sig, Sig+4); // output the bytecode signature...
  37   }
  38
  39   void outputModuleInfoBlock(const Module *C);
  40   void outputSymbolTable(const SymbolTable &ST);
  41   bool outputConstant(const Constant *CPV);
  42   void outputType(const Type *T);
  43 };
  44
  45
  46
  47
  48 // BytecodeBlock - Little helper class that helps us do backpatching of bytecode
  49 // block sizes really easily.  It backpatches when it goes out of scope.
  50 //
  51 class BytecodeBlock {
  52   unsigned Loc;
  53   std::deque<unsigned char> &Out;
  54
  55   BytecodeBlock(const BytecodeBlock &);   // do not implement
  56   void operator=(const BytecodeBlock &);  // do not implement
  57 public:
  58   inline BytecodeBlock(unsigned ID, std::deque<unsigned char> &o) : Out(o) {
  59     output(ID, Out);
  60     output((unsigned)0, Out);         // Reserve the space for the block size...
  61     Loc = Out.size();
  62   }
  63
  64   inline ~BytecodeBlock() {           // Do backpatch when block goes out
  65                                       // of scope...
  66     //cerr << "OldLoc = " << Loc << " NewLoc = " << NewLoc << " diff = "
  67     //     << (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