ConstantInitFuture.h source code [clang_source_code/include/clang/CodeGen/ConstantInitFuture.h]

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	(0) . __assert_fail ("initializer && \"creating null future\"", "/home/seafit/code_projects/clang_source/clang/include/clang/CodeGen/ConstantInitFuture.h", 60, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">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

llvm::PointerLikeTypeTraits::getAsVoidPointer

llvm::PointerLikeTypeTraits::getFromVoidPointer

clang::CodeGen::ConstantInitFuture::Data

clang::CodeGen::ConstantInitFuture::getType

clang::CodeGen::ConstantInitFuture::abandon

clang::CodeGen::ConstantInitFuture::installInGlobal

clang::CodeGen::ConstantInitFuture::getOpaqueValue

clang::CodeGen::ConstantInitFuture::getFromOpaqueValue

clang::CodeGen::ConstantInitFuture::installInGlobal

Clang Project