1 //===--- ConstantEmitter.h - IR constant emission ---------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // A helper class for emitting expressions and values as llvm::Constants
11 // and as initializers for global variables.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H
16 #define LLVM_CLANG_LIB_CODEGEN_CONSTANTEMITTER_H
17 
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 
21 namespace clang {
22 namespace CodeGen {
23 
24 class ConstantEmitter {
25 public:
26   CodeGenModule &CGM;
27   CodeGenFunction *CGF;
28 
29 private:
30   bool Abstract = false;
31 
32   /// Whether non-abstract components of the emitter have been initialized.
33   bool InitializedNonAbstract = false;
34 
35   /// Whether the emitter has been finalized.
36   bool Finalized = false;
37 
38   /// Whether the constant-emission failed.
39   bool Failed = false;
40 
41   /// Whether we're in a constant context.
42   bool InConstantContext = false;
43 
44   /// The AST address space where this (non-abstract) initializer is going.
45   /// Used for generating appropriate placeholders.
46   LangAS DestAddressSpace;
47 
48   llvm::SmallVector<std::pair<llvm::Constant *, llvm::GlobalVariable*>, 4>
49     PlaceholderAddresses;
50 
51 public:
52   ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF = nullptr)
CGM(CGM)53     : CGM(CGM), CGF(CGF) {}
54 
55   /// Initialize this emission in the context of the given function.
56   /// Use this if the expression might contain contextual references like
57   /// block addresses or PredefinedExprs.
ConstantEmitter(CodeGenFunction & CGF)58   ConstantEmitter(CodeGenFunction &CGF)
59     : CGM(CGF.CGM), CGF(&CGF) {}
60 
61   ConstantEmitter(const ConstantEmitter &other) = delete;
62   ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
63 
64   ~ConstantEmitter();
65 
66   /// Is the current emission context abstract?
isAbstract()67   bool isAbstract() const {
68     return Abstract;
69   }
70 
71   /// Try to emit the initiaizer of the given declaration as an abstract
72   /// constant.  If this succeeds, the emission must be finalized.
73   llvm::Constant *tryEmitForInitializer(const VarDecl &D);
74   llvm::Constant *tryEmitForInitializer(const Expr *E, LangAS destAddrSpace,
75                                         QualType destType);
76   llvm::Constant *emitForInitializer(const APValue &value, LangAS destAddrSpace,
77                                      QualType destType);
78 
79   void finalize(llvm::GlobalVariable *global);
80 
81   // All of the "abstract" emission methods below permit the emission to
82   // be immediately discarded without finalizing anything.  Therefore, they
83   // must also promise not to do anything that will, in the future, require
84   // finalization:
85   //
86   //   - using the CGF (if present) for anything other than establishing
87   //     semantic context; for example, an expression with ignored
88   //     side-effects must not be emitted as an abstract expression
89   //
90   //   - doing anything that would not be safe to duplicate within an
91   //     initializer or to propagate to another context; for example,
92   //     side effects, or emitting an initialization that requires a
93   //     reference to its current location.
94 
95   /// Try to emit the initializer of the given declaration as an abstract
96   /// constant.
97   llvm::Constant *tryEmitAbstractForInitializer(const VarDecl &D);
98 
99   /// Emit the result of the given expression as an abstract constant,
100   /// asserting that it succeeded.  This is only safe to do when the
101   /// expression is known to be a constant expression with either a fairly
102   /// simple type or a known simple form.
103   llvm::Constant *emitAbstract(const Expr *E, QualType T);
104   llvm::Constant *emitAbstract(SourceLocation loc, const APValue &value,
105                                QualType T);
106 
107   /// Try to emit the result of the given expression as an abstract constant.
108   llvm::Constant *tryEmitAbstract(const Expr *E, QualType T);
109   llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T);
110 
111   llvm::Constant *tryEmitAbstract(const APValue &value, QualType T);
112   llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T);
113 
emitNullForMemory(QualType T)114   llvm::Constant *emitNullForMemory(QualType T) {
115     return emitNullForMemory(CGM, T);
116   }
emitForMemory(llvm::Constant * C,QualType T)117   llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) {
118     return emitForMemory(CGM, C, T);
119   }
120 
121   static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T);
122   static llvm::Constant *emitForMemory(CodeGenModule &CGM, llvm::Constant *C,
123                                        QualType T);
124 
125   // These are private helper routines of the constant emitter that
126   // can't actually be private because things are split out into helper
127   // functions and classes.
128 
129   llvm::Constant *tryEmitPrivateForVarInit(const VarDecl &D);
130 
131   llvm::Constant *tryEmitPrivate(const Expr *E, QualType T);
132   llvm::Constant *tryEmitPrivateForMemory(const Expr *E, QualType T);
133 
134   llvm::Constant *tryEmitPrivate(const APValue &value, QualType T);
135   llvm::Constant *tryEmitPrivateForMemory(const APValue &value, QualType T);
136 
137   /// Get the address of the current location.  This is a constant
138   /// that will resolve, after finalization, to the address of the
139   /// 'signal' value that is registered with the emitter later.
140   llvm::GlobalValue *getCurrentAddrPrivate();
141 
142   /// Register a 'signal' value with the emitter to inform it where to
143   /// resolve a placeholder.  The signal value must be unique in the
144   /// initializer; it might, for example, be the address of a global that
145   /// refers to the current-address value in its own initializer.
146   ///
147   /// Uses of the placeholder must be properly anchored before finalizing
148   /// the emitter, e.g. by being installed as the initializer of a global
149   /// variable.  That is, it must be possible to replaceAllUsesWith
150   /// the placeholder with the proper address of the signal.
151   void registerCurrentAddrPrivate(llvm::Constant *signal,
152                                   llvm::GlobalValue *placeholder);
153 
154 private:
initializeNonAbstract(LangAS destAS)155   void initializeNonAbstract(LangAS destAS) {
156     assert(!InitializedNonAbstract);
157     InitializedNonAbstract = true;
158     DestAddressSpace = destAS;
159   }
markIfFailed(llvm::Constant * init)160   llvm::Constant *markIfFailed(llvm::Constant *init) {
161     if (!init)
162       Failed = true;
163     return init;
164   }
165 
166   struct AbstractState {
167     bool OldValue;
168     size_t OldPlaceholdersSize;
169   };
pushAbstract()170   AbstractState pushAbstract() {
171     AbstractState saved = { Abstract, PlaceholderAddresses.size() };
172     Abstract = true;
173     return saved;
174   }
175   llvm::Constant *validateAndPopAbstract(llvm::Constant *C, AbstractState save);
176 };
177 
178 }
179 }
180 
181 #endif
182