Changes from 3.7 merge to files not in upstream

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
 //     Low-level bitstream reader interface
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 55 matching lines @@
 
   std::unique_ptr<MemoryObject> BitcodeBytes;
 
   std::vector<BlockInfo> BlockInfoRecords;
 
   /// \brief Holds the offset of the first byte after the header.
   size_t InitialAddress;
 
   // True if filler should be added to byte align records.
   bool AlignBitcodeRecords = false;
+  NaClBitstreamReader(const NaClBitstreamReader&) = delete;
+  void operator=(const NaClBitstreamReader&) = delete;
 
-  NaClBitstreamReader(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
-  void operator=(const NaClBitstreamReader&) LLVM_DELETED_FUNCTION;
 
   void initFromHeader(NaClBitcodeHeader &Header) {
     InitialAddress = Header.getHeaderSize();
     AlignBitcodeRecords = Header.getAlignBitcodeRecords();
   }
 
 public:
   /// Read stream from sequence of bytes [Start .. End) after parsing
   /// the given bitcode header.
   NaClBitstreamReader(const unsigned char *Start, const unsigned char *End,
@@ skipping 102 matching lines @@
 /// NaClBitcodeParser to listen to record details when processing
 /// abbreviations. The major reason for using a listener is that the
 /// NaCl bitcode reader would require a major rewrite (including the
 /// introduction of more overhead) if we were to lift abbreviations up
 /// to the bitcode reader. That is, not only would we have to lift the
 /// block processing up into the readers (i.e. many blocks in
 /// NaClBitcodeReader and NaClBitcodeParser), but add many new API's
 /// to allow the readers to update internals of the bit stream reader
 /// appropriately.
 class NaClAbbrevListener {
-  NaClAbbrevListener(const NaClAbbrevListener&) LLVM_DELETED_FUNCTION;
-  void operator=(const NaClAbbrevListener&) LLVM_DELETED_FUNCTION;
+  NaClAbbrevListener(const NaClAbbrevListener&) = delete;
+  void operator=(const NaClAbbrevListener&) = delete;
 public:
   NaClAbbrevListener() {}
   virtual ~NaClAbbrevListener() {}
 
   /// Called to process the read abbreviation.
   virtual void ProcessAbbreviation(NaClBitCodeAbbrev *Abbrev,
                                    bool IsLocal) = 0;
 
   /// Called after entering block. NumWords is the number of words
   /// in the block.
@@ skipping 74 matching lines @@
     NaClBitcodeSelectorAbbrev PrevCodeSize;
     std::vector<NaClBitCodeAbbrev*> PrevAbbrevs;
     Block() : PrevCodeSize() {}
     explicit Block(const NaClBitcodeSelectorAbbrev& PCS)
         : PrevCodeSize(PCS) {}
   };
 
   /// This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
-  NaClBitstreamCursor(const NaClBitstreamCursor &) LLVM_DELETED_FUNCTION;
-  NaClBitstreamCursor &operator=(const NaClBitstreamCursor &) LLVM_DELETED_FUNCTION;
+  NaClBitstreamCursor(const NaClBitstreamCursor &) = delete;
+  NaClBitstreamCursor &operator=(const NaClBitstreamCursor &) = delete;
 
 public:
   NaClBitstreamCursor() : ErrHandler(new ErrorHandler(*this)) {
     init(nullptr);
   }
 
   explicit NaClBitstreamCursor(NaClBitstreamReader &R)
       : ErrHandler(new ErrorHandler(*this)) { init(&R); }
 
   void init(NaClBitstreamReader *R) {
@@ skipping 370 matching lines @@
   // Skips over an abbreviation record. Duplicates code of ReadAbbrevRecord,
   // except that no abbreviation is built.
   void SkipAbbrevRecord();
   
   bool ReadBlockInfoBlock(NaClAbbrevListener *Listener);
 };
 
 } // End llvm namespace
 
 #endif