Add the new @llvm.nacl.atomic.fence.all intrinsic

lib/IR/NaClAtomicIntrinsics.cpp

 //=== llvm/IR/NaClAtomicIntrinsics.cpp - NaCl Atomic Intrinsics -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes atomic intrinsic functions that are specific to NaCl.
@@ skipping 36 matching lines @@
       I[CurIntrin][CurType].ParamType[Param++] = P3;                           \
       I[CurIntrin][CurType].ParamType[Param++] = P4;                           \
     }                                                                          \
     ++CurIntrin;                                                               \
   } while (0)
 
   INIT(Ptr, Mem, NoP, NoP, NoP, load);
   INIT(Ptr, Int, Mem, NoP, NoP, store);
   INIT(RMW, Ptr, Int, Mem, NoP, rmw);
   INIT(Ptr, Int, Int, Mem, Mem, cmpxchg);
   INIT(Mem, NoP, NoP, NoP, NoP, fence);

[jvoung (off chromium), 2013/08/07 19:38:40]

I think I brought this up before -- it seems a bit wasteful to create versions
of fence and fence_all for each overload type, even though there aren't
overloads.

Doesn't it mean that the transform pass will loop through each call in a
function 3x more than needed for each of the fence and fence_all?


The loop:

NaCl::AtomicIntrinsics::View V = AI.allIntrinsicsAndOverloads();
for (NaCl::AtomicIntrinsics::View::iterator I = V.begin(), E = V.end(); I != E;
++I) {
    AtomicCallResolver AtomicResolver(F, I);
    Changed |= visitCalls(AtomicResolver);
}

[JF, 2013/08/07 19:55:21]

I can make a "default overload type" for the functions with no overload, and
then remove the duplicates from this table.

I'd rather do this in another CL, though: I'd like to get this and others in
before the branch. If it's OK with you I'll file an issue and punt to M31.

[jvoung (off chromium), 2013/08/07 22:32:11]

ok that's fine

[JF, 2013/08/07 22:47:41]

https://code.google.com/p/nativeclient/issues/detail?id=3612

+  INIT(NoP, NoP, NoP, NoP, NoP, fence_all);
 }
 
 AtomicIntrinsics::View AtomicIntrinsics::allIntrinsicsAndOverloads() const {
   return View(&I[0][0], NumAtomicIntrinsics * NumAtomicIntrinsicOverloadTypes);
 }
 
 AtomicIntrinsics::View AtomicIntrinsics::overloadsFor(Intrinsic::ID ID) const {
   // Overloads are stored consecutively.
   View R = allIntrinsicsAndOverloads();
   for (const AtomicIntrinsic *AI = R.begin(), *E = R.end(); AI != E; ++AI)
     if (AI->ID == ID)
       return View(AI, NumAtomicIntrinsicOverloadTypes);
   llvm_unreachable("unhandled atomic intrinsic");
 }
 
 const AtomicIntrinsics::AtomicIntrinsic *
 AtomicIntrinsics::find(Intrinsic::ID ID, Type *OverloadedType) const {
   View R = allIntrinsicsAndOverloads();
   for (const AtomicIntrinsic *AI = R.begin(), *E = R.end(); AI != E; ++AI)
     if (AI->ID == ID && AI->OverloadedType == OverloadedType)
       return AI;
   llvm_unreachable("unhandled atomic intrinsic");
 }
 
 } // End NaCl namespace
 
 } // End llvm namespace