| 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 *const 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 |
bool isInConstantContext() const { return InConstantContext; } |
| 71 |
void setInConstantContext(bool var) { InConstantContext = var; } |
| 72 |
|
| 73 |
/// Try to emit the initiaizer of the given declaration as an abstract |
| 74 |
/// constant. If this succeeds, the emission must be finalized. |
| 75 |
llvm::Constant *tryEmitForInitializer(const VarDecl &D); |
| 76 |
llvm::Constant *tryEmitForInitializer(const Expr *E, LangAS destAddrSpace, |
| 77 |
QualType destType); |
| 78 |
llvm::Constant *emitForInitializer(const APValue &value, LangAS destAddrSpace, |
| 79 |
QualType destType); |
| 80 |
|
| 81 |
void finalize(llvm::GlobalVariable *global); |
| 82 |
|
| 83 |
// All of the "abstract" emission methods below permit the emission to |
| 84 |
// be immediately discarded without finalizing anything. Therefore, they |
| 85 |
// must also promise not to do anything that will, in the future, require |
| 86 |
// finalization: |
| 87 |
// |
| 88 |
// - using the CGF (if present) for anything other than establishing |
| 89 |
// semantic context; for example, an expression with ignored |
| 90 |
// side-effects must not be emitted as an abstract expression |
| 91 |
// |
| 92 |
// - doing anything that would not be safe to duplicate within an |
| 93 |
// initializer or to propagate to another context; for example, |
| 94 |
// side effects, or emitting an initialization that requires a |
| 95 |
// reference to its current location. |
| 96 |
|
| 97 |
/// Try to emit the initializer of the given declaration as an abstract |
| 98 |
/// constant. |
| 99 |
llvm::Constant *tryEmitAbstractForInitializer(const VarDecl &D); |
| 100 |
|
| 101 |
/// Emit the result of the given expression as an abstract constant, |
| 102 |
/// asserting that it succeeded. This is only safe to do when the |
| 103 |
/// expression is known to be a constant expression with either a fairly |
| 104 |
/// simple type or a known simple form. |
| 105 |
llvm::Constant *emitAbstract(const Expr *E, QualType T); |
| 106 |
llvm::Constant *emitAbstract(SourceLocation loc, const APValue &value, |
| 107 |
QualType T); |
| 108 |
|
| 109 |
/// Try to emit the result of the given expression as an abstract constant. |
| 110 |
llvm::Constant *tryEmitAbstract(const Expr *E, QualType T); |
| 111 |
llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T); |
| 112 |
|
| 113 |
llvm::Constant *tryEmitAbstract(const APValue &value, QualType T); |
| 114 |
llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T); |
| 115 |
|
| 116 |
llvm::Constant *tryEmitConstantExpr(const ConstantExpr *CE); |
| 117 |
|
| 118 |
llvm::Constant *emitNullForMemory(QualType T) { |
| 119 |
return emitNullForMemory(CGM, T); |
| 120 |
} |
| 121 |
llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) { |
| 122 |
return emitForMemory(CGM, C, T); |
| 123 |
} |
| 124 |
|
| 125 |
static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T); |
| 126 |
static llvm::Constant *emitForMemory(CodeGenModule &CGM, llvm::Constant *C, |
| 127 |
QualType T); |
| 128 |
|
| 129 |
// These are private helper routines of the constant emitter that |
| 130 |
// can't actually be private because things are split out into helper |
| 131 |
// functions and classes. |
| 132 |
|
| 133 |
llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D); |
| 134 |
|
| 135 |
llvm::Constant *tryEmitPrivate(const Expr *E, QualType T); |
| 136 |
llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T); |
| 137 |
|
| 138 |
llvm::Constant *tryEmitPrivate(const APValue &value, QualType T); |
| 139 |
llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T); |
| 140 |
|
| 141 |
/// Get the address of the current location. This is a constant |
| 142 |
/// that will resolve, after finalization, to the address of the |
| 143 |
/// 'signal' value that is registered with the emitter later. |
| 144 |
llvm::GlobalValue *getCurrentAddrPrivate(); |
| 145 |
|
| 146 |
/// Register a 'signal' value with the emitter to inform it where to |
| 147 |
/// resolve a placeholder. The signal value must be unique in the |
| 148 |
/// initializer; it might, for example, be the address of a global that |
| 149 |
/// refers to the current-address value in its own initializer. |
| 150 |
/// |
| 151 |
/// Uses of the placeholder must be properly anchored before finalizing |
| 152 |
/// the emitter, e.g. by being installed as the initializer of a global |
| 153 |
/// variable. That is, it must be possible to replaceAllUsesWith |
| 154 |
/// the placeholder with the proper address of the signal. |
| 155 |
void registerCurrentAddrPrivate(llvm::Constant *signal, |
| 156 |
llvm::GlobalValue *placeholder); |
| 157 |
|
| 158 |
private: |
| 159 |
void initializeNonAbstract(LangAS destAS) { |
| 160 |
assert(!InitializedNonAbstract); |
| 161 |
InitializedNonAbstract = true; |
| 162 |
DestAddressSpace = destAS; |
| 163 |
} |
| 164 |
llvm::Constant *markIfFailed(llvm::Constant *init) { |
| 165 |
if (!init) |
| 166 |
Failed = true; |
| 167 |
return init; |
| 168 |
} |
| 169 |
|
| 170 |
struct AbstractState { |
| 171 |
bool OldValue; |
| 172 |
size_t OldPlaceholdersSize; |
| 173 |
}; |
| 174 |
AbstractState pushAbstract() { |
| 175 |
AbstractState saved = { Abstract, PlaceholderAddresses.size() }; |
| 176 |
Abstract = true; |
| 177 |
return saved; |
| 178 |
} |
| 179 |
llvm::Constant *validateAndPopAbstract(llvm::Constant *C, AbstractState save); |
| 180 |
}; |
| 181 |
|
| 182 |
} |
| 183 |
} |
| 184 |
|
| 185 |
#endif |