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