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 #include <deque>
  21
  22 class BytecodeWriter {
  23   std::deque<unsigned char> &Out;
  24   SlotCalculator Table;
  25 public:
  26   BytecodeWriter(std::deque<unsigned char> &o, const Module *M);
  27
  28 protected:
  29   void outputConstants(bool isMethod);
  30   void processMethod(const Function *F);
  31   void processBasicBlock(const BasicBlock *BB);
  32   void 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 Constant *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   std::deque<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, std::deque<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 = "
  68     //     << (NewLoc-Loc) << endl;
  69     output((unsigned)(Out.size()-Loc), Out, (int)Loc-4);
  70     align32(Out);  // Blocks must ALWAYS be aligned
  71   }
  72 };
  73
  74
  75 #endif