ConstantEmitter.h

Go to the documentation of this file.

//===--- 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