ConstantEmitter.h source code [clang_source_code/lib/CodeGen/ConstantEmitter.h]

1	//===--- ConstantEmitter.h - IR constant emission ---------------- 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	// A helper class for emitting expressions and values as llvm::Constants
10	// and as initializers for global variables.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#ifndef LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H
15	#define LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H
16
17	#include "CodeGenFunction.h"
18	#include "CodeGenModule.h"
19
20	namespace clang {
21	namespace CodeGen {
22
23	class ConstantEmitter {
24	public:
25	CodeGenModule &CGM;
26	CodeGenFunction *CGF;
27
28	private:
29	bool Abstract = false;
30
31	/// Whether non-abstract components of the emitter have been initialized.
32	bool InitializedNonAbstract = false;
33
34	/// Whether the emitter has been finalized.
35	bool Finalized = false;
36
37	/// Whether the constant-emission failed.
38	bool Failed = false;
39
40	/// Whether we're in a constant context.
41	bool InConstantContext = false;
42
43	/// The AST address space where this (non-abstract) initializer is going.
44	/// Used for generating appropriate placeholders.
45	LangAS DestAddressSpace;
46
47	llvm::SmallVector<std::pair<llvm::Constant , llvm::GlobalVariable>, 4>
48	PlaceholderAddresses;
49
50	public:
51	ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF = nullptr)
52	: CGM(CGM), CGF(CGF) {}
53
54	/// Initialize this emission in the context of the given function.
55	/// Use this if the expression might contain contextual references like
56	/// block addresses or PredefinedExprs.
57	ConstantEmitter(CodeGenFunction &CGF)
58	: CGM(CGF.CGM), CGF(&CGF) {}
59
60	ConstantEmitter(const ConstantEmitter &other) = delete;
61	ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
62
63	~ConstantEmitter();
64
65	/// Is the current emission context abstract?
66	bool isAbstract() const {
67	return Abstract;
68	}
69
70	/// Try to emit the initiaizer of the given declaration as an abstract
71	/// constant. If this succeeds, the emission must be finalized.
72	llvm::Constant *tryEmitForInitializer(const VarDecl &D);
73	llvm::Constant tryEmitForInitializer(const Expr E, LangAS destAddrSpace,
74	QualType destType);
75	llvm::Constant *emitForInitializer(const APValue &value, LangAS destAddrSpace,
76	QualType destType);
77
78	void finalize(llvm::GlobalVariable *global);
79
80	// All of the "abstract" emission methods below permit the emission to
81	// be immediately discarded without finalizing anything. Therefore, they
82	// must also promise not to do anything that will, in the future, require
83	// finalization:
84	//
85	// - using the CGF (if present) for anything other than establishing
86	// semantic context; for example, an expression with ignored
87	// side-effects must not be emitted as an abstract expression
88	//
89	// - doing anything that would not be safe to duplicate within an
90	// initializer or to propagate to another context; for example,
91	// side effects, or emitting an initialization that requires a
92	// reference to its current location.
93
94	/// Try to emit the initializer of the given declaration as an abstract
95	/// constant.
96	llvm::Constant *tryEmitAbstractForInitializer(const VarDecl &D);
97
98	/// Emit the result of the given expression as an abstract constant,
99	/// asserting that it succeeded. This is only safe to do when the
100	/// expression is known to be a constant expression with either a fairly
101	/// simple type or a known simple form.
102	llvm::Constant emitAbstract(const Expr E, QualType T);
103	llvm::Constant *emitAbstract(SourceLocation loc, const APValue &value,
104	QualType T);
105
106	/// Try to emit the result of the given expression as an abstract constant.
107	llvm::Constant tryEmitAbstract(const Expr E, QualType T);
108	llvm::Constant tryEmitAbstractForMemory(const Expr E, QualType T);
109
110	llvm::Constant *tryEmitAbstract(const APValue &value, QualType T);
111	llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T);
112
113	llvm::Constant *emitNullForMemory(QualType T) {
114	return emitNullForMemory(CGM, T);
115	}
116	llvm::Constant emitForMemory(llvm::Constant C, QualType T) {
117	return emitForMemory(CGM, C, T);
118	}
119
120	static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T);
121	static llvm::Constant emitForMemory(CodeGenModule &CGM, llvm::Constant C,
122	QualType T);
123
124	// These are private helper routines of the constant emitter that
125	// can't actually be private because things are split out into helper
126	// functions and classes.
127
128	llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D);
129
130	llvm::Constant tryEmitPrivate(const Expr E, QualType T);
131	llvm::Constant tryEmitPrivateForMemory(const Expr E, QualType T);
132
133	llvm::Constant *tryEmitPrivate(const APValue &value, QualType T);
134	llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T);
135
136	/// Get the address of the current location. This is a constant
137	/// that will resolve, after finalization, to the address of the
138	/// 'signal' value that is registered with the emitter later.
139	llvm::GlobalValue *getCurrentAddrPrivate();
140
141	/// Register a 'signal' value with the emitter to inform it where to
142	/// resolve a placeholder. The signal value must be unique in the
143	/// initializer; it might, for example, be the address of a global that
144	/// refers to the current-address value in its own initializer.
145	///
146	/// Uses of the placeholder must be properly anchored before finalizing
147	/// the emitter, e.g. by being installed as the initializer of a global
148	/// variable. That is, it must be possible to replaceAllUsesWith
149	/// the placeholder with the proper address of the signal.
150	void registerCurrentAddrPrivate(llvm::Constant *signal,
151	llvm::GlobalValue *placeholder);
152
153	private:
154	void initializeNonAbstract(LangAS destAS) {
155	assert(!InitializedNonAbstract);
156	InitializedNonAbstract = true;
157	DestAddressSpace = destAS;
158	}
159	llvm::Constant markIfFailed(llvm::Constant init) {
160	if (!init)
161	Failed = true;
162	return init;
163	}
164
165	struct AbstractState {
166	bool OldValue;
167	size_t OldPlaceholdersSize;
168	};
169	AbstractState pushAbstract() {
170	AbstractState saved = { Abstract, PlaceholderAddresses.size() };
171	Abstract = true;
172	return saved;
173	}
174	llvm::Constant validateAndPopAbstract(llvm::Constant C, AbstractState save);
175	};
176
177	}
178	}
179
180	#endif
181