blob: 59a19730f4ebc51829f83e97930f4e322761a96e [file] [log] [blame]
//===--- ConstantEmitter.h - IR constant emission ---------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See 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.
#include "CodeGenFunction.h"
#include "CodeGenModule.h"
namespace clang {
namespace CodeGen {
class ConstantEmitter {
CodeGenModule &CGM;
CodeGenFunction *CGF;
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;
llvm::SmallVector<std::pair<llvm::Constant *, llvm::GlobalVariable*>, 4>
ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF = nullptr)
/// 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)
ConstantEmitter(const ConstantEmitter &other) = delete;
ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
/// Is the current emission context abstract?
bool isAbstract() const {
return Abstract;
/// 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);
/// 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 *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);
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);
void initializeNonAbstract(LangAS destAS) {
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);