Line data    Source code

       1             : //===- SmallVectorMemoryBuffer.h --------------------------------*- 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 declares a wrapper class to hold the memory into which an
      11             : // object will be generated.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_EXECUTIONENGINE_OBJECTMEMORYBUFFER_H
      16             : #define LLVM_EXECUTIONENGINE_OBJECTMEMORYBUFFER_H
      17             : 
      18             : #include "llvm/ADT/SmallVector.h"
      19             : #include "llvm/Support/MemoryBuffer.h"
      20             : #include "llvm/Support/raw_ostream.h"
      21             : 
      22             : namespace llvm {
      23             : 
      24             : /// SmallVector-backed MemoryBuffer instance.
      25             : ///
      26             : /// This class enables efficient construction of MemoryBuffers from SmallVector
      27             : /// instances. This is useful for MCJIT and Orc, where object files are streamed
      28             : /// into SmallVectors, then inspected using ObjectFile (which takes a
      29             : /// MemoryBuffer).
      30             : class SmallVectorMemoryBuffer : public MemoryBuffer {
      31             : public:
      32             :   /// Construct an SmallVectorMemoryBuffer from the given SmallVector
      33             :   /// r-value.
      34             :   ///
      35             :   /// FIXME: It'd be nice for this to be a non-templated constructor taking a
      36             :   /// SmallVectorImpl here instead of a templated one taking a SmallVector<N>,
      37             :   /// but SmallVector's move-construction/assignment currently only take
      38             :   /// SmallVectors. If/when that is fixed we can simplify this constructor and
      39             :   /// the following one.
      40         331 :   SmallVectorMemoryBuffer(SmallVectorImpl<char> &&SV)
      41         662 :       : SV(std::move(SV)), BufferName("<in-memory object>") {
      42         662 :     init(this->SV.begin(), this->SV.end(), false);
      43         330 :   }
      44             : 
      45             :   /// Construct a named SmallVectorMemoryBuffer from the given
      46             :   /// SmallVector r-value and StringRef.
      47             :   SmallVectorMemoryBuffer(SmallVectorImpl<char> &&SV, StringRef Name)
      48             :       : SV(std::move(SV)), BufferName(Name) {
      49             :     init(this->SV.begin(), this->SV.end(), false);
      50             :   }
      51             : 
      52             :   // Key function.
      53             :   ~SmallVectorMemoryBuffer() override;
      54             : 
      55         826 :   StringRef getBufferIdentifier() const override { return BufferName; }
      56             : 
      57           0 :   BufferKind getBufferKind() const override { return MemoryBuffer_Malloc; }
      58             : 
      59             : private:
      60             :   SmallVector<char, 0> SV;
      61             :   std::string BufferName;
      62             : };
      63             : 
      64             : } // namespace llvm
      65             : 
      66             : #endif