Line data    Source code

       1             : //===-- llvm/CodeGen/ByteStreamer.h - ByteStreamer class --------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file contains a class that can take bytes that would normally be
      11             : // streamed via the AsmPrinter.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_BYTESTREAMER_H
      16             : #define LLVM_LIB_CODEGEN_ASMPRINTER_BYTESTREAMER_H
      17             : 
      18             : #include "DIEHash.h"
      19             : #include "llvm/CodeGen/AsmPrinter.h"
      20             : #include "llvm/MC/MCStreamer.h"
      21             : #include "llvm/Support/LEB128.h"
      22             : #include <string>
      23             : 
      24             : namespace llvm {
      25             : class ByteStreamer {
      26             :  protected:
      27             :   ~ByteStreamer() = default;
      28             :   ByteStreamer(const ByteStreamer&) = default;
      29             :   ByteStreamer() = default;
      30             : 
      31             :  public:
      32             :   // For now we're just handling the calls we need for dwarf emission/hashing.
      33             :   virtual void EmitInt8(uint8_t Byte, const Twine &Comment = "") = 0;
      34             :   virtual void EmitSLEB128(uint64_t DWord, const Twine &Comment = "") = 0;
      35             :   virtual void EmitULEB128(uint64_t DWord, const Twine &Comment = "") = 0;
      36             : };
      37             : 
      38             : class APByteStreamer final : public ByteStreamer {
      39             : private:
      40             :   AsmPrinter &AP;
      41             : 
      42             : public:
      43       85397 :   APByteStreamer(AsmPrinter &Asm) : AP(Asm) {}
      44      143845 :   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
      45      287690 :     AP.OutStreamer->AddComment(Comment);
      46      143845 :     AP.emitInt8(Byte);
      47      143845 :   }
      48           0 :   void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
      49           0 :     AP.OutStreamer->AddComment(Comment);
      50           0 :     AP.EmitSLEB128(DWord);
      51           0 :   }
      52           0 :   void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
      53           0 :     AP.OutStreamer->AddComment(Comment);
      54           0 :     AP.EmitULEB128(DWord);
      55           0 :   }
      56             : };
      57             : 
      58             : class HashingByteStreamer final : public ByteStreamer {
      59             :  private:
      60             :   DIEHash &Hash;
      61             :  public:
      62           3 :  HashingByteStreamer(DIEHash &H) : Hash(H) {}
      63           7 :   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
      64           7 :     Hash.update(Byte);
      65           7 :   }
      66           0 :   void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
      67           0 :     Hash.addSLEB128(DWord);
      68           0 :   }
      69           0 :   void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
      70           0 :     Hash.addULEB128(DWord);
      71           0 :   }
      72             : };
      73             : 
      74             : class BufferByteStreamer final : public ByteStreamer {
      75             : private:
      76             :   SmallVectorImpl<char> &Buffer;
      77             :   SmallVectorImpl<std::string> &Comments;
      78             : 
      79             :   /// Only verbose textual output needs comments.  This will be set to
      80             :   /// true for that case, and false otherwise.  If false, comments passed in to
      81             :   /// the emit methods will be ignored.
      82             :   bool GenerateComments;
      83             : 
      84             : public:
      85             :   BufferByteStreamer(SmallVectorImpl<char> &Buffer,
      86             :                      SmallVectorImpl<std::string> &Comments,
      87             :                      bool GenerateComments)
      88       85416 :   : Buffer(Buffer), Comments(Comments), GenerateComments(GenerateComments) {}
      89      106256 :   void EmitInt8(uint8_t Byte, const Twine &Comment) override {
      90      106256 :     Buffer.push_back(Byte);
      91      106256 :     if (GenerateComments)
      92         686 :       Comments.push_back(Comment.str());
      93      106256 :   }
      94       20180 :   void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
      95       20180 :     raw_svector_ostream OSE(Buffer);
      96       20180 :     unsigned Length = encodeSLEB128(DWord, OSE);
      97       20180 :     if (GenerateComments) {
      98         126 :       Comments.push_back(Comment.str());
      99             :       // Add some empty comments to keep the Buffer and Comments vectors aligned
     100             :       // with each other.
     101          64 :       for (size_t i = 1; i < Length; ++i)
     102           2 :         Comments.push_back("");
     103             : 
     104             :     }
     105       20180 :   }
     106        4823 :   void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
     107        4823 :     raw_svector_ostream OSE(Buffer);
     108        4823 :     unsigned Length = encodeULEB128(DWord, OSE);
     109        4823 :     if (GenerateComments) {
     110          74 :       Comments.push_back(Comment.str());
     111             :       // Add some empty comments to keep the Buffer and Comments vectors aligned
     112             :       // with each other.
     113          51 :       for (size_t i = 1; i < Length; ++i)
     114          28 :         Comments.push_back("");
     115             : 
     116             :     }
     117        4823 :   }
     118             : };
     119             : 
     120             : }
     121             : 
     122             : #endif