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 = LangAS::Default; 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 * 107 emitAbstract(SourceLocation loc, const APValue &value, QualType T, 108 bool EnablePtrAuthFunctionTypeDiscrimination = true); 109 110 /// Try to emit the result of the given expression as an abstract constant. 111 llvm::Constant *tryEmitAbstract(const Expr *E, QualType T); 112 llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T); 113 114 llvm::Constant *tryEmitAbstract(const APValue &value, QualType T); 115 llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T); 116 117 llvm::Constant *tryEmitConstantSignedPointer(llvm::Constant *Ptr, 118 PointerAuthQualifier Auth); 119 120 llvm::Constant *tryEmitConstantExpr(const ConstantExpr *CE); 121 122 llvm::Constant *emitNullForMemory(QualType T) { 123 return emitNullForMemory(CGM, T); 124 } 125 llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) { 126 return emitForMemory(CGM, C, T); 127 } 128 129 static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T); 130 static llvm::Constant *emitForMemory(CodeGenModule &CGM, llvm::Constant *C, 131 QualType T); 132 133 // These are private helper routines of the constant emitter that 134 // can't actually be private because things are split out into helper 135 // functions and classes. 136 137 llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D); 138 139 llvm::Constant *tryEmitPrivate(const Expr *E, QualType T); 140 llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T); 141 142 llvm::Constant * 143 tryEmitPrivate(const APValue &value, QualType T, 144 bool EnablePtrAuthFunctionTypeDiscrimination = true); 145 llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T); 146 147 /// Get the address of the current location. This is a constant 148 /// that will resolve, after finalization, to the address of the 149 /// 'signal' value that is registered with the emitter later. 150 llvm::GlobalValue *getCurrentAddrPrivate(); 151 152 /// Register a 'signal' value with the emitter to inform it where to 153 /// resolve a placeholder. The signal value must be unique in the 154 /// initializer; it might, for example, be the address of a global that 155 /// refers to the current-address value in its own initializer. 156 /// 157 /// Uses of the placeholder must be properly anchored before finalizing 158 /// the emitter, e.g. by being installed as the initializer of a global 159 /// variable. That is, it must be possible to replaceAllUsesWith 160 /// the placeholder with the proper address of the signal. 161 void registerCurrentAddrPrivate(llvm::Constant *signal, 162 llvm::GlobalValue *placeholder); 163 164 private: 165 void initializeNonAbstract(LangAS destAS) { 166 assert(!InitializedNonAbstract); 167 InitializedNonAbstract = true; 168 DestAddressSpace = destAS; 169 } 170 llvm::Constant *markIfFailed(llvm::Constant *init) { 171 if (!init) 172 Failed = true; 173 return init; 174 } 175 176 struct AbstractState { 177 bool OldValue; 178 size_t OldPlaceholdersSize; 179 }; 180 AbstractState pushAbstract() { 181 AbstractState saved = { Abstract, PlaceholderAddresses.size() }; 182 Abstract = true; 183 return saved; 184 } 185 llvm::Constant *validateAndPopAbstract(llvm::Constant *C, AbstractState save); 186 }; 187 188 } 189 } 190 191 #endif 192