1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
//===-- llvm/IR/NaClAtomicIntrinsics.h - 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.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_NACL_ATOMIC_INTRINSICS_H
#define LLVM_IR_NACL_ATOMIC_INTRINSICS_H
#include "llvm/IR/Intrinsics.h"
#include "llvm/Support/Compiler.h"
#include <cstddef>
namespace llvm {
namespace NaCl {
static const size_t NumAtomicIntrinsics = 6;
static const size_t NumAtomicIntrinsicOverloadTypes = 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 {
Type *OverloadedType;
Intrinsic::ID ID : 16;
uint8_t Overloaded : 1;
uint8_t NumParams : 7;
uint8_t ParamType[MaxAtomicIntrinsicsParameters];
Function *getDeclaration(Module *M) const {
// The atomic intrinsic can be overloaded on zero or one type,
// which is needed to create the function's declaration.
return Intrinsic::getDeclaration(
M, ID, ArrayRef<Type *>(&OverloadedType, Overloaded ? 1 : 0));
}
};
AtomicIntrinsics(LLVMContext &C);
~AtomicIntrinsics() {}
typedef ArrayRef<AtomicIntrinsic> View;
/// The following three methods give access to atomic intrinsics, or a
/// subset of them, and allows iteration through them.
View allIntrinsicsAndOverloads() const;
View overloadsFor(Intrinsic::ID ID) const;
const AtomicIntrinsic *find(Intrinsic::ID ID, Type *OverloadedType) const;
private:
AtomicIntrinsic I[NumAtomicIntrinsics][NumAtomicIntrinsicOverloadTypes];
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
|
