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.

[Derek Schuff, 2013/07/03 16:08:55]

since these files are really only for atomic intrinsics, they should probably be
named as such (unless someone plans to use them for other things). Also the
comment here and in NaClIntrinsics.cpp should be updated.

[JF, 2013/07/03 21:28:12]

Done in a single change.

+//
+//===----------------------------------------------------------------------===//
+
+#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;
+    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() 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