Changes from 3.7 merge to files not in upstream

lib/Bitcode/NaCl/Analysis/NaClCompress.cpp

 //===-- NaClCompress.cpp - Bitcode (abbrev) compression -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Analyzes the data in memory buffer, and determines what
@@ skipping 447 matching lines @@
     Abbrevs = new BlockAbbrevs(BlockID);
     AbbrevsMap[BlockID] = Abbrevs;
   }
   return Abbrevs;
 }
 
 /// Parses the bitcode file, analyzes it, and generates the
 /// corresponding lists of global abbreviations to use in the
 /// generated (compressed) bitcode file.
 class NaClAnalyzeParser : public NaClBitcodeParser {
-  NaClAnalyzeParser(const NaClAnalyzeParser&)
-      LLVM_DELETED_FUNCTION;
-  void operator=(const NaClAnalyzeParser&)
-      LLVM_DELETED_FUNCTION;
+  NaClAnalyzeParser(const NaClAnalyzeParser&) = delete;
+  void operator=(const NaClAnalyzeParser&) = delete;
 
 public:
   // Creates the analysis parser, which will fill the given
   // BlockAbbrevsMap with appropriate abbreviations, after
   // analyzing the bitcode file defined by Cursor.
   NaClAnalyzeParser(const NaClBitcodeCompressor::CompressFlags &Flags,
                     NaClBitstreamCursor &Cursor,
                     BlockAbbrevsMapType &BlockAbbrevsMap)
       : NaClBitcodeParser(Cursor), Flags(Flags),
         BlockAbbrevsMap(BlockAbbrevsMap),
@@ skipping 14 matching lines @@
   BlockAbbrevsMapType &BlockAbbrevsMap;
 
   // Nested distribution capturing distribution of records in bitcode file.
   NaClBitcodeBlockDist BlockDist;
 
   // Listener used to get abbreviations as they are read.
   NaClBitcodeParserListener AbbrevListener;
 };
 
 class NaClBlockAnalyzeParser : public NaClBitcodeParser {
-  NaClBlockAnalyzeParser(const NaClBlockAnalyzeParser&)
-      LLVM_DELETED_FUNCTION;
-  void operator=(NaClBlockAnalyzeParser&)
-      LLVM_DELETED_FUNCTION;
+  NaClBlockAnalyzeParser(const NaClBlockAnalyzeParser&) = delete;
+  void operator=(NaClBlockAnalyzeParser&) = delete;
 
 public:
   /// Top-level constructor to build the top-level block with the
   /// given BlockID, and collect data (for compression) in that block.
   NaClBlockAnalyzeParser(unsigned BlockID,
                          NaClAnalyzeParser *Context)
       : NaClBitcodeParser(BlockID, Context), Context(Context) {
     init();
   }
 
@@ skipping 125 matching lines @@
 /// in [VBR(6), Lit(4), VBR(6), Array(VBR(6))].
 ///
 /// After we have done appropriate substitutions, we can simplify the
 /// unrolled abbreviation by calling method Restore.
 ///
 /// Note: We unroll in the form that best matches the distribution
 /// map. Hence, the code is stored as a separate operator. We also
 /// keep the array abbreviation op, for untracked elements within the
 /// distribution maps.
 class UnrolledAbbreviation {
-  void operator=(const UnrolledAbbreviation&) LLVM_DELETED_FUNCTION;
+  void operator=(const UnrolledAbbreviation&) = delete;
 public:
   /// Unroll the given abbreviation, assuming it has the given size
   /// (as specified in the distribution maps).
   ///
   /// If argument CanBeBigger is true, then we do not assume that we
   /// can remove the trailing array when expanding, because the
   /// actual size of the corresponding record using this abbreviation
   /// may be bigger.
   UnrolledAbbreviation(NaClBitCodeAbbrev *Abbrev, unsigned Size,
                        bool CanBeBigger = false)
@@ skipping 982 matching lines @@
   BlockAbbrevsQueueMap AbbrevsQueueMap;
   bool Result = true;
   if (chooseAbbrevs(MemBuf, BlockAbbrevsMap, AbbrevsQueueMap))
     Result = false;
   else if (copyBitcode(Flags, MemBuf, BitcodeOutput, BlockAbbrevsMap,
                        AbbrevsQueueMap))
     Result = false;
   DeleteContainerSeconds(AbbrevsQueueMap);
   return Result;
 }