lib/Bytecode/Writer/WriterInternals.h

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