Concurrency support for PNaCl ABI

include/llvm/IR/NaClIntrinsics.h

+//===-- llvm/IR/NaClIntrinsics.h - NaCl 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 intrinsic functions that are specific to NaCl.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_NACL_H
+#define LLVM_IR_NACL_H
+
+#include "llvm/IR/Intrinsics.h"
+#include <cstddef>
+
+namespace llvm {
+
+namespace NaCl {

[Mark Seaborn, 2013/07/02 19:16:02]

We haven't used "namespace NaCl" so far, but there is a "namespace naclbitc". 
Maybe this should be "namespace nacl" here, for consistency with existing
lower-case namespace names?

[JF, 2013/07/02 23:14:54]

The majority of LLVM namespaces are capitalized, so for consistency naclbitc
should be capitalized.

+
+static const size_t NumAtomicIntrinsics = 5;
+static const size_t NumAtomicIntrinsicTypes = 4;
+static const size_t MaxAtomicIntrinsicsParameters = 5;
+
+// Describe all the atomic intrinsics and their type signature. Most can
+// be overloaded on a type.
+class AtomicIntrinsics {
+public:
+  enum ParamType {
+    Non, // No parameter.

[Mark Seaborn, 2013/07/02 19:16:02]

"Non" -> "None"?  Otherwise this is obscure - it looks like you're programming
in French. :-)

[JF, 2013/07/02 23:14:54]

Renamed to NoP.

+    Int, // Overloaded.
+    Ptr, // Overloaded.
+    RMW, // Atomic RMW operation type.
+    Mem  // Memory order.
+  };
+
+  struct AtomicIntrinsic {
+    Intrinsic::ID ID : 16;

[Mark Seaborn, 2013/07/02 19:16:02]

Using a bitfield here seems to be a micro-optimisation.  It might break if
upstream starts using a lot of intrinsic IDs, or allocates them
non-contiguously.

[JF, 2013/07/02 23:14:54]

It's 40 bytes that are used at translation time, and I think it's a decent one
without shortcomings. Coming from me that's not much of a micro-optimization, in
a more constrained compiler I'd have done much more with this struct.

+    uint8_t NumParams;
+    bool Overloaded;
+    Type *OverloadedType;
+    // Full function signature, excluding return type.
+    Type *Signature[MaxAtomicIntrinsicsParameters];
+    uint8_t ParamType[MaxAtomicIntrinsicsParameters];
+
+    Type *Parameter(size_t P) const { return Signature[P]; }
+    Function *getDeclaration(Module *M) const {
+      return Intrinsic::getDeclaration(
+          M, ID, ArrayRef<Type *>(&OverloadedType, Overloaded ? 1 : 0));
+    }
+  };
+
+  AtomicIntrinsics(LLVMContext &C);
+  ~AtomicIntrinsics() {}
+
+  class const_iterator {
+  public:
+    const_iterator(const AtomicIntrinsic *I) : I(I) {}
+    ~const_iterator() {}
+    const_iterator(const const_iterator &rhs) : I(rhs.I) {}
+    const_iterator &operator=(const const_iterator &rhs) {
+      I = rhs.I;
+      return *this;
+    }
+    void operator++() { ++I; }
+    bool operator!=(const const_iterator &rhs) { return I != rhs.I; }
+    const AtomicIntrinsic *operator->() const { return I; }
+
+  private:
+    const AtomicIntrinsic *I;
+    const_iterator();
+    friend class AtomicIntrinsics;
+  };
+
+  // Iterator through all ID+Type overloads.
+  const_iterator begin() const;
+  const_iterator end() const;
+
+  // Iterator through all Type overloads for a single ID.
+  const_iterator begin(Intrinsic::ID ID) const;
+  const_iterator end(Intrinsic::ID ID) const;
+
+  const_iterator find(Intrinsic::ID ID, Type *OverloadedType) const;
+
+private:
+  AtomicIntrinsic I[NumAtomicIntrinsics][NumAtomicIntrinsicTypes];
+
+  AtomicIntrinsics();
+  AtomicIntrinsics(const AtomicIntrinsics &);
+  AtomicIntrinsics &operator=(const AtomicIntrinsics &);
+};
+
+// Operations that can be represented by the @llvm.nacl.atomic.rmw
+// intrinsic.
+//
+// Do not reorder these values: their order offers forward compatibility
+// of bitcode targeted to NaCl.
+enum AtomicRMWOperation {
+  AtomicInvalid = 0, // Invalid, keep first.
+  AtomicAdd,
+  AtomicSub,
+  AtomicOr,
+  AtomicAnd,
+  AtomicXor,
+  AtomicExchange,
+  AtomicNum // Invalid, keep last.
+};
+
+// Memory orderings supported by C11/C++11.
+//
+// Do not reorder these values: their order offers forward compatibility
+// of bitcode targeted to NaCl.
+enum MemoryOrder {
+  MemoryOrderInvalid = 0, // Invalid, keep first.
+  MemoryOrderRelaxed,
+  MemoryOrderConsume,
+  MemoryOrderAcquire,
+  MemoryOrderRelease,
+  MemoryOrderAcquireRelease,
+  MemoryOrderSequentiallyConsistent,
+  MemoryOrderNum // Invalid, keep last.
+};
+
+} // End NaCl namespace
+
+} // End llvm namespace
+
+#endif