clang 8.0.0

ConstantInitFuture.h
Go to the documentation of this file.
1 //===- ConstantInitFuture.h - "Future" constant initializers ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This class defines the ConstantInitFuture class. This is split out
11 // from ConstantInitBuilder.h in order to allow APIs to work with it
12 // without having to include that entire header. This is particularly
13 // important because it is often useful to be able to default-construct
14 // a future in, say, a default argument.
15 //
16 //===----------------------------------------------------------------------===//
17
18 #ifndef LLVM_CLANG_CODEGEN_CONSTANTINITFUTURE_H
19 #define LLVM_CLANG_CODEGEN_CONSTANTINITFUTURE_H
20
21 #include "llvm/ADT/PointerUnion.h"
22 #include "llvm/IR/Constant.h"
23
24 // Forward-declare ConstantInitBuilderBase and give it a
25 // PointerLikeTypeTraits specialization so that we can safely use it
26 // in a PointerUnion below.
27 namespace clang {
28 namespace CodeGen {
29 class ConstantInitBuilderBase;
30 }
31 }
32 namespace llvm {
33 template <>
34 struct PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase*> {
35 using T = ::clang::CodeGen::ConstantInitBuilderBase*;
36
37 static inline void *getAsVoidPointer(T p) { return p; }
38 static inline T getFromVoidPointer(void *p) {return static_cast<T>(p);}
39 enum { NumLowBitsAvailable = 2 };
40 };
41 }
42
43 namespace clang {
44 namespace CodeGen {
45
46 /// A "future" for a completed constant initializer, which can be passed
47 /// around independently of any sub-builders (but not the original parent).
48 class ConstantInitFuture {
49 using PairTy = llvm::PointerUnion<ConstantInitBuilderBase*, llvm::Constant*>;
50
51 PairTy Data;
52
53 friend class ConstantInitBuilderBase;
54 explicit ConstantInitFuture(ConstantInitBuilderBase *builder);
55
56 public:
57 ConstantInitFuture() {}
58
59 /// A future can be explicitly created from a fixed initializer.
60 explicit ConstantInitFuture(llvm::Constant *initializer) : Data(initializer) {
61 assert(initializer && "creating null future");
62 }
63
64 /// Is this future non-null?
65 explicit operator bool() const { return bool(Data); }
66
67 /// Return the type of the initializer.
68 llvm::Type *getType() const;
69
70 /// Abandon this initializer.
71 void abandon();
72
73 /// Install the initializer into a global variable. This cannot
74 /// be called multiple times.
75 void installInGlobal(llvm::GlobalVariable *global);
76
77 void *getOpaqueValue() const { return Data.getOpaqueValue(); }
78 static ConstantInitFuture getFromOpaqueValue(void *value) {
79 ConstantInitFuture result;
80 result.Data = PairTy::getFromOpaqueValue(value);
81 return result;
82 }
83 enum {
84 NumLowBitsAvailable =
85 llvm::PointerLikeTypeTraits<PairTy>::NumLowBitsAvailable
86 };
87 };
88
89 } // end namespace CodeGen
90 } // end namespace clang
91
92 namespace llvm {
93
94 template <>
95 struct PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture> {
96 using T = ::clang::CodeGen::ConstantInitFuture;
97
98 static inline void *getAsVoidPointer(T future) {
99 return future.getOpaqueValue();
100 }
101 static inline T getFromVoidPointer(void *p) {
102 return T::getFromOpaqueValue(p);
103 }
104 enum { NumLowBitsAvailable = T::NumLowBitsAvailable };
105 };
106
107 } // end namespace llvm
108
109 #endif
llvm
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
clang::CodeGen::ConstantInitFuture::ConstantInitFuture
ConstantInitFuture()
Definition: ConstantInitFuture.h:57
llvm::PointerLikeTypeTraits
Definition: DeclGroup.h:140
bool
#define bool
Definition: stdbool.h:31
llvm::PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture >::getAsVoidPointer
static void * getAsVoidPointer(T future)
Definition: ConstantInitFuture.h:98
llvm::PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase * >::getAsVoidPointer
static void * getAsVoidPointer(T p)
Definition: ConstantInitFuture.h:37
clang::CodeGen::AlignmentSource::Type
The l-value was considered opaque, so the alignment was determined from a type.
clang::CodeGen::ConstantInitFuture::ConstantInitFuture
ConstantInitFuture(llvm::Constant *initializer)
A future can be explicitly created from a fixed initializer.
Definition: ConstantInitFuture.h:60
clang::CodeGen::ConstantInitFuture
A "future" for a completed constant initializer, which can be passed around independently of any sub-...
Definition: ConstantInitFuture.h:48
clang::CodeGen::ConstantInitFuture::getOpaqueValue
void * getOpaqueValue() const
Definition: ConstantInitFuture.h:77
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
llvm::PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture >::getFromVoidPointer
static T getFromVoidPointer(void *p)
Definition: ConstantInitFuture.h:101
clang::CodeGen::ConstantInitFuture::getFromOpaqueValue
static ConstantInitFuture getFromOpaqueValue(void *value)
Definition: ConstantInitFuture.h:78
llvm::PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase * >::getFromVoidPointer
static T getFromVoidPointer(void *p)
Definition: ConstantInitFuture.h:38
clang::CodeGen::ConstantInitBuilderBase
Definition: ConstantInitBuilder.h:52