Bitcode streaming

include/llvm/Bitcode/ReaderWriter.h

 //===-- llvm/Bitcode/ReaderWriter.h - Bitcode reader/writers ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header defines interfaces to read and write LLVM bitcode files/streams.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_H
 #define LLVM_BITCODE_H
 
+#include "llvm/Bitcode/BitcodeStream.h"
 #include <string>
 
 namespace llvm {
   class Module;
   class MemoryBuffer;
   class ModulePass;
   class BitstreamWriter;
   class LLVMContext;
   class raw_ostream;
-  
+
   /// getLazyBitcodeModule - Read the header of the specified bitcode buffer
   /// and prepare for lazy deserialization of function bodies.  If successful,
   /// this takes ownership of 'buffer' and returns a non-null pointer.  On
   /// error, this returns null, *does not* take ownership of Buffer, and fills
   /// in *ErrMsg with an error description if ErrMsg is non-null.
   Module *getLazyBitcodeModule(MemoryBuffer *Buffer,
                                LLVMContext& Context,
                                std::string *ErrMsg = 0);
 
+  /// getStreamedBitcodeModule - Read the header of the specified stream
+  /// and prepare for lazy deserialization and streaming of function bodies.
+  /// On error, this returns null, and fills
+  /// in *ErrMsg with an error description if ErrMsg is non-null.

[nlewycky, 2011/11/05 00:45:06]

Reflow text.

[(google.com) Derek Schuff, 2011/11/07 22:33:50]

Done.

+  Module *getStreamedBitcodeModule(const std::string &name,
+                               BitcodeStreamer* streamer,

[nlewycky, 2011/11/05 00:45:06]

Fix indent.

[(google.com) Derek Schuff, 2011/11/07 22:33:50]

Done.

+                               LLVMContext& Context,
+                               std::string *ErrMsg = 0);
+
   /// getBitcodeTargetTriple - Read the header of the specified bitcode
   /// buffer and extract just the triple information. If successful,
   /// this returns a string and *does not* take ownership
   /// of 'buffer'. On error, this returns "", and fills in *ErrMsg
   /// if ErrMsg is non-null.
   std::string getBitcodeTargetTriple(MemoryBuffer *Buffer,
                                      LLVMContext& Context,
                                      std::string *ErrMsg = 0);
 
   /// ParseBitcodeFile - Read the specified bitcode file, returning the module.
@@ skipping 60 matching lines @@
   ///   uint32_t Magic;         // 0x0B17C0DE
   ///   uint32_t Version;       // Version, currently always 0.
   ///   uint32_t BitcodeOffset; // Offset to traditional bitcode file.
   ///   uint32_t BitcodeSize;   // Size of traditional bitcode file.
   ///   ... potentially other gunk ...
   /// };
   /// 
   /// This function is called when we find a file with a matching magic number.
   /// In this case, skip down to the subsection of the file that is actually a
   /// BC file.
-  static inline bool SkipBitcodeWrapperHeader(unsigned char *&BufPtr,
-                                              unsigned char *&BufEnd) {
+  /// If 'verify' is true, check that the file fits in the buffer.

[nlewycky, 2011/11/05 00:45:06]

How does the caller tell whether we returned successful because we actually
skipped or because it didn't fit?

[(google.com) Derek Schuff, 2011/11/07 22:33:50]

I'm not sure I understand the question.
Before it returned unsuccessful if the buffer wasn't big enough for the header,
or if the buffer is not big enough for the header-declared size of the file.
Otherwise it returns successful.
The new version skips the 2nd buffer size check because the provided buffer does
not contain all the bitcode. it only returns unsuccessful if the buffer is not
even big enough for the header.

On 2011/11/05 00:45:06, nlewycky wrote:

+  static inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr,
+                                              const unsigned char *&BufEnd,
+                                              bool Verify) {
     enum {
       KnownHeaderSize = 4*4,  // Size of header we read.
       OffsetField = 2*4,      // Offset in bytes to Offset field.
       SizeField = 3*4         // Offset in bytes to Size field.
     };
     
     // Must contain the header!
     if (BufEnd-BufPtr < KnownHeaderSize) return true;
     
     unsigned Offset = ( BufPtr[OffsetField  ]        |
                        (BufPtr[OffsetField+1] << 8)  |
                        (BufPtr[OffsetField+2] << 16) |
                        (BufPtr[OffsetField+3] << 24));
     unsigned Size   = ( BufPtr[SizeField    ]        |
                        (BufPtr[SizeField  +1] << 8)  |
                        (BufPtr[SizeField  +2] << 16) |
                        (BufPtr[SizeField  +3] << 24));
     
     // Verify that Offset+Size fits in the file.
-    if (Offset+Size > unsigned(BufEnd-BufPtr))
+    if (Verify && Offset+Size > unsigned(BufEnd-BufPtr))
       return true;
     BufPtr += Offset;
     BufEnd = BufPtr+Size;
     return false;
   }
 } // End llvm namespace
 
 #endif