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