PNaCl localmod mods in LLVM to 223109 (local files only)

include/llvm/Bitcode/NaCl/NaClReaderWriter.h

 //===-- llvm/Bitcode/NaCl/NaClReaderWriter.h - ------------------*- C++ -*-===//
 //      NaCl Bitcode reader/writer.
 //
 //                     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 NaCl bitcode wire format
 // files.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_NACL_NACLREADERWRITER_H
 #define LLVM_BITCODE_NACL_NACLREADERWRITER_H
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/MemoryBuffer.h"
 
 #include <string>
 
 namespace llvm {
-  class MemoryBuffer;
   class LLVMContext;
   class Module;
-  class raw_ostream;
   class NaClBitcodeHeader;
   class NaClBitstreamWriter;
   class StreamingMemoryObject;
+  class raw_ostream;
 
   /// Defines the data layout used for PNaCl bitcode files. We set the
   /// data layout of the module in the bitcode readers rather than in
   /// pnacl-llc so that 'opt' will also use the correct data layout if
   /// it is run on a pexe.
   extern const char *PNaClDataLayout;
 
   /// Allows (function) local symbol tables (unsupported) in PNaCl bitcode
   /// files.
   extern cl::opt<bool> PNaClAllowLocalSymbolTables;
 
   /// \brief Defines the integer bit size used to model pointers in PNaCl.
   static const unsigned PNaClIntPtrTypeBitSize = 32;
 
   /// getNaClLazyBitcodeModule - Read the header of the specified bitcode buffer

[jvoung (off chromium), 2015/02/24 18:38:48]

New style seems to be to avoid repeating the function name in comments, so I
also went and deleted them.

   /// and prepare for lazy deserialization of function bodies.  If successful,
   /// takes ownership of 'buffer' and returns a non-null pointer.  On
   /// error, this returns an error code and *does not* take ownership of Buffer.
   ///
   /// When Verbose is non-null, more descriptive error messages are also
   /// written to Verbose.
   ///
   /// The AcceptSupportedOnly argument is used to decide which PNaCl versions
   /// of the PNaCl bitcode to accept. There are three forms:
   ///    1) Readable and supported.
   ///    2) Readable and unsupported. Allows testing of code before becoming
   ///       supported, as well as running experiments on the bitcode format.
   ///    3) Unreadable.
   /// When AcceptSupportedOnly is true, only form 1 is allowed. When
   /// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
-  ErrorOr<Module *> getNaClLazyBitcodeModule(MemoryBuffer *Buffer,
+  ErrorOr<Module *> getNaClLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,

[JF, 2015/02/24 05:35:36]

Linewrap.

Does the function take ownership of the Buf? r-value tells me yes, but doc above
says no.

[jvoung (off chromium), 2015/02/24 18:38:48]

It is conditional/complicated =).  See above comment (before When Verbose is ...
etc.) -- on success it "takes ownership" of the underlying MemoryBuffer and
extends the lifetime and on error it does not extend the lifetime, but since the
unique_ptr goes out of scope I guess it would delete.

Linewrapped.

[JF, 2015/02/24 19:32:55]

That sounds like ownership :-p
The updated documentation clarifies this well.

Is that just because of LLVM's current odd handling of errors?

                                              LLVMContext &Context,
                                              raw_ostream *Verbose = nullptr,
                                              bool AcceptSupportedOnly = true);
 
   /// getNaClStreamedBitcodeModule - 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.
   ///
   /// See getNaClLazyBitcodeModule for an explanation of arguments
   /// Verbose, AcceptSupportedOnly.
   /// TODO(kschimpf): Refactor this and getStreamedBitcodeModule to use
   /// ErrorOr<Module *> API so that all methods have the same interface.
   Module *getNaClStreamedBitcodeModule(const std::string &name,
                                        StreamingMemoryObject *streamer,
                                        LLVMContext &Context,
                                        raw_ostream *Verbose = nullptr,
                                        std::string *ErrMsg = nullptr,
                                        bool AcceptSupportedOnly = true);
 
   /// NaClParseBitcodeFile - Read the specified bitcode file,
-  /// returning the module. This method *never* takes ownership of Buffer.
+  /// returning the module.
   ///
   /// See getNaClLazyBitcodeModule for an explanation of arguments
   /// Verbose, AcceptSupportedOnly.
-  ErrorOr<Module *> NaClParseBitcodeFile(MemoryBuffer *Buffer,
+  ErrorOr<Module *> NaClParseBitcodeFile(MemoryBufferRef Buffer,
                                          LLVMContext &Context,
                                          raw_ostream *Verbose = nullptr,
                                          bool AcceptSupportedOnly = true);
 
   /// NaClWriteBitcodeToFile - Write the specified module to the
   /// specified raw output stream, using PNaCl wire format.  For
   /// streams where it matters, the given stream should be in "binary"
   /// mode.
   ///
   /// The AcceptSupportedOnly argument is used to decide which PNaCl versions
@@ skipping 30 matching lines @@
 
   /// NaClObjDump - Read PNaCl bitcode file from input, and print a
   /// textual representation of its contents. NoRecords and NoAssembly
   /// define what should not be included in the dump. Note: The caller
   /// retains ownership of the Input memory buffer.
   bool NaClObjDump(MemoryBuffer *Input, raw_ostream &output,
                    bool NoRecords, bool NoAssembly);
 
 } // end llvm namespace
 #endif