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 "llvm/Support/Compiler.h"
+#include <cstddef>
+
+namespace llvm {
+
+namespace NaCl {
+
+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 {
+    NoP, // No parameter.
+    Int, // Overloaded.
+    Ptr, // Overloaded.
+    RMW, // Atomic RMW operation type.
+    Mem  // Memory order.
+  };
+
+  struct AtomicIntrinsic {
+    Intrinsic::ID ID : 16;
+    uint8_t NumParams;

[Mark Seaborn, 2013/07/03 04:55:20]

You can remove this -- it's set but not read

[JF, 2013/07/03 15:06:13]

Cleaned up.

+    bool Overloaded;
+    Type *OverloadedType;
+    // Full function signature, excluding return type.
+    Type *Signature[MaxAtomicIntrinsicsParameters];

[Mark Seaborn, 2013/07/03 04:55:20]

This isn't read any more

[JF, 2013/07/03 15:06:13]

Done.

+    uint8_t ParamType[MaxAtomicIntrinsicsParameters];
+
+    Type *Parameter(size_t P) const { return Signature[P]; }

[Mark Seaborn, 2013/07/03 04:55:20]

This method isn't used any more

[JF, 2013/07/03 15:06:13]

Done.

+    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() LLVM_DELETED_FUNCTION;
+    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() LLVM_DELETED_FUNCTION;
+  AtomicIntrinsics(const AtomicIntrinsics &) LLVM_DELETED_FUNCTION;
+  AtomicIntrinsics &operator=(const AtomicIntrinsics &) LLVM_DELETED_FUNCTION;
+};
+
+// 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