PNaCl: Impl the other atomicrmw operations: nand, max, min, umax, and umin.

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
 // instead of LLVM's regular IR instructions.
 //
 // All of the above are transformed into one of the
 // @llvm.nacl.atomic.* intrinsics.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Analysis/NaCl/PNaClSimplificationAnalyses.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/NaClAtomicIntrinsics.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Transforms/NaCl.h"
 #include <climits>
 #include <string>
 
 using namespace llvm;
 
 static cl::opt<bool> PNaClMemoryOrderSeqCstOnly(
     "pnacl-memory-order-seq-cst-only",
     cl::desc("PNaCl should upgrade all atomic memory orders to seq_cst"),
     cl::init(false));
 
 namespace {
 
-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());
+struct Initer {
+  Initer() {}
+  Initer(Initer &&Rhs)
+      : Initialized(Rhs.Initialized), Target(std::move(Rhs.Target)),
+        AtomicRMWExpander(std::move(Rhs.AtomicRMWExpander)) {}
+  Initer &operator=(Initer &&Rhs) {
+    Initialized = Rhs.Initialized;
+    Target = std::move(Rhs.Target);
+    AtomicRMWExpander = std::move(Rhs.AtomicRMWExpander);
+    return *this;
   }
 
-  virtual bool runOnModule(Module &M);
+  bool Initialized = false;
+  std::unique_ptr<TargetMachine> Target = nullptr;
+  std::unique_ptr<FunctionPass> AtomicRMWExpander = nullptr;
+
+  bool initialize() {
+    if (!Initialized) {
+      // For rewritting nand, (u)max, (u)min rmw atomics:

[Richard Diamond, 2015/07/30 11:47:08]

Note to (re)views: once http://reviews.llvm.org/D11422 is accepted upstream and
cherry picked into `pnacl-llvm`, this kluge will be removed infavor of
`llvm::expandAtomicRMWToCmpXchg`.

[Richard Diamond, 2015/07/30 11:48:08]

reviewers*

+      // First we need a target machine to appease its lordship:
+
+      // Get the target specific parser.
+      std::string Error;
+      Triple TheTriple = Triple("i686-none-nacl");
+      const llvm::Target *TheTarget =
+          TargetRegistry::lookupTarget("", TheTriple, Error);
+      if (!TheTarget) {
+        errs() << "Looking up 'i686-none-nacl':"
+               << ": " << Error;
+        report_fatal_error("Did you forget to initialize the x86 target?");
+      }
+
+      // Create the target machine:
+      Target.reset(TheTarget->createTargetMachine(
+          TheTriple.getTriple(), "generic", "", TargetOptions(), Reloc::Default,
+          CodeModel::Default, CodeGenOpt::Default));
+      assert(Target != nullptr);
+      AtomicRMWExpander.reset(createAtomicExpandPass(Target.get()));

[JF, 2015/07/27 19:49:28]

Now that you have an analysis pass, can you move this code to the part that
invokes the passes, so that we can create the triple there and pass it to other
passes?

+
+      Initialized = true;
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+class RewriteAtomicsPass {
+  Initer Init;
+
+public:
+  static StringRef name() { return "RewriteAtomicsPass"; }
+
+  RewriteAtomicsPass() { Init.initialize(); }
+  RewriteAtomicsPass(RewriteAtomicsPass &&Rhs) : Init(std::move(Rhs.Init)) {}
+  RewriteAtomicsPass &operator=(RewriteAtomicsPass &&Rhs) {
+    Init = std::move(Rhs.Init);
+    return *this;
+  }
+
+  PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM);
 };
 
 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(M.getDataLayout()), AI(C),
-        ModifiedModule(false) {}
+  AtomicVisitor(Module &M)
+      : M(M), C(M.getContext()), TD(M.getDataLayout()), AI(C) {}
   ~AtomicVisitor() {}
-  bool modifiedModule() const { return ModifiedModule; }
+  bool modifiedFunction() const { return Modified; }
+  bool needsAtomicExpand() const { return NeedsAtomicExpand; }
 
   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;
+  bool Modified = false;
+  bool NeedsAtomicExpand = false;
 
   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>
@@ skipping 54 matching lines @@
         Type *IntNPtr = Type::getIntNPtrTy(AV.C, BitSize);
         P = AV.createCast(I, P, IntNPtr, P->getName() + ".cast");
         PET = P->getType()->getPointerElementType();
       }
       AV.checkSizeMatchesType(I, BitSize, PET);
     }
   };
 };
 }
 
-char RewriteAtomics::ID = 0;
-INITIALIZE_PASS(RewriteAtomics, "nacl-rewrite-atomics",
-                "rewrite atomics, volatiles and fences into stable "
-                "@llvm.nacl.atomics.* intrinsics",
-                false, false)
+static bool
+ExpandAtomicInstructions(Function &F,
+                         std::unique_ptr<FunctionPass> &AtomicRMWExpander,
+                         AtomicInfo &Info) {
+  bool Changed = false;
+  AtomicVisitor AV(*F.getParent());
 
-bool RewriteAtomics::runOnModule(Module &M) {
-  AtomicVisitor AV(M, *this);
-  AV.visit(M);
-  return AV.modifiedModule();
+  auto &CmpXchgs = Info.getCmpXchgs();
+  for (auto *CmpXchg : CmpXchgs) {
+    AV.visitAtomicCmpXchgInst(*CmpXchg);
+    Changed = true;
+  }
+
+  auto &Loads = Info.getLoads();
+  for (auto *Load : Loads) {
+    AV.visitLoadInst(*Load);
+    Changed = true;
+  }
+
+  auto &Stores = Info.getStores();
+  for (auto *Store : Stores) {
+    AV.visitStoreInst(*Store);
+    Changed = true;
+  }
+
+  auto &RMWs = Info.getRMWs();
+  for (auto *RMW : RMWs) {
+    AV.visitAtomicRMWInst(*RMW);
+    Changed = true;
+  }
+
+  auto &Fences = Info.getFences();
+  for (auto *Fence : Fences) {
+    AV.visitFenceInst(*Fence);
+    Changed = true;
+  }
+
+  // Expand any leftover RMW atomics:
+  // This is done after because otherwise -atomic-expand will expand stuff we're
+  // capable of expanding, leaving us with less efficient code.
+  if (Info.needsAtomicExpand()) {
+    const bool Expanded = AtomicRMWExpander->runOnFunction(F);

[JF, 2015/07/27 19:49:28]

Once the target is present, this can be done automatically by the pass manager
(assuming you add it as a pass).

+    (void)Expanded;
+    assert(Expanded);
+    // revisit the function, rewriting cmpxchg to the corresponding
+    // llvm.nacl.etc.etc.
+    AV.visit(F);
+    Changed = true;
+  }
+  return Changed;
+}
+
+PreservedAnalyses RewriteAtomicsPass::run(Function &F,
+                                          AnalysisManager<Function> *AM) {
+  auto &Info = AM->getResult<AtomicAnalysis>(F);
+
+  if (ExpandAtomicInstructions(F, Init.AtomicRMWExpander, Info)) {
+    return PreservedAnalyses::none();
+  } else {
+    return PreservedAnalyses::all();
+  }
 }
 
 template <class Instruction>
 ConstantInt *AtomicVisitor::freezeMemoryOrder(const Instruction &I,
                                               AtomicOrdering O) const {
   NaCl::MemoryOrder AO = NaCl::MemoryOrderInvalid;
 
   // TODO Volatile load/store are promoted to sequentially consistent
   //      for now. We could do something weaker.
   if (const LoadInst *L = dyn_cast<LoadInst>(&I)) {
     if (L->isVolatile())
       AO = NaCl::MemoryOrderSequentiallyConsistent;
   } else if (const StoreInst *S = dyn_cast<StoreInst>(&I)) {
     if (S->isVolatile())
       AO = NaCl::MemoryOrderSequentiallyConsistent;
   }
 
   if (AO == NaCl::MemoryOrderInvalid) {
     switch (O) {
-    case NotAtomic: llvm_unreachable("unexpected memory order");
+    case NotAtomic:
+      llvm_unreachable("unexpected memory order");
     // Monotonic is a strict superset of Unordered. Both can therefore
     // map to Relaxed ordering, which is in the C11/C++11 standard.
-    case Unordered: AO = NaCl::MemoryOrderRelaxed; break;
-    case Monotonic: AO = NaCl::MemoryOrderRelaxed; break;
+    case Unordered:
+      AO = NaCl::MemoryOrderRelaxed;
+      break;
+    case Monotonic:
+      AO = NaCl::MemoryOrderRelaxed;
+      break;
     // TODO Consume is currently unspecified by LLVM's internal IR.
-    case Acquire: AO = NaCl::MemoryOrderAcquire; break;
-    case Release: AO = NaCl::MemoryOrderRelease; break;
-    case AcquireRelease: AO = NaCl::MemoryOrderAcquireRelease; break;
+    case Acquire:
+      AO = NaCl::MemoryOrderAcquire;
+      break;
+    case Release:
+      AO = NaCl::MemoryOrderRelease;
+      break;
+    case AcquireRelease:
+      AO = NaCl::MemoryOrderAcquireRelease;
+      break;
     case SequentiallyConsistent:
-      AO = NaCl::MemoryOrderSequentiallyConsistent; break;
+      AO = NaCl::MemoryOrderSequentiallyConsistent;
+      break;
     }
   }
 
   // TODO For now only acquire/release/acq_rel/seq_cst are allowed.
   if (PNaClMemoryOrderSeqCstOnly || AO == NaCl::MemoryOrderRelaxed)
     AO = NaCl::MemoryOrderSequentiallyConsistent;
 
   return ConstantInt::get(Type::getInt32Ty(C), AO);
 }
 
@@ skipping 82 matching lines @@
         Success, 1, Name + ".insert.success", &I);
   } else if (!Call->getType()->isVoidTy() && DstType != OverloadedType) {
     // The call returns a value which needs to be cast to a non-integer.
     Res = createCast(I, Call, DstType, Name + ".cast");
     Res->setDebugLoc(I.getDebugLoc());
   }
 
   I.replaceAllUsesWith(Res);
   I.eraseFromParent();
   Call->setName(Name);
-  ModifiedModule = true;
+  Modified = true;
 }
 
 ///   %res = load {atomic|volatile} T* %ptr memory_order, align sizeof(T)
 /// becomes:
 ///   %res = call T @llvm.nacl.atomic.load.i<size>(%ptr, memory_order)
 void AtomicVisitor::visitLoadInst(LoadInst &I) {
   if (I.isSimple())
     return;
   PointerHelper<LoadInst> PH(*this, I);
   const NaCl::AtomicIntrinsics::AtomicIntrinsic *Intrinsic =
@@ skipping 29 matching lines @@
   replaceInstructionWithIntrinsicCall(I, Intrinsic, PH.OriginalPET, PH.PET,
                                       Args);
 }
 
 ///   %res = atomicrmw OP T* %ptr, T %val memory_order
 /// becomes:
 ///   %res = call T @llvm.nacl.atomic.rmw.i<size>(OP, %ptr, %val, memory_order)
 void AtomicVisitor::visitAtomicRMWInst(AtomicRMWInst &I) {
   NaCl::AtomicRMWOperation Op;
   switch (I.getOperation()) {
-  default: report_fatal_error("unsupported atomicrmw operation: " + ToStr(I));
-  case AtomicRMWInst::Add: Op = NaCl::AtomicAdd; break;
-  case AtomicRMWInst::Sub: Op = NaCl::AtomicSub; break;
-  case AtomicRMWInst::And: Op = NaCl::AtomicAnd; break;
-  case AtomicRMWInst::Or:  Op = NaCl::AtomicOr;  break;
-  case AtomicRMWInst::Xor: Op = NaCl::AtomicXor; break;
-  case AtomicRMWInst::Xchg: Op = NaCl::AtomicExchange; break;
+  default: { return; }
+  case AtomicRMWInst::Add:
+    Op = NaCl::AtomicAdd;
+    break;
+  case AtomicRMWInst::Sub:
+    Op = NaCl::AtomicSub;
+    break;
+  case AtomicRMWInst::And:
+    Op = NaCl::AtomicAnd;
+    break;
+  case AtomicRMWInst::Or:
+    Op = NaCl::AtomicOr;
+    break;
+  case AtomicRMWInst::Xor:
+    Op = NaCl::AtomicXor;
+    break;
+  case AtomicRMWInst::Xchg:
+    Op = NaCl::AtomicExchange;
+    break;
   }
   PointerHelper<AtomicRMWInst> PH(*this, I);
   const NaCl::AtomicIntrinsics::AtomicIntrinsic *Intrinsic =
       findAtomicIntrinsic(I, Intrinsic::nacl_atomic_rmw, PH.PET);
   checkSizeMatchesType(I, PH.BitSize, I.getValOperand()->getType());
   Value *Args[] = {ConstantInt::get(Type::getInt32Ty(C), Op), PH.P,
                    I.getValOperand(), freezeMemoryOrder(I, I.getOrdering())};
   replaceInstructionWithIntrinsicCall(I, Intrinsic, PH.OriginalPET, PH.PET,
                                       Args);
 }
@@ skipping 52 matching lines @@
     replaceInstructionWithIntrinsicCall(I, Intrinsic, T, T,
                                         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(); }
+/// Wrapper for the legacy pass manager.
+class RewriteAtomics : public FunctionPass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  RewriteAtomics() : FunctionPass(ID) {
+    initializeRewriteAtomicsPass(*PassRegistry::getPassRegistry());
+  }
+
+  Initer Init;
+
+  using llvm::Pass::doInitialization;
+  bool doInitialization(Module &M) override {
+    (void)M;
+    return Init.initialize();
+  }
+
+  bool runOnFunction(Function &F) override {
+    auto &Info = getAnalysis<AtomicAnalysisWrapperPass>().getInfo();
+    return ExpandAtomicInstructions(F, Init.AtomicRMWExpander, Info);
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<AtomicAnalysisWrapperPass>();
+  }
+};
+char RewriteAtomics::ID = 0;
+INITIALIZE_PASS_BEGIN(RewriteAtomics, "nacl-rewrite-atomics",
+                      "rewrite atomics, volatiles and fences into stable "
+                      "@llvm.nacl.atomics.* intrinsics",
+                      false, false)
+INITIALIZE_PASS_DEPENDENCY(AtomicAnalysisWrapperPass);
+INITIALIZE_PASS_END(RewriteAtomics, "nacl-rewrite-atomics",
+                    "rewrite atomics, volatiles and fences into stable "
+                    "@llvm.nacl.atomics.* intrinsics",
+                    false, false)
+
+FunctionPass *llvm::createRewriteAtomicsPass() { return new RewriteAtomics(); }