| //===--- ConstantEmitter.h - IR constant emission ---------------*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // A helper class for emitting expressions and values as llvm::Constants | |
| // and as initializers for global variables. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H | |
| #define LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H | |
| #include "CodeGenFunction.h" | |
| #include "CodeGenModule.h" | |
| namespace clang { | |
| namespace CodeGen { | |
| class ConstantEmitter { | |
| public: | |
| CodeGenModule &CGM; | |
| CodeGenFunction *const CGF; | |
| private: | |
| bool Abstract = false; | |
| /// Whether non-abstract components of the emitter have been initialized. | |
| bool InitializedNonAbstract = false; | |
| /// Whether the emitter has been finalized. | |
| bool Finalized = false; | |
| /// Whether the constant-emission failed. | |
| bool Failed = false; | |
| /// Whether we're in a constant context. | |
| bool InConstantContext = false; | |
| /// The AST address space where this (non-abstract) initializer is going. | |
| /// Used for generating appropriate placeholders. | |
| LangAS DestAddressSpace = LangAS::Default; | |
| llvm::SmallVector<std::pair<llvm::Constant *, llvm::GlobalVariable*>, 4> | |
| PlaceholderAddresses; | |
| public: | |
| ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF = nullptr) | |
| : CGM(CGM), CGF(CGF) {} | |
| /// Initialize this emission in the context of the given function. | |
| /// Use this if the expression might contain contextual references like | |
| /// block addresses or PredefinedExprs. | |
| ConstantEmitter(CodeGenFunction &CGF) | |
| : CGM(CGF.CGM), CGF(&CGF) {} | |
| ConstantEmitter(const ConstantEmitter &other) = delete; | |
| ConstantEmitter &operator=(const ConstantEmitter &other) = delete; | |
| ~ConstantEmitter(); | |
| /// Is the current emission context abstract? | |
| bool isAbstract() const { | |
| return Abstract; | |
| } | |
| bool isInConstantContext() const { return InConstantContext; } | |
| void setInConstantContext(bool var) { InConstantContext = var; } | |
| /// Try to emit the initiaizer of the given declaration as an abstract | |
| /// constant. If this succeeds, the emission must be finalized. | |
| llvm::Constant *tryEmitForInitializer(const VarDecl &D); | |
| llvm::Constant *tryEmitForInitializer(const Expr *E, LangAS destAddrSpace, | |
| QualType destType); | |
| llvm::Constant *emitForInitializer(const APValue &value, LangAS destAddrSpace, | |
| QualType destType); | |
| void finalize(llvm::GlobalVariable *global); | |
| // All of the "abstract" emission methods below permit the emission to | |
| // be immediately discarded without finalizing anything. Therefore, they | |
| // must also promise not to do anything that will, in the future, require | |
| // finalization: | |
| // | |
| // - using the CGF (if present) for anything other than establishing | |
| // semantic context; for example, an expression with ignored | |
| // side-effects must not be emitted as an abstract expression | |
| // | |
| // - doing anything that would not be safe to duplicate within an | |
| // initializer or to propagate to another context; for example, | |
| // side effects, or emitting an initialization that requires a | |
| // reference to its current location. | |
| /// Try to emit the initializer of the given declaration as an abstract | |
| /// constant. | |
| llvm::Constant *tryEmitAbstractForInitializer(const VarDecl &D); | |
| /// Emit the result of the given expression as an abstract constant, | |
| /// asserting that it succeeded. This is only safe to do when the | |
| /// expression is known to be a constant expression with either a fairly | |
| /// simple type or a known simple form. | |
| llvm::Constant *emitAbstract(const Expr *E, QualType T); | |
| llvm::Constant * | |
| emitAbstract(SourceLocation loc, const APValue &value, QualType T, | |
| bool EnablePtrAuthFunctionTypeDiscrimination = true); | |
| /// Try to emit the result of the given expression as an abstract constant. | |
| llvm::Constant *tryEmitAbstract(const Expr *E, QualType T); | |
| llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T); | |
| llvm::Constant *tryEmitAbstract(const APValue &value, QualType T); | |
| llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T); | |
| llvm::Constant *tryEmitConstantSignedPointer(llvm::Constant *Ptr, | |
| PointerAuthQualifier Auth); | |
| llvm::Constant *tryEmitConstantExpr(const ConstantExpr *CE); | |
| llvm::Constant *emitNullForMemory(QualType T) { | |
| return emitNullForMemory(CGM, T); | |
| } | |
| llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) { | |
| return emitForMemory(CGM, C, T); | |
| } | |
| static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T); | |
| static llvm::Constant *emitForMemory(CodeGenModule &CGM, llvm::Constant *C, | |
| QualType T); | |
| // These are private helper routines of the constant emitter that | |
| // can't actually be private because things are split out into helper | |
| // functions and classes. | |
| llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D); | |
| llvm::Constant *tryEmitPrivate(const Expr *E, QualType T); | |
| llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T); | |
| llvm::Constant * | |
| tryEmitPrivate(const APValue &value, QualType T, | |
| bool EnablePtrAuthFunctionTypeDiscrimination = true); | |
| llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T); | |
| /// Get the address of the current location. This is a constant | |
| /// that will resolve, after finalization, to the address of the | |
| /// 'signal' value that is registered with the emitter later. | |
| llvm::GlobalValue *getCurrentAddrPrivate(); | |
| /// Register a 'signal' value with the emitter to inform it where to | |
| /// resolve a placeholder. The signal value must be unique in the | |
| /// initializer; it might, for example, be the address of a global that | |
| /// refers to the current-address value in its own initializer. | |
| /// | |
| /// Uses of the placeholder must be properly anchored before finalizing | |
| /// the emitter, e.g. by being installed as the initializer of a global | |
| /// variable. That is, it must be possible to replaceAllUsesWith | |
| /// the placeholder with the proper address of the signal. | |
| void registerCurrentAddrPrivate(llvm::Constant *signal, | |
| llvm::GlobalValue *placeholder); | |
| private: | |
| void initializeNonAbstract(LangAS destAS) { | |
| assert(!InitializedNonAbstract); | |
| InitializedNonAbstract = true; | |
| DestAddressSpace = destAS; | |
| } | |
| llvm::Constant *markIfFailed(llvm::Constant *init) { | |
| if (!init) | |
| Failed = true; | |
| return init; | |
| } | |
| struct AbstractState { | |
| bool OldValue; | |
| size_t OldPlaceholdersSize; | |
| }; | |
| AbstractState pushAbstract() { | |
| AbstractState saved = { Abstract, PlaceholderAddresses.size() }; | |
| Abstract = true; | |
| return saved; | |
| } | |
| llvm::Constant *validateAndPopAbstract(llvm::Constant *C, AbstractState save); | |
| }; | |
| } | |
| } | |
| #endif |