include/llvm/Assembly/CachedWriter.h

   1 //===-- llvm/Assembly/CachedWriter.h - Printer Accellerator -----*- 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 file defines a 'CacheWriter' class that is used to accelerate printing
  11 // chunks of LLVM.  This is used when a module is not being changed, but random
  12 // parts of it need to be printed.  This can greatly speed up printing of LLVM
  13 // output.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_ASSEMBLY_CACHED_WRITER_H
  18 #define LLVM_ASSEMBLY_CACHED_WRITER_H
  19
  20 #include "llvm/Value.h"
  21 #include <iostream>
  22
  23 class Module;
  24 class PointerType;
  25 class SlotCalculator;
  26 class AssemblyWriter;  // Internal private class
  27
  28 class CachedWriter {
  29   AssemblyWriter *AW;
  30   SlotCalculator *SC;
  31 public:
  32   std::ostream &Out;
  33 public:
  34   CachedWriter(std::ostream &O = std::cout) : AW(0), SC(0), Out(O) { }
  35   CachedWriter(const Module *M, std::ostream &O = std::cout)
  36     : AW(0), SC(0), Out(O) {
  37     setModule(M);
  38   }
  39   ~CachedWriter();
  40
  41   // setModule - Invalidate internal state, use the new module instead.
  42   void setModule(const Module *M);
  43
  44   CachedWriter &operator<<(const Value *V);
  45
  46   inline CachedWriter &operator<<(Value *X) {
  47     return *this << (const Value*)X;
  48   }
  49   inline CachedWriter &operator<<(const GlobalVariable *X) {
  50     return *this << (const Value*)X;
  51   }
  52   inline CachedWriter &operator<<(const Function *X) {
  53     return *this << (const Value*)X;
  54   }
  55   inline CachedWriter &operator<<(const Argument *X) {
  56     return *this << (const Value*)X;
  57   }
  58   inline CachedWriter &operator<<(const BasicBlock *X) {
  59     return *this << (const Value*)X;
  60   }
  61   inline CachedWriter &operator<<(const Instruction *X) {
  62     return *this << (const Value*)X;
  63   }
  64   inline CachedWriter &operator<<(const Constant *X) {
  65     return *this << (const Value*)X;
  66   }
  67   inline CachedWriter &operator<<(const Type *X) {
  68     return *this << (const Value*)X;
  69   }
  70   inline CachedWriter &operator<<(const PointerType *X) {
  71     return *this << (const Value*)X;
  72   }
  73
  74   inline CachedWriter &operator<<(std::ostream &(&Manip)(std::ostream &)) {
  75     Out << Manip; return *this;
  76   }
  77
  78   template<class X>
  79   inline CachedWriter &operator<<(const X &v) {
  80     Out << v;
  81     return *this;
  82   }
  83 };
  84
  85 #endif