clang  11.0.0git
ConstantEmitter.h
Go to the documentation of this file.
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 
24 public:
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;
46 
48  PlaceholderAddresses;
49 
50 public:
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.
58  : CGM(CGF.CGM), CGF(&CGF) {}
59 
60  ConstantEmitter(const ConstantEmitter &other) = delete;
61  ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
62 
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 *tryEmitConstantExpr(const ConstantExpr *CE);
114 
115  llvm::Constant *emitNullForMemory(QualType T) {
116  return emitNullForMemory(CGM, T);
117  }
118  llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) {
119  return emitForMemory(CGM, C, T);
120  }
121 
122  static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T);
123  static llvm::Constant *emitForMemory(CodeGenModule &CGM, llvm::Constant *C,
124  QualType T);
125 
126  // These are private helper routines of the constant emitter that
127  // can't actually be private because things are split out into helper
128  // functions and classes.
129 
130  llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D);
131 
132  llvm::Constant *tryEmitPrivate(const Expr *E, QualType T);
133  llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T);
134 
135  llvm::Constant *tryEmitPrivate(const APValue &value, QualType T);
136  llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T);
137 
138  /// Get the address of the current location. This is a constant
139  /// that will resolve, after finalization, to the address of the
140  /// 'signal' value that is registered with the emitter later.
141  llvm::GlobalValue *getCurrentAddrPrivate();
142 
143  /// Register a 'signal' value with the emitter to inform it where to
144  /// resolve a placeholder. The signal value must be unique in the
145  /// initializer; it might, for example, be the address of a global that
146  /// refers to the current-address value in its own initializer.
147  ///
148  /// Uses of the placeholder must be properly anchored before finalizing
149  /// the emitter, e.g. by being installed as the initializer of a global
150  /// variable. That is, it must be possible to replaceAllUsesWith
151  /// the placeholder with the proper address of the signal.
152  void registerCurrentAddrPrivate(llvm::Constant *signal,
153  llvm::GlobalValue *placeholder);
154 
155 private:
156  void initializeNonAbstract(LangAS destAS) {
157  assert(!InitializedNonAbstract);
158  InitializedNonAbstract = true;
159  DestAddressSpace = destAS;
160  }
161  llvm::Constant *markIfFailed(llvm::Constant *init) {
162  if (!init)
163  Failed = true;
164  return init;
165  }
166 
167  struct AbstractState {
168  bool OldValue;
169  size_t OldPlaceholdersSize;
170  };
171  AbstractState pushAbstract() {
172  AbstractState saved = { Abstract, PlaceholderAddresses.size() };
173  Abstract = true;
174  return saved;
175  }
176  llvm::Constant *validateAndPopAbstract(llvm::Constant *C, AbstractState save);
177 };
178 
179 }
180 }
181 
182 #endif
CodeGenFunction *const CGF
A (possibly-)qualified type.
Definition: Type.h:655
llvm::Constant * emitForInitializer(const APValue &value, LangAS destAddrSpace, QualType destType)
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
llvm::Constant * emitForMemory(llvm::Constant *C, QualType T)
llvm::Constant * tryEmitPrivateForVarInit(const VarDecl &D)
Represents a variable declaration or definition.
Definition: Decl.h:820
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)
Try to emit the initializer of the given declaration as an abstract constant.
ConstantEmitter & operator=(const ConstantEmitter &other)=delete
ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF=nullptr)
llvm::Constant * tryEmitPrivate(const Expr *E, QualType T)
llvm::GlobalValue * getCurrentAddrPrivate()
Get the address of the current location.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:987
ConstantEmitter(CodeGenFunction &CGF)
Initialize this emission in the context of the given function.
This represents one expression.
Definition: Expr.h:110
llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)
Encodes a location in the source.
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded...
void registerCurrentAddrPrivate(llvm::Constant *signal, llvm::GlobalValue *placeholder)
Register a 'signal' value with the emitter to inform it where to resolve a placeholder.
llvm::Constant * emitNullForMemory(QualType T)
This class organizes the cross-function state that is used while generating LLVM code.
Dataflow Directional Tag Classes.
llvm::Constant * tryEmitPrivateForMemory(const Expr *E, QualType T)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:115
void finalize(llvm::GlobalVariable *global)
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
bool isAbstract() const
Is the current emission context abstract?
llvm::Constant * tryEmitAbstractForMemory(const Expr *E, QualType T)