Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/RewriteAtomics.cpp

 //===- RewriteAtomics.cpp - Stabilize instructions used for concurrency ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass encodes atomics, volatiles and fences using NaCl intrinsics
@@ skipping 33 matching lines @@
 class RewriteAtomics : public ModulePass {
 public:
   static char ID; // Pass identification, replacement for typeid
   RewriteAtomics() : ModulePass(ID) {
     // This is a module pass because it may have to introduce
     // intrinsic declarations into the module and modify a global function.
     initializeRewriteAtomicsPass(*PassRegistry::getPassRegistry());
   }
 
   virtual bool runOnModule(Module &M);
-  virtual void getAnalysisUsage(AnalysisUsage &Info) const {
-    Info.addRequired<DataLayoutPass>();
-  }
 };
 
 template <class T> std::string ToStr(const T &V) {
   std::string S;
   raw_string_ostream OS(S);
   OS << const_cast<T &>(V);
   return OS.str();
 }
 
 class AtomicVisitor : public InstVisitor<AtomicVisitor> {
 public:
   AtomicVisitor(Module &M, Pass &P)
       : M(M), C(M.getContext()),
-        TD(P.getAnalysis<DataLayoutPass>().getDataLayout()), AI(C),
+        TD(M.getDataLayout()), AI(C),
         ModifiedModule(false) {}
   ~AtomicVisitor() {}
   bool modifiedModule() const { return ModifiedModule; }
 
   void visitLoadInst(LoadInst &I);
   void visitStoreInst(StoreInst &I);
   void visitAtomicCmpXchgInst(AtomicCmpXchgInst &I);
   void visitAtomicRMWInst(AtomicRMWInst &I);
   void visitFenceInst(FenceInst &I);
 
 private:
   Module &M;
   LLVMContext &C;
   const DataLayout TD;
   NaCl::AtomicIntrinsics AI;
   bool ModifiedModule;
 
-  AtomicVisitor() LLVM_DELETED_FUNCTION;
-  AtomicVisitor(const AtomicVisitor &) LLVM_DELETED_FUNCTION;
-  AtomicVisitor &operator=(const AtomicVisitor &) LLVM_DELETED_FUNCTION;
+  AtomicVisitor() = delete;
+  AtomicVisitor(const AtomicVisitor &) = delete;
+  AtomicVisitor &operator=(const AtomicVisitor &) = delete;
 
   /// Create an integer constant holding a NaCl::MemoryOrder that can be
   /// passed as an argument to one of the @llvm.nacl.atomic.*
   /// intrinsics. This function may strengthen the ordering initially
   /// specified by the instruction \p I for stability purpose.
   template <class Instruction>
   ConstantInt *freezeMemoryOrder(const Instruction &I, AtomicOrdering O) const;
   std::pair<ConstantInt *, ConstantInt *>
   freezeMemoryOrder(const AtomicCmpXchgInst &I, AtomicOrdering S,
                     AtomicOrdering F) const;
@@ skipping 322 matching lines @@
                                         ArrayRef<Value *>());
   } else {
     const NaCl::AtomicIntrinsics::AtomicIntrinsic *Intrinsic =
         findAtomicIntrinsic(I, Intrinsic::nacl_atomic_fence, T);
     Value *Args[] = {freezeMemoryOrder(I, I.getOrdering())};
     replaceInstructionWithIntrinsicCall(I, Intrinsic, T, T, Args);
   }
 }
 
 ModulePass *llvm::createRewriteAtomicsPass() { return new RewriteAtomics(); }