/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CodeGenFunction.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- 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 | | // This is the internal per-function state used for llvm translation. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H |
14 | | #define LLVM_CLANG_LIB_CODEGEN_CODEGENFUNCTION_H |
15 | | |
16 | | #include "CGBuilder.h" |
17 | | #include "CGDebugInfo.h" |
18 | | #include "CGLoopInfo.h" |
19 | | #include "CGValue.h" |
20 | | #include "CodeGenModule.h" |
21 | | #include "CodeGenPGO.h" |
22 | | #include "EHScopeStack.h" |
23 | | #include "VarBypassDetector.h" |
24 | | #include "clang/AST/CharUnits.h" |
25 | | #include "clang/AST/CurrentSourceLocExprScope.h" |
26 | | #include "clang/AST/ExprCXX.h" |
27 | | #include "clang/AST/ExprObjC.h" |
28 | | #include "clang/AST/ExprOpenMP.h" |
29 | | #include "clang/AST/StmtOpenMP.h" |
30 | | #include "clang/AST/Type.h" |
31 | | #include "clang/Basic/ABI.h" |
32 | | #include "clang/Basic/CapturedStmt.h" |
33 | | #include "clang/Basic/CodeGenOptions.h" |
34 | | #include "clang/Basic/OpenMPKinds.h" |
35 | | #include "clang/Basic/TargetInfo.h" |
36 | | #include "llvm/ADT/ArrayRef.h" |
37 | | #include "llvm/ADT/DenseMap.h" |
38 | | #include "llvm/ADT/MapVector.h" |
39 | | #include "llvm/ADT/SmallVector.h" |
40 | | #include "llvm/Frontend/OpenMP/OMPIRBuilder.h" |
41 | | #include "llvm/IR/ValueHandle.h" |
42 | | #include "llvm/Support/Debug.h" |
43 | | #include "llvm/Transforms/Utils/SanitizerStats.h" |
44 | | |
45 | | namespace llvm { |
46 | | class BasicBlock; |
47 | | class LLVMContext; |
48 | | class MDNode; |
49 | | class SwitchInst; |
50 | | class Twine; |
51 | | class Value; |
52 | | class CanonicalLoopInfo; |
53 | | } |
54 | | |
55 | | namespace clang { |
56 | | class ASTContext; |
57 | | class CXXDestructorDecl; |
58 | | class CXXForRangeStmt; |
59 | | class CXXTryStmt; |
60 | | class Decl; |
61 | | class LabelDecl; |
62 | | class FunctionDecl; |
63 | | class FunctionProtoType; |
64 | | class LabelStmt; |
65 | | class ObjCContainerDecl; |
66 | | class ObjCInterfaceDecl; |
67 | | class ObjCIvarDecl; |
68 | | class ObjCMethodDecl; |
69 | | class ObjCImplementationDecl; |
70 | | class ObjCPropertyImplDecl; |
71 | | class TargetInfo; |
72 | | class VarDecl; |
73 | | class ObjCForCollectionStmt; |
74 | | class ObjCAtTryStmt; |
75 | | class ObjCAtThrowStmt; |
76 | | class ObjCAtSynchronizedStmt; |
77 | | class ObjCAutoreleasePoolStmt; |
78 | | class OMPUseDevicePtrClause; |
79 | | class OMPUseDeviceAddrClause; |
80 | | class SVETypeFlags; |
81 | | class OMPExecutableDirective; |
82 | | |
83 | | namespace analyze_os_log { |
84 | | class OSLogBufferLayout; |
85 | | } |
86 | | |
87 | | namespace CodeGen { |
88 | | class CodeGenTypes; |
89 | | class CGCallee; |
90 | | class CGFunctionInfo; |
91 | | class CGBlockInfo; |
92 | | class CGCXXABI; |
93 | | class BlockByrefHelpers; |
94 | | class BlockByrefInfo; |
95 | | class BlockFieldFlags; |
96 | | class RegionCodeGenTy; |
97 | | class TargetCodeGenInfo; |
98 | | struct OMPTaskDataTy; |
99 | | struct CGCoroData; |
100 | | |
101 | | /// The kind of evaluation to perform on values of a particular |
102 | | /// type. Basically, is the code in CGExprScalar, CGExprComplex, or |
103 | | /// CGExprAgg? |
104 | | /// |
105 | | /// TODO: should vectors maybe be split out into their own thing? |
106 | | enum TypeEvaluationKind { |
107 | | TEK_Scalar, |
108 | | TEK_Complex, |
109 | | TEK_Aggregate |
110 | | }; |
111 | | |
112 | | #define LIST_SANITIZER_CHECKS \ |
113 | | SANITIZER_CHECK(AddOverflow, add_overflow, 0) \ |
114 | | SANITIZER_CHECK(BuiltinUnreachable, builtin_unreachable, 0) \ |
115 | | SANITIZER_CHECK(CFICheckFail, cfi_check_fail, 0) \ |
116 | | SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0) \ |
117 | | SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0) \ |
118 | | SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0) \ |
119 | | SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 1) \ |
120 | | SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0) \ |
121 | | SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0) \ |
122 | | SANITIZER_CHECK(InvalidObjCCast, invalid_objc_cast, 0) \ |
123 | | SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0) \ |
124 | | SANITIZER_CHECK(MissingReturn, missing_return, 0) \ |
125 | | SANITIZER_CHECK(MulOverflow, mul_overflow, 0) \ |
126 | | SANITIZER_CHECK(NegateOverflow, negate_overflow, 0) \ |
127 | | SANITIZER_CHECK(NullabilityArg, nullability_arg, 0) \ |
128 | | SANITIZER_CHECK(NullabilityReturn, nullability_return, 1) \ |
129 | | SANITIZER_CHECK(NonnullArg, nonnull_arg, 0) \ |
130 | | SANITIZER_CHECK(NonnullReturn, nonnull_return, 1) \ |
131 | | SANITIZER_CHECK(OutOfBounds, out_of_bounds, 0) \ |
132 | | SANITIZER_CHECK(PointerOverflow, pointer_overflow, 0) \ |
133 | | SANITIZER_CHECK(ShiftOutOfBounds, shift_out_of_bounds, 0) \ |
134 | | SANITIZER_CHECK(SubOverflow, sub_overflow, 0) \ |
135 | | SANITIZER_CHECK(TypeMismatch, type_mismatch, 1) \ |
136 | | SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0) \ |
137 | | SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0) |
138 | | |
139 | | enum SanitizerHandler { |
140 | | #define SANITIZER_CHECK(Enum, Name, Version) Enum, |
141 | | LIST_SANITIZER_CHECKS |
142 | | #undef SANITIZER_CHECK |
143 | | }; |
144 | | |
145 | | /// Helper class with most of the code for saving a value for a |
146 | | /// conditional expression cleanup. |
147 | | struct DominatingLLVMValue { |
148 | | typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type; |
149 | | |
150 | | /// Answer whether the given value needs extra work to be saved. |
151 | 158 | static bool needsSaving(llvm::Value *value) { |
152 | | // If it's not an instruction, we don't need to save. |
153 | 158 | if (!isa<llvm::Instruction>(value)) return false20 ; |
154 | | |
155 | | // If it's an instruction in the entry block, we don't need to save. |
156 | 138 | llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent(); |
157 | 138 | return (block != &block->getParent()->getEntryBlock()); |
158 | 158 | } |
159 | | |
160 | | static saved_type save(CodeGenFunction &CGF, llvm::Value *value); |
161 | | static llvm::Value *restore(CodeGenFunction &CGF, saved_type value); |
162 | | }; |
163 | | |
164 | | /// A partial specialization of DominatingValue for llvm::Values that |
165 | | /// might be llvm::Instructions. |
166 | | template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue { |
167 | | typedef T *type; |
168 | 31 | static type restore(CodeGenFunction &CGF, saved_type value) { |
169 | 31 | return static_cast<T*>(DominatingLLVMValue::restore(CGF, value)); |
170 | 31 | } |
171 | | }; |
172 | | |
173 | | /// A specialization of DominatingValue for Address. |
174 | | template <> struct DominatingValue<Address> { |
175 | | typedef Address type; |
176 | | |
177 | | struct saved_type { |
178 | | DominatingLLVMValue::saved_type SavedValue; |
179 | | llvm::Type *ElementType; |
180 | | CharUnits Alignment; |
181 | | }; |
182 | | |
183 | 0 | static bool needsSaving(type value) { |
184 | 0 | return DominatingLLVMValue::needsSaving(value.getPointer()); |
185 | 0 | } |
186 | 102 | static saved_type save(CodeGenFunction &CGF, type value) { |
187 | 102 | return { DominatingLLVMValue::save(CGF, value.getPointer()), |
188 | 102 | value.getElementType(), value.getAlignment() }; |
189 | 102 | } |
190 | 116 | static type restore(CodeGenFunction &CGF, saved_type value) { |
191 | 116 | return Address(DominatingLLVMValue::restore(CGF, value.SavedValue), |
192 | 116 | value.ElementType, value.Alignment); |
193 | 116 | } |
194 | | }; |
195 | | |
196 | | /// A specialization of DominatingValue for RValue. |
197 | | template <> struct DominatingValue<RValue> { |
198 | | typedef RValue type; |
199 | | class saved_type { |
200 | | enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral, |
201 | | AggregateAddress, ComplexAddress }; |
202 | | |
203 | | llvm::Value *Value; |
204 | | llvm::Type *ElementType; |
205 | | unsigned K : 3; |
206 | | unsigned Align : 29; |
207 | | saved_type(llvm::Value *v, llvm::Type *e, Kind k, unsigned a = 0) |
208 | 16 | : Value(v), ElementType(e), K(k), Align(a) {} |
209 | | |
210 | | public: |
211 | | static bool needsSaving(RValue value); |
212 | | static saved_type save(CodeGenFunction &CGF, RValue value); |
213 | | RValue restore(CodeGenFunction &CGF); |
214 | | |
215 | | // implementations in CGCleanup.cpp |
216 | | }; |
217 | | |
218 | 0 | static bool needsSaving(type value) { |
219 | 0 | return saved_type::needsSaving(value); |
220 | 0 | } |
221 | 16 | static saved_type save(CodeGenFunction &CGF, type value) { |
222 | 16 | return saved_type::save(CGF, value); |
223 | 16 | } |
224 | 0 | static type restore(CodeGenFunction &CGF, saved_type value) { |
225 | 0 | return value.restore(CGF); |
226 | 0 | } |
227 | | }; |
228 | | |
229 | | /// CodeGenFunction - This class organizes the per-function state that is used |
230 | | /// while generating LLVM code. |
231 | | class CodeGenFunction : public CodeGenTypeCache { |
232 | | CodeGenFunction(const CodeGenFunction &) = delete; |
233 | | void operator=(const CodeGenFunction &) = delete; |
234 | | |
235 | | friend class CGCXXABI; |
236 | | public: |
237 | | /// A jump destination is an abstract label, branching to which may |
238 | | /// require a jump out through normal cleanups. |
239 | | struct JumpDest { |
240 | 1.29M | JumpDest() : Block(nullptr), Index(0) {} |
241 | | JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth, |
242 | | unsigned Index) |
243 | 422k | : Block(Block), ScopeDepth(Depth), Index(Index) {} |
244 | | |
245 | 476k | bool isValid() const { return Block != nullptr; } |
246 | 1.45M | llvm::BasicBlock *getBlock() const { return Block; } |
247 | 200k | EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; } |
248 | 7.65k | unsigned getDestIndex() const { return Index; } |
249 | | |
250 | | // This should be used cautiously. |
251 | 146 | void setScopeDepth(EHScopeStack::stable_iterator depth) { |
252 | 146 | ScopeDepth = depth; |
253 | 146 | } |
254 | | |
255 | | private: |
256 | | llvm::BasicBlock *Block; |
257 | | EHScopeStack::stable_iterator ScopeDepth; |
258 | | unsigned Index; |
259 | | }; |
260 | | |
261 | | CodeGenModule &CGM; // Per-module state. |
262 | | const TargetInfo &Target; |
263 | | |
264 | | // For EH/SEH outlined funclets, this field points to parent's CGF |
265 | | CodeGenFunction *ParentCGF = nullptr; |
266 | | |
267 | | typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy; |
268 | | LoopInfoStack LoopStack; |
269 | | CGBuilderTy Builder; |
270 | | |
271 | | // Stores variables for which we can't generate correct lifetime markers |
272 | | // because of jumps. |
273 | | VarBypassDetector Bypasses; |
274 | | |
275 | | /// List of recently emitted OMPCanonicalLoops. |
276 | | /// |
277 | | /// Since OMPCanonicalLoops are nested inside other statements (in particular |
278 | | /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested |
279 | | /// loops), we cannot directly call OMPEmitOMPCanonicalLoop and receive its |
280 | | /// llvm::CanonicalLoopInfo. Instead, we call EmitStmt and any |
281 | | /// OMPEmitOMPCanonicalLoop called by it will add its CanonicalLoopInfo to |
282 | | /// this stack when done. Entering a new loop requires clearing this list; it |
283 | | /// either means we start parsing a new loop nest (in which case the previous |
284 | | /// loop nest goes out of scope) or a second loop in the same level in which |
285 | | /// case it would be ambiguous into which of the two (or more) loops the loop |
286 | | /// nest would extend. |
287 | | SmallVector<llvm::CanonicalLoopInfo *, 4> OMPLoopNestStack; |
288 | | |
289 | | /// Number of nested loop to be consumed by the last surrounding |
290 | | /// loop-associated directive. |
291 | | int ExpectedOMPLoopDepth = 0; |
292 | | |
293 | | // CodeGen lambda for loops and support for ordered clause |
294 | | typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &, |
295 | | JumpDest)> |
296 | | CodeGenLoopTy; |
297 | | typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation, |
298 | | const unsigned, const bool)> |
299 | | CodeGenOrderedTy; |
300 | | |
301 | | // Codegen lambda for loop bounds in worksharing loop constructs |
302 | | typedef llvm::function_ref<std::pair<LValue, LValue>( |
303 | | CodeGenFunction &, const OMPExecutableDirective &S)> |
304 | | CodeGenLoopBoundsTy; |
305 | | |
306 | | // Codegen lambda for loop bounds in dispatch-based loop implementation |
307 | | typedef llvm::function_ref<std::pair<llvm::Value *, llvm::Value *>( |
308 | | CodeGenFunction &, const OMPExecutableDirective &S, Address LB, |
309 | | Address UB)> |
310 | | CodeGenDispatchBoundsTy; |
311 | | |
312 | | /// CGBuilder insert helper. This function is called after an |
313 | | /// instruction is created using Builder. |
314 | | void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, |
315 | | llvm::BasicBlock *BB, |
316 | | llvm::BasicBlock::iterator InsertPt) const; |
317 | | |
318 | | /// CurFuncDecl - Holds the Decl for the current outermost |
319 | | /// non-closure context. |
320 | | const Decl *CurFuncDecl; |
321 | | /// CurCodeDecl - This is the inner-most code context, which includes blocks. |
322 | | const Decl *CurCodeDecl; |
323 | | const CGFunctionInfo *CurFnInfo; |
324 | | QualType FnRetTy; |
325 | | llvm::Function *CurFn = nullptr; |
326 | | |
327 | | /// Save Parameter Decl for coroutine. |
328 | | llvm::SmallVector<const ParmVarDecl *, 4> FnArgs; |
329 | | |
330 | | // Holds coroutine data if the current function is a coroutine. We use a |
331 | | // wrapper to manage its lifetime, so that we don't have to define CGCoroData |
332 | | // in this header. |
333 | | struct CGCoroInfo { |
334 | | std::unique_ptr<CGCoroData> Data; |
335 | | CGCoroInfo(); |
336 | | ~CGCoroInfo(); |
337 | | }; |
338 | | CGCoroInfo CurCoro; |
339 | | |
340 | 383 | bool isCoroutine() const { |
341 | 383 | return CurCoro.Data != nullptr; |
342 | 383 | } |
343 | | |
344 | | /// CurGD - The GlobalDecl for the current function being compiled. |
345 | | GlobalDecl CurGD; |
346 | | |
347 | | /// PrologueCleanupDepth - The cleanup depth enclosing all the |
348 | | /// cleanups associated with the parameters. |
349 | | EHScopeStack::stable_iterator PrologueCleanupDepth; |
350 | | |
351 | | /// ReturnBlock - Unified return block. |
352 | | JumpDest ReturnBlock; |
353 | | |
354 | | /// ReturnValue - The temporary alloca to hold the return |
355 | | /// value. This is invalid iff the function has no return value. |
356 | | Address ReturnValue = Address::invalid(); |
357 | | |
358 | | /// ReturnValuePointer - The temporary alloca to hold a pointer to sret. |
359 | | /// This is invalid if sret is not in use. |
360 | | Address ReturnValuePointer = Address::invalid(); |
361 | | |
362 | | /// If a return statement is being visited, this holds the return statment's |
363 | | /// result expression. |
364 | | const Expr *RetExpr = nullptr; |
365 | | |
366 | | /// Return true if a label was seen in the current scope. |
367 | 32.2k | bool hasLabelBeenSeenInCurrentScope() const { |
368 | 32.2k | if (CurLexicalScope) |
369 | 11.0k | return CurLexicalScope->hasLabels(); |
370 | 21.2k | return !LabelMap.empty(); |
371 | 32.2k | } |
372 | | |
373 | | /// AllocaInsertPoint - This is an instruction in the entry block before which |
374 | | /// we prefer to insert allocas. |
375 | | llvm::AssertingVH<llvm::Instruction> AllocaInsertPt; |
376 | | |
377 | | private: |
378 | | /// PostAllocaInsertPt - This is a place in the prologue where code can be |
379 | | /// inserted that will be dominated by all the static allocas. This helps |
380 | | /// achieve two things: |
381 | | /// 1. Contiguity of all static allocas (within the prologue) is maintained. |
382 | | /// 2. All other prologue code (which are dominated by static allocas) do |
383 | | /// appear in the source order immediately after all static allocas. |
384 | | /// |
385 | | /// PostAllocaInsertPt will be lazily created when it is *really* required. |
386 | | llvm::AssertingVH<llvm::Instruction> PostAllocaInsertPt = nullptr; |
387 | | |
388 | | public: |
389 | | /// Return PostAllocaInsertPt. If it is not yet created, then insert it |
390 | | /// immediately after AllocaInsertPt. |
391 | 4.08k | llvm::Instruction *getPostAllocaInsertPoint() { |
392 | 4.08k | if (!PostAllocaInsertPt) { |
393 | 1.51k | assert(AllocaInsertPt && |
394 | 1.51k | "Expected static alloca insertion point at function prologue"); |
395 | 0 | assert(AllocaInsertPt->getParent()->isEntryBlock() && |
396 | 1.51k | "EBB should be entry block of the current code gen function"); |
397 | 0 | PostAllocaInsertPt = AllocaInsertPt->clone(); |
398 | 1.51k | PostAllocaInsertPt->setName("postallocapt"); |
399 | 1.51k | PostAllocaInsertPt->insertAfter(AllocaInsertPt); |
400 | 1.51k | } |
401 | | |
402 | 0 | return PostAllocaInsertPt; |
403 | 4.08k | } |
404 | | |
405 | | /// API for captured statement code generation. |
406 | | class CGCapturedStmtInfo { |
407 | | public: |
408 | | explicit CGCapturedStmtInfo(CapturedRegionKind K = CR_Default) |
409 | 43.6k | : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {} |
410 | | explicit CGCapturedStmtInfo(const CapturedStmt &S, |
411 | | CapturedRegionKind K = CR_Default) |
412 | 25.5k | : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) { |
413 | | |
414 | 25.5k | RecordDecl::field_iterator Field = |
415 | 25.5k | S.getCapturedRecordDecl()->field_begin(); |
416 | 25.5k | for (CapturedStmt::const_capture_iterator I = S.capture_begin(), |
417 | 25.5k | E = S.capture_end(); |
418 | 63.8k | I != E; ++I, ++Field38.2k ) { |
419 | 38.2k | if (I->capturesThis()) |
420 | 1.86k | CXXThisFieldDecl = *Field; |
421 | 36.3k | else if (I->capturesVariable()) |
422 | 14.9k | CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field; |
423 | 21.3k | else if (I->capturesVariableByCopy()) |
424 | 18.2k | CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field; |
425 | 38.2k | } |
426 | 25.5k | } |
427 | | |
428 | | virtual ~CGCapturedStmtInfo(); |
429 | | |
430 | 29.7k | CapturedRegionKind getKind() const { return Kind; } |
431 | | |
432 | 1.02k | virtual void setContextValue(llvm::Value *V) { ThisValue = V; } |
433 | | // Retrieve the value of the context parameter. |
434 | 2.08k | virtual llvm::Value *getContextValue() const { return ThisValue; } |
435 | | |
436 | | /// Lookup the captured field decl for a variable. |
437 | 30.7k | virtual const FieldDecl *lookup(const VarDecl *VD) const { |
438 | 30.7k | return CaptureFields.lookup(VD->getCanonicalDecl()); |
439 | 30.7k | } |
440 | | |
441 | 1.02k | bool isCXXThisExprCaptured() const { return getThisFieldDecl() != nullptr; } |
442 | 1.05k | virtual FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; } |
443 | | |
444 | 0 | static bool classof(const CGCapturedStmtInfo *) { |
445 | 0 | return true; |
446 | 0 | } |
447 | | |
448 | | /// Emit the captured statement body. |
449 | 123 | virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) { |
450 | 123 | CGF.incrementProfileCounter(S); |
451 | 123 | CGF.EmitStmt(S); |
452 | 123 | } |
453 | | |
454 | | /// Get the name of the capture helper. |
455 | 123 | virtual StringRef getHelperName() const { return "__captured_stmt"; } |
456 | | |
457 | | /// Get the CaptureFields |
458 | 6 | llvm::SmallDenseMap<const VarDecl *, FieldDecl *> getCaptureFields() { |
459 | 6 | return CaptureFields; |
460 | 6 | } |
461 | | |
462 | | private: |
463 | | /// The kind of captured statement being generated. |
464 | | CapturedRegionKind Kind; |
465 | | |
466 | | /// Keep the map between VarDecl and FieldDecl. |
467 | | llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields; |
468 | | |
469 | | /// The base address of the captured record, passed in as the first |
470 | | /// argument of the parallel region function. |
471 | | llvm::Value *ThisValue; |
472 | | |
473 | | /// Captured 'this' type. |
474 | | FieldDecl *CXXThisFieldDecl; |
475 | | }; |
476 | | CGCapturedStmtInfo *CapturedStmtInfo = nullptr; |
477 | | |
478 | | /// RAII for correct setting/restoring of CapturedStmtInfo. |
479 | | class CGCapturedStmtRAII { |
480 | | private: |
481 | | CodeGenFunction &CGF; |
482 | | CGCapturedStmtInfo *PrevCapturedStmtInfo; |
483 | | public: |
484 | | CGCapturedStmtRAII(CodeGenFunction &CGF, |
485 | | CGCapturedStmtInfo *NewCapturedStmtInfo) |
486 | 25.8k | : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) { |
487 | 25.8k | CGF.CapturedStmtInfo = NewCapturedStmtInfo; |
488 | 25.8k | } |
489 | 25.8k | ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; } |
490 | | }; |
491 | | |
492 | | /// An abstract representation of regular/ObjC call/message targets. |
493 | | class AbstractCallee { |
494 | | /// The function declaration of the callee. |
495 | | const Decl *CalleeDecl; |
496 | | |
497 | | public: |
498 | 2.70k | AbstractCallee() : CalleeDecl(nullptr) {} |
499 | 302k | AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {} |
500 | 11.9k | AbstractCallee(const ObjCMethodDecl *OMD) : CalleeDecl(OMD) {} |
501 | 402k | bool hasFunctionDecl() const { |
502 | 402k | return isa_and_nonnull<FunctionDecl>(CalleeDecl); |
503 | 402k | } |
504 | 402k | const Decl *getDecl() const { return CalleeDecl; } |
505 | 371k | unsigned getNumParams() const { |
506 | 371k | if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl)) |
507 | 371k | return FD->getNumParams(); |
508 | 8 | return cast<ObjCMethodDecl>(CalleeDecl)->param_size(); |
509 | 371k | } |
510 | 284k | const ParmVarDecl *getParamDecl(unsigned I) const { |
511 | 284k | if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecl)) |
512 | 284k | return FD->getParamDecl(I); |
513 | 7 | return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I); |
514 | 284k | } |
515 | | }; |
516 | | |
517 | | /// Sanitizers enabled for this function. |
518 | | SanitizerSet SanOpts; |
519 | | |
520 | | /// True if CodeGen currently emits code implementing sanitizer checks. |
521 | | bool IsSanitizerScope = false; |
522 | | |
523 | | /// RAII object to set/unset CodeGenFunction::IsSanitizerScope. |
524 | | class SanitizerScope { |
525 | | CodeGenFunction *CGF; |
526 | | public: |
527 | | SanitizerScope(CodeGenFunction *CGF); |
528 | | ~SanitizerScope(); |
529 | | }; |
530 | | |
531 | | /// In C++, whether we are code generating a thunk. This controls whether we |
532 | | /// should emit cleanups. |
533 | | bool CurFuncIsThunk = false; |
534 | | |
535 | | /// In ARC, whether we should autorelease the return value. |
536 | | bool AutoreleaseResult = false; |
537 | | |
538 | | /// Whether we processed a Microsoft-style asm block during CodeGen. These can |
539 | | /// potentially set the return value. |
540 | | bool SawAsmBlock = false; |
541 | | |
542 | | const NamedDecl *CurSEHParent = nullptr; |
543 | | |
544 | | /// True if the current function is an outlined SEH helper. This can be a |
545 | | /// finally block or filter expression. |
546 | | bool IsOutlinedSEHHelper = false; |
547 | | |
548 | | /// True if CodeGen currently emits code inside presereved access index |
549 | | /// region. |
550 | | bool IsInPreservedAIRegion = false; |
551 | | |
552 | | /// True if the current statement has nomerge attribute. |
553 | | bool InNoMergeAttributedStmt = false; |
554 | | |
555 | | /// True if the current statement has noinline attribute. |
556 | | bool InNoInlineAttributedStmt = false; |
557 | | |
558 | | /// True if the current statement has always_inline attribute. |
559 | | bool InAlwaysInlineAttributedStmt = false; |
560 | | |
561 | | // The CallExpr within the current statement that the musttail attribute |
562 | | // applies to. nullptr if there is no 'musttail' on the current statement. |
563 | | const CallExpr *MustTailCall = nullptr; |
564 | | |
565 | | /// Returns true if a function must make progress, which means the |
566 | | /// mustprogress attribute can be added. |
567 | 233k | bool checkIfFunctionMustProgress() { |
568 | 233k | if (CGM.getCodeGenOpts().getFiniteLoops() == |
569 | 233k | CodeGenOptions::FiniteLoopsKind::Never) |
570 | 115 | return false; |
571 | | |
572 | | // C++11 and later guarantees that a thread eventually will do one of the |
573 | | // following (6.9.2.3.1 in C++11): |
574 | | // - terminate, |
575 | | // - make a call to a library I/O function, |
576 | | // - perform an access through a volatile glvalue, or |
577 | | // - perform a synchronization operation or an atomic operation. |
578 | | // |
579 | | // Hence each function is 'mustprogress' in C++11 or later. |
580 | 232k | return getLangOpts().CPlusPlus11; |
581 | 233k | } |
582 | | |
583 | | /// Returns true if a loop must make progress, which means the mustprogress |
584 | | /// attribute can be added. \p HasConstantCond indicates whether the branch |
585 | | /// condition is a known constant. |
586 | 19.5k | bool checkIfLoopMustProgress(bool HasConstantCond) { |
587 | 19.5k | if (CGM.getCodeGenOpts().getFiniteLoops() == |
588 | 19.5k | CodeGenOptions::FiniteLoopsKind::Always) |
589 | 155 | return true; |
590 | 19.3k | if (CGM.getCodeGenOpts().getFiniteLoops() == |
591 | 19.3k | CodeGenOptions::FiniteLoopsKind::Never) |
592 | 155 | return false; |
593 | | |
594 | | // If the containing function must make progress, loops also must make |
595 | | // progress (as in C++11 and later). |
596 | 19.2k | if (checkIfFunctionMustProgress()) |
597 | 18.1k | return true; |
598 | | |
599 | | // Now apply rules for plain C (see 6.8.5.6 in C11). |
600 | | // Loops with constant conditions do not have to make progress in any C |
601 | | // version. |
602 | 1.08k | if (HasConstantCond) |
603 | 278 | return false; |
604 | | |
605 | | // Loops with non-constant conditions must make progress in C11 and later. |
606 | 809 | return getLangOpts().C11; |
607 | 1.08k | } |
608 | | |
609 | | const CodeGen::CGBlockInfo *BlockInfo = nullptr; |
610 | | llvm::Value *BlockPointer = nullptr; |
611 | | |
612 | | llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields; |
613 | | FieldDecl *LambdaThisCaptureField = nullptr; |
614 | | |
615 | | /// A mapping from NRVO variables to the flags used to indicate |
616 | | /// when the NRVO has been applied to this variable. |
617 | | llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags; |
618 | | |
619 | | EHScopeStack EHStack; |
620 | | llvm::SmallVector<char, 256> LifetimeExtendedCleanupStack; |
621 | | llvm::SmallVector<const JumpDest *, 2> SEHTryEpilogueStack; |
622 | | |
623 | | llvm::Instruction *CurrentFuncletPad = nullptr; |
624 | | |
625 | | class CallLifetimeEnd final : public EHScopeStack::Cleanup { |
626 | 0 | bool isRedundantBeforeReturn() override { return true; } |
627 | | |
628 | | llvm::Value *Addr; |
629 | | llvm::Value *Size; |
630 | | |
631 | | public: |
632 | | CallLifetimeEnd(Address addr, llvm::Value *size) |
633 | 4.53k | : Addr(addr.getPointer()), Size(size) {} |
634 | | |
635 | 4.67k | void Emit(CodeGenFunction &CGF, Flags flags) override { |
636 | 4.67k | CGF.EmitLifetimeEnd(Size, Addr); |
637 | 4.67k | } |
638 | | }; |
639 | | |
640 | | /// Header for data within LifetimeExtendedCleanupStack. |
641 | | struct LifetimeExtendedCleanupHeader { |
642 | | /// The size of the following cleanup object. |
643 | | unsigned Size; |
644 | | /// The kind of cleanup to push: a value from the CleanupKind enumeration. |
645 | | unsigned Kind : 31; |
646 | | /// Whether this is a conditional cleanup. |
647 | | unsigned IsConditional : 1; |
648 | | |
649 | 1.13k | size_t getSize() const { return Size; } |
650 | 568 | CleanupKind getKind() const { return (CleanupKind)Kind; } |
651 | 568 | bool isConditional() const { return IsConditional; } |
652 | | }; |
653 | | |
654 | | /// i32s containing the indexes of the cleanup destinations. |
655 | | Address NormalCleanupDest = Address::invalid(); |
656 | | |
657 | | unsigned NextCleanupDestIndex = 1; |
658 | | |
659 | | /// EHResumeBlock - Unified block containing a call to llvm.eh.resume. |
660 | | llvm::BasicBlock *EHResumeBlock = nullptr; |
661 | | |
662 | | /// The exception slot. All landing pads write the current exception pointer |
663 | | /// into this alloca. |
664 | | llvm::Value *ExceptionSlot = nullptr; |
665 | | |
666 | | /// The selector slot. Under the MandatoryCleanup model, all landing pads |
667 | | /// write the current selector value into this alloca. |
668 | | llvm::AllocaInst *EHSelectorSlot = nullptr; |
669 | | |
670 | | /// A stack of exception code slots. Entering an __except block pushes a slot |
671 | | /// on the stack and leaving pops one. The __exception_code() intrinsic loads |
672 | | /// a value from the top of the stack. |
673 | | SmallVector<Address, 1> SEHCodeSlotStack; |
674 | | |
675 | | /// Value returned by __exception_info intrinsic. |
676 | | llvm::Value *SEHInfo = nullptr; |
677 | | |
678 | | /// Emits a landing pad for the current EH stack. |
679 | | llvm::BasicBlock *EmitLandingPad(); |
680 | | |
681 | | llvm::BasicBlock *getInvokeDestImpl(); |
682 | | |
683 | | /// Parent loop-based directive for scan directive. |
684 | | const OMPExecutableDirective *OMPParentLoopDirectiveForScan = nullptr; |
685 | | llvm::BasicBlock *OMPBeforeScanBlock = nullptr; |
686 | | llvm::BasicBlock *OMPAfterScanBlock = nullptr; |
687 | | llvm::BasicBlock *OMPScanExitBlock = nullptr; |
688 | | llvm::BasicBlock *OMPScanDispatch = nullptr; |
689 | | bool OMPFirstScanLoop = false; |
690 | | |
691 | | /// Manages parent directive for scan directives. |
692 | | class ParentLoopDirectiveForScanRegion { |
693 | | CodeGenFunction &CGF; |
694 | | const OMPExecutableDirective *ParentLoopDirectiveForScan; |
695 | | |
696 | | public: |
697 | | ParentLoopDirectiveForScanRegion( |
698 | | CodeGenFunction &CGF, |
699 | | const OMPExecutableDirective &ParentLoopDirectiveForScan) |
700 | | : CGF(CGF), |
701 | 3.67k | ParentLoopDirectiveForScan(CGF.OMPParentLoopDirectiveForScan) { |
702 | 3.67k | CGF.OMPParentLoopDirectiveForScan = &ParentLoopDirectiveForScan; |
703 | 3.67k | } |
704 | 3.67k | ~ParentLoopDirectiveForScanRegion() { |
705 | 3.67k | CGF.OMPParentLoopDirectiveForScan = ParentLoopDirectiveForScan; |
706 | 3.67k | } |
707 | | }; |
708 | | |
709 | | template <class T> |
710 | 309 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { |
711 | 309 | return DominatingValue<T>::save(*this, value); |
712 | 309 | } clang::CodeGen::DominatingValue<clang::CodeGen::Address>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<clang::CodeGen::Address>(clang::CodeGen::Address) Line | Count | Source | 710 | 102 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { | 711 | 102 | return DominatingValue<T>::save(*this, value); | 712 | 102 | } |
clang::CodeGen::DominatingValue<clang::QualType>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<clang::QualType>(clang::QualType) Line | Count | Source | 710 | 61 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { | 711 | 61 | return DominatingValue<T>::save(*this, value); | 712 | 61 | } |
clang::CodeGen::DominatingValue<llvm::Value*>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<llvm::Value*>(llvm::Value*) Line | Count | Source | 710 | 40 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { | 711 | 40 | return DominatingValue<T>::save(*this, value); | 712 | 40 | } |
clang::CodeGen::DominatingValue<void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)>(void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)) Line | Count | Source | 710 | 53 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { | 711 | 53 | return DominatingValue<T>::save(*this, value); | 712 | 53 | } |
clang::CodeGen::DominatingValue<bool>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<bool>(bool) Line | Count | Source | 710 | 53 | typename DominatingValue<T>::saved_type saveValueInCond(T value) { | 711 | 53 | return DominatingValue<T>::save(*this, value); | 712 | 53 | } |
Unexecuted instantiation: clang::CodeGen::DominatingValue<clang::CharUnits>::saved_type clang::CodeGen::CodeGenFunction::saveValueInCond<clang::CharUnits>(clang::CharUnits) |
713 | | |
714 | | class CGFPOptionsRAII { |
715 | | public: |
716 | | CGFPOptionsRAII(CodeGenFunction &CGF, FPOptions FPFeatures); |
717 | | CGFPOptionsRAII(CodeGenFunction &CGF, const Expr *E); |
718 | | ~CGFPOptionsRAII(); |
719 | | |
720 | | private: |
721 | | void ConstructorHelper(FPOptions FPFeatures); |
722 | | CodeGenFunction &CGF; |
723 | | FPOptions OldFPFeatures; |
724 | | llvm::fp::ExceptionBehavior OldExcept; |
725 | | llvm::RoundingMode OldRounding; |
726 | | Optional<CGBuilderTy::FastMathFlagGuard> FMFGuard; |
727 | | }; |
728 | | FPOptions CurFPFeatures; |
729 | | |
730 | | public: |
731 | | /// ObjCEHValueStack - Stack of Objective-C exception values, used for |
732 | | /// rethrows. |
733 | | SmallVector<llvm::Value*, 8> ObjCEHValueStack; |
734 | | |
735 | | /// A class controlling the emission of a finally block. |
736 | | class FinallyInfo { |
737 | | /// Where the catchall's edge through the cleanup should go. |
738 | | JumpDest RethrowDest; |
739 | | |
740 | | /// A function to call to enter the catch. |
741 | | llvm::FunctionCallee BeginCatchFn; |
742 | | |
743 | | /// An i1 variable indicating whether or not the @finally is |
744 | | /// running for an exception. |
745 | | llvm::AllocaInst *ForEHVar; |
746 | | |
747 | | /// An i8* variable into which the exception pointer to rethrow |
748 | | /// has been saved. |
749 | | llvm::AllocaInst *SavedExnVar; |
750 | | |
751 | | public: |
752 | | void enter(CodeGenFunction &CGF, const Stmt *Finally, |
753 | | llvm::FunctionCallee beginCatchFn, |
754 | | llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn); |
755 | | void exit(CodeGenFunction &CGF); |
756 | | }; |
757 | | |
758 | | /// Returns true inside SEH __try blocks. |
759 | 366k | bool isSEHTryScope() const { return !SEHTryEpilogueStack.empty(); } |
760 | | |
761 | | /// Returns true while emitting a cleanuppad. |
762 | 366k | bool isCleanupPadScope() const { |
763 | 366k | return CurrentFuncletPad && isa<llvm::CleanupPadInst>(CurrentFuncletPad)128 ; |
764 | 366k | } |
765 | | |
766 | | /// pushFullExprCleanup - Push a cleanup to be run at the end of the |
767 | | /// current full-expression. Safe against the possibility that |
768 | | /// we're currently inside a conditionally-evaluated expression. |
769 | | template <class T, class... As> |
770 | 8.68k | void pushFullExprCleanup(CleanupKind kind, As... A) { |
771 | | // If we're not in a conditional branch, or if none of the |
772 | | // arguments requires saving, then use the unconditional cleanup. |
773 | 8.68k | if (!isInConditionalBranch()) |
774 | 8.58k | return EHStack.pushCleanup<T>(kind, A...); |
775 | | |
776 | | // Stash values in a tuple so we can guarantee the order of saves. |
777 | 101 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; |
778 | 101 | SavedTuple Saved{saveValueInCond(A)...}; |
779 | | |
780 | 101 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; |
781 | 101 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); |
782 | 101 | initFullExprCleanup(); |
783 | 101 | } CGCall.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::DestroyUnpassedArg, clang::CodeGen::Address, clang::QualType>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, clang::QualType) Line | Count | Source | 770 | 186 | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 186 | if (!isInConditionalBranch()) | 774 | 178 | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 8 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 8 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | | | 780 | 8 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 8 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 8 | initFullExprCleanup(); | 783 | 8 | } |
void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<clang::CodeGen::CodeGenFunction::CallLifetimeEnd, clang::CodeGen::Address, llvm::Value*>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, llvm::Value*) Line | Count | Source | 770 | 719 | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 719 | if (!isInConditionalBranch()) | 774 | 707 | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 12 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 12 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | | | 780 | 12 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 12 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 12 | initFullExprCleanup(); | 783 | 12 | } |
CGDecl.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::DestroyObject, clang::CodeGen::Address, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool) Line | Count | Source | 770 | 4.86k | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 4.86k | if (!isInConditionalBranch()) | 774 | 4.81k | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 53 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 53 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | | | 780 | 53 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 53 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 53 | initFullExprCleanup(); | 783 | 53 | } |
CGDecl.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::IrregularPartialArrayDestroy, llvm::Value*, clang::CodeGen::Address, clang::QualType, clang::CharUnits, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)>(clang::CodeGen::CleanupKind, llvm::Value*, clang::CodeGen::Address, clang::QualType, clang::CharUnits, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)) Line | Count | Source | 770 | 72 | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 72 | if (!isInConditionalBranch()) | 774 | 72 | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 0 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 0 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | |
| 780 | 0 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 0 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 0 | initFullExprCleanup(); | 783 | 0 | } |
CGDecl.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::RegularPartialArrayDestroy, llvm::Value*, llvm::Value*, clang::QualType, clang::CharUnits, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)>(clang::CodeGen::CleanupKind, llvm::Value*, llvm::Value*, clang::QualType, clang::CharUnits, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType)) Line | Count | Source | 770 | 1.89k | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 1.89k | if (!isInConditionalBranch()) | 774 | 1.89k | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 0 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 0 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | |
| 780 | 0 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 0 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 0 | initFullExprCleanup(); | 783 | 0 | } |
CGException.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::FreeException, llvm::Value*>(clang::CodeGen::CleanupKind, llvm::Value*) Line | Count | Source | 770 | 646 | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 646 | if (!isInConditionalBranch()) | 774 | 633 | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 13 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 13 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | | | 780 | 13 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 13 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 13 | initFullExprCleanup(); | 783 | 13 | } |
CGObjC.cpp:void clang::CodeGen::CodeGenFunction::pushFullExprCleanup<(anonymous namespace)::CallObjCRelease, llvm::Value*>(clang::CodeGen::CleanupKind, llvm::Value*) Line | Count | Source | 770 | 297 | void pushFullExprCleanup(CleanupKind kind, As... A) { | 771 | | // If we're not in a conditional branch, or if none of the | 772 | | // arguments requires saving, then use the unconditional cleanup. | 773 | 297 | if (!isInConditionalBranch()) | 774 | 282 | return EHStack.pushCleanup<T>(kind, A...); | 775 | | | 776 | | // Stash values in a tuple so we can guarantee the order of saves. | 777 | 15 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 778 | 15 | SavedTuple Saved{saveValueInCond(A)...}; | 779 | | | 780 | 15 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 781 | 15 | EHStack.pushCleanupTuple<CleanupType>(kind, Saved); | 782 | 15 | initFullExprCleanup(); | 783 | 15 | } |
|
784 | | |
785 | | /// Queue a cleanup to be pushed after finishing the current full-expression, |
786 | | /// potentially with an active flag. |
787 | | template <class T, class... As> |
788 | 21 | void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) { |
789 | 21 | if (!isInConditionalBranch()) |
790 | 21 | return pushCleanupAfterFullExprWithActiveFlag<T>(Kind, Address::invalid(), |
791 | 21 | A...); |
792 | | |
793 | 0 | Address ActiveFlag = createCleanupActiveFlag(); |
794 | 0 | assert(!DominatingValue<Address>::needsSaving(ActiveFlag) && |
795 | 0 | "cleanup active flag should never need saving"); |
796 | | |
797 | 0 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; |
798 | 0 | SavedTuple Saved{saveValueInCond(A)...}; |
799 | |
|
800 | 0 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; |
801 | 0 | pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved); |
802 | 0 | } CGBuiltin.cpp:void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExpr<(anonymous namespace)::CallObjCArcUse, llvm::Value*>(clang::CodeGen::CleanupKind, llvm::Value*) Line | Count | Source | 788 | 4 | void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) { | 789 | 4 | if (!isInConditionalBranch()) | 790 | 4 | return pushCleanupAfterFullExprWithActiveFlag<T>(Kind, Address::invalid(), | 791 | 4 | A...); | 792 | | | 793 | 0 | Address ActiveFlag = createCleanupActiveFlag(); | 794 | 0 | assert(!DominatingValue<Address>::needsSaving(ActiveFlag) && | 795 | 0 | "cleanup active flag should never need saving"); | 796 | | | 797 | 0 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 798 | 0 | SavedTuple Saved{saveValueInCond(A)...}; | 799 | |
| 800 | 0 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 801 | 0 | pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved); | 802 | 0 | } |
void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExpr<clang::CodeGen::CodeGenFunction::CallLifetimeEnd, clang::CodeGen::Address, llvm::Value*>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, llvm::Value*) Line | Count | Source | 788 | 17 | void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) { | 789 | 17 | if (!isInConditionalBranch()) | 790 | 17 | return pushCleanupAfterFullExprWithActiveFlag<T>(Kind, Address::invalid(), | 791 | 17 | A...); | 792 | | | 793 | 0 | Address ActiveFlag = createCleanupActiveFlag(); | 794 | 0 | assert(!DominatingValue<Address>::needsSaving(ActiveFlag) && | 795 | 0 | "cleanup active flag should never need saving"); | 796 | | | 797 | 0 | typedef std::tuple<typename DominatingValue<As>::saved_type...> SavedTuple; | 798 | 0 | SavedTuple Saved{saveValueInCond(A)...}; | 799 | |
| 800 | 0 | typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType; | 801 | 0 | pushCleanupAfterFullExprWithActiveFlag<CleanupType>(Kind, ActiveFlag, Saved); | 802 | 0 | } |
|
803 | | |
804 | | template <class T, class... As> |
805 | | void pushCleanupAfterFullExprWithActiveFlag(CleanupKind Kind, |
806 | 568 | Address ActiveFlag, As... A) { |
807 | 568 | LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind, |
808 | 568 | ActiveFlag.isValid()}; |
809 | | |
810 | 568 | size_t OldSize = LifetimeExtendedCleanupStack.size(); |
811 | 568 | LifetimeExtendedCleanupStack.resize( |
812 | 568 | LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size + |
813 | 568 | (Header.IsConditional ? sizeof(ActiveFlag)29 : 0539 )); |
814 | | |
815 | 568 | static_assert(sizeof(Header) % alignof(T) == 0, |
816 | 568 | "Cleanup will be allocated on misaligned address"); |
817 | 568 | char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; |
818 | 568 | new (Buffer) LifetimeExtendedCleanupHeader(Header); |
819 | 568 | new (Buffer + sizeof(Header)) T(A...); |
820 | 568 | if (Header.IsConditional) |
821 | 29 | new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag); |
822 | 568 | } CGBuiltin.cpp:void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<(anonymous namespace)::CallObjCArcUse, llvm::Value*>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, llvm::Value*) Line | Count | Source | 806 | 4 | Address ActiveFlag, As... A) { | 807 | 4 | LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind, | 808 | 4 | ActiveFlag.isValid()}; | 809 | | | 810 | 4 | size_t OldSize = LifetimeExtendedCleanupStack.size(); | 811 | 4 | LifetimeExtendedCleanupStack.resize( | 812 | 4 | LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size + | 813 | 4 | (Header.IsConditional ? sizeof(ActiveFlag)0 : 0)); | 814 | | | 815 | 4 | static_assert(sizeof(Header) % alignof(T) == 0, | 816 | 4 | "Cleanup will be allocated on misaligned address"); | 817 | 4 | char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; | 818 | 4 | new (Buffer) LifetimeExtendedCleanupHeader(Header); | 819 | 4 | new (Buffer + sizeof(Header)) T(A...); | 820 | 4 | if (Header.IsConditional) | 821 | 0 | new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag); | 822 | 4 | } |
Unexecuted instantiation: CGBuiltin.cpp:void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<clang::CodeGen::EHScopeStack::ConditionalCleanup<(anonymous namespace)::CallObjCArcUse, llvm::Value*>, std::__1::tuple<llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*> > > > >(clang::CodeGen::CleanupKind, clang::CodeGen::Address, std::__1::tuple<llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*> > > >) CGDecl.cpp:void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<(anonymous namespace)::DestroyObject, clang::CodeGen::Address, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, clang::CodeGen::Address, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool) Line | Count | Source | 806 | 518 | Address ActiveFlag, As... A) { | 807 | 518 | LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind, | 808 | 518 | ActiveFlag.isValid()}; | 809 | | | 810 | 518 | size_t OldSize = LifetimeExtendedCleanupStack.size(); | 811 | 518 | LifetimeExtendedCleanupStack.resize( | 812 | 518 | LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size + | 813 | 518 | (Header.IsConditional ? sizeof(ActiveFlag)0 : 0)); | 814 | | | 815 | 518 | static_assert(sizeof(Header) % alignof(T) == 0, | 816 | 518 | "Cleanup will be allocated on misaligned address"); | 817 | 518 | char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; | 818 | 518 | new (Buffer) LifetimeExtendedCleanupHeader(Header); | 819 | 518 | new (Buffer + sizeof(Header)) T(A...); | 820 | 518 | if (Header.IsConditional) | 821 | 0 | new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag); | 822 | 518 | } |
CGDecl.cpp:void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<clang::CodeGen::EHScopeStack::ConditionalCleanup<(anonymous namespace)::DestroyObject, clang::CodeGen::Address, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool>, clang::CodeGen::DominatingValue<clang::CodeGen::Address>::saved_type, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, clang::CodeGen::DominatingValue<clang::CodeGen::Address>::saved_type, clang::QualType, void (*)(clang::CodeGen::CodeGenFunction&, clang::CodeGen::Address, clang::QualType), bool) Line | Count | Source | 806 | 29 | Address ActiveFlag, As... A) { | 807 | 29 | LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind, | 808 | 29 | ActiveFlag.isValid()}; | 809 | | | 810 | 29 | size_t OldSize = LifetimeExtendedCleanupStack.size(); | 811 | 29 | LifetimeExtendedCleanupStack.resize( | 812 | 29 | LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size + | 813 | 29 | (Header.IsConditional ? sizeof(ActiveFlag) : 00 )); | 814 | | | 815 | 29 | static_assert(sizeof(Header) % alignof(T) == 0, | 816 | 29 | "Cleanup will be allocated on misaligned address"); | 817 | 29 | char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; | 818 | 29 | new (Buffer) LifetimeExtendedCleanupHeader(Header); | 819 | 29 | new (Buffer + sizeof(Header)) T(A...); | 820 | 29 | if (Header.IsConditional) | 821 | 29 | new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag); | 822 | 29 | } |
void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<clang::CodeGen::CodeGenFunction::CallLifetimeEnd, clang::CodeGen::Address, llvm::Value*>(clang::CodeGen::CleanupKind, clang::CodeGen::Address, clang::CodeGen::Address, llvm::Value*) Line | Count | Source | 806 | 17 | Address ActiveFlag, As... A) { | 807 | 17 | LifetimeExtendedCleanupHeader Header = {sizeof(T), Kind, | 808 | 17 | ActiveFlag.isValid()}; | 809 | | | 810 | 17 | size_t OldSize = LifetimeExtendedCleanupStack.size(); | 811 | 17 | LifetimeExtendedCleanupStack.resize( | 812 | 17 | LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size + | 813 | 17 | (Header.IsConditional ? sizeof(ActiveFlag)0 : 0)); | 814 | | | 815 | 17 | static_assert(sizeof(Header) % alignof(T) == 0, | 816 | 17 | "Cleanup will be allocated on misaligned address"); | 817 | 17 | char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; | 818 | 17 | new (Buffer) LifetimeExtendedCleanupHeader(Header); | 819 | 17 | new (Buffer + sizeof(Header)) T(A...); | 820 | 17 | if (Header.IsConditional) | 821 | 0 | new (Buffer + sizeof(Header) + sizeof(T)) Address(ActiveFlag); | 822 | 17 | } |
Unexecuted instantiation: void clang::CodeGen::CodeGenFunction::pushCleanupAfterFullExprWithActiveFlag<clang::CodeGen::EHScopeStack::ConditionalCleanup<clang::CodeGen::CodeGenFunction::CallLifetimeEnd, clang::CodeGen::Address, llvm::Value*>, std::__1::tuple<clang::CodeGen::DominatingValue<clang::CodeGen::Address>::saved_type, llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*> > > > >(clang::CodeGen::CleanupKind, clang::CodeGen::Address, std::__1::tuple<clang::CodeGen::DominatingValue<clang::CodeGen::Address>::saved_type, llvm::PointerIntPair<llvm::Value*, 1u, bool, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 1u, llvm::PointerLikeTypeTraits<llvm::Value*> > > >) |
823 | | |
824 | | /// Set up the last cleanup that was pushed as a conditional |
825 | | /// full-expression cleanup. |
826 | 107 | void initFullExprCleanup() { |
827 | 107 | initFullExprCleanupWithFlag(createCleanupActiveFlag()); |
828 | 107 | } |
829 | | |
830 | | void initFullExprCleanupWithFlag(Address ActiveFlag); |
831 | | Address createCleanupActiveFlag(); |
832 | | |
833 | | /// PushDestructorCleanup - Push a cleanup to call the |
834 | | /// complete-object destructor of an object of the given type at the |
835 | | /// given address. Does nothing if T is not a C++ class type with a |
836 | | /// non-trivial destructor. |
837 | | void PushDestructorCleanup(QualType T, Address Addr); |
838 | | |
839 | | /// PushDestructorCleanup - Push a cleanup to call the |
840 | | /// complete-object variant of the given destructor on the object at |
841 | | /// the given address. |
842 | | void PushDestructorCleanup(const CXXDestructorDecl *Dtor, QualType T, |
843 | | Address Addr); |
844 | | |
845 | | /// PopCleanupBlock - Will pop the cleanup entry on the stack and |
846 | | /// process all branch fixups. |
847 | | void PopCleanupBlock(bool FallThroughIsBranchThrough = false); |
848 | | |
849 | | /// DeactivateCleanupBlock - Deactivates the given cleanup block. |
850 | | /// The block cannot be reactivated. Pops it if it's the top of the |
851 | | /// stack. |
852 | | /// |
853 | | /// \param DominatingIP - An instruction which is known to |
854 | | /// dominate the current IP (if set) and which lies along |
855 | | /// all paths of execution between the current IP and the |
856 | | /// the point at which the cleanup comes into scope. |
857 | | void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, |
858 | | llvm::Instruction *DominatingIP); |
859 | | |
860 | | /// ActivateCleanupBlock - Activates an initially-inactive cleanup. |
861 | | /// Cannot be used to resurrect a deactivated cleanup. |
862 | | /// |
863 | | /// \param DominatingIP - An instruction which is known to |
864 | | /// dominate the current IP (if set) and which lies along |
865 | | /// all paths of execution between the current IP and the |
866 | | /// the point at which the cleanup comes into scope. |
867 | | void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, |
868 | | llvm::Instruction *DominatingIP); |
869 | | |
870 | | /// Enters a new scope for capturing cleanups, all of which |
871 | | /// will be executed once the scope is exited. |
872 | | class RunCleanupsScope { |
873 | | EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth; |
874 | | size_t LifetimeExtendedCleanupStackSize; |
875 | | bool OldDidCallStackSave; |
876 | | protected: |
877 | | bool PerformCleanup; |
878 | | private: |
879 | | |
880 | | RunCleanupsScope(const RunCleanupsScope &) = delete; |
881 | | void operator=(const RunCleanupsScope &) = delete; |
882 | | |
883 | | protected: |
884 | | CodeGenFunction& CGF; |
885 | | |
886 | | public: |
887 | | /// Enter a new cleanup scope. |
888 | | explicit RunCleanupsScope(CodeGenFunction &CGF) |
889 | | : PerformCleanup(true), CGF(CGF) |
890 | 980k | { |
891 | 980k | CleanupStackDepth = CGF.EHStack.stable_begin(); |
892 | 980k | LifetimeExtendedCleanupStackSize = |
893 | 980k | CGF.LifetimeExtendedCleanupStack.size(); |
894 | 980k | OldDidCallStackSave = CGF.DidCallStackSave; |
895 | 980k | CGF.DidCallStackSave = false; |
896 | 980k | OldCleanupScopeDepth = CGF.CurrentCleanupScopeDepth; |
897 | 980k | CGF.CurrentCleanupScopeDepth = CleanupStackDepth; |
898 | 980k | } |
899 | | |
900 | | /// Exit this cleanup scope, emitting any accumulated cleanups. |
901 | 980k | ~RunCleanupsScope() { |
902 | 980k | if (PerformCleanup) |
903 | 325k | ForceCleanup(); |
904 | 980k | } |
905 | | |
906 | | /// Determine whether this scope requires any cleanups. |
907 | 33.7k | bool requiresCleanups() const { |
908 | 33.7k | return CGF.EHStack.stable_begin() != CleanupStackDepth; |
909 | 33.7k | } |
910 | | |
911 | | /// Force the emission of cleanups now, instead of waiting |
912 | | /// until this object is destroyed. |
913 | | /// \param ValuesToReload - A list of values that need to be available at |
914 | | /// the insertion point after cleanup emission. If cleanup emission created |
915 | | /// a shared cleanup block, these value pointers will be rewritten. |
916 | | /// Otherwise, they not will be modified. |
917 | 980k | void ForceCleanup(std::initializer_list<llvm::Value**> ValuesToReload = {}) { |
918 | 980k | assert(PerformCleanup && "Already forced cleanup"); |
919 | 0 | CGF.DidCallStackSave = OldDidCallStackSave; |
920 | 980k | CGF.PopCleanupBlocks(CleanupStackDepth, LifetimeExtendedCleanupStackSize, |
921 | 980k | ValuesToReload); |
922 | 980k | PerformCleanup = false; |
923 | 980k | CGF.CurrentCleanupScopeDepth = OldCleanupScopeDepth; |
924 | 980k | } |
925 | | }; |
926 | | |
927 | | // Cleanup stack depth of the RunCleanupsScope that was pushed most recently. |
928 | | EHScopeStack::stable_iterator CurrentCleanupScopeDepth = |
929 | | EHScopeStack::stable_end(); |
930 | | |
931 | | class LexicalScope : public RunCleanupsScope { |
932 | | SourceRange Range; |
933 | | SmallVector<const LabelDecl*, 4> Labels; |
934 | | LexicalScope *ParentScope; |
935 | | |
936 | | LexicalScope(const LexicalScope &) = delete; |
937 | | void operator=(const LexicalScope &) = delete; |
938 | | |
939 | | public: |
940 | | /// Enter a new cleanup scope. |
941 | | explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range) |
942 | 305k | : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) { |
943 | 305k | CGF.CurLexicalScope = this; |
944 | 305k | if (CGDebugInfo *DI = CGF.getDebugInfo()) |
945 | 206k | DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin()); |
946 | 305k | } |
947 | | |
948 | 0 | void addLabel(const LabelDecl *label) { |
949 | 0 | assert(PerformCleanup && "adding label to dead scope?"); |
950 | 0 | Labels.push_back(label); |
951 | 0 | } |
952 | | |
953 | | /// Exit this cleanup scope, emitting any accumulated |
954 | | /// cleanups. |
955 | 305k | ~LexicalScope() { |
956 | 305k | if (CGDebugInfo *DI = CGF.getDebugInfo()) |
957 | 206k | DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd()); |
958 | | |
959 | | // If we should perform a cleanup, force them now. Note that |
960 | | // this ends the cleanup scope before rescoping any labels. |
961 | 305k | if (PerformCleanup) { |
962 | 271k | ApplyDebugLocation DL(CGF, Range.getEnd()); |
963 | 271k | ForceCleanup(); |
964 | 271k | } |
965 | 305k | } |
966 | | |
967 | | /// Force the emission of cleanups now, instead of waiting |
968 | | /// until this object is destroyed. |
969 | 305k | void ForceCleanup() { |
970 | 305k | CGF.CurLexicalScope = ParentScope; |
971 | 305k | RunCleanupsScope::ForceCleanup(); |
972 | | |
973 | 305k | if (!Labels.empty()) |
974 | 0 | rescopeLabels(); |
975 | 305k | } |
976 | | |
977 | 11.0k | bool hasLabels() const { |
978 | 11.0k | return !Labels.empty(); |
979 | 11.0k | } |
980 | | |
981 | | void rescopeLabels(); |
982 | | }; |
983 | | |
984 | | typedef llvm::DenseMap<const Decl *, Address> DeclMapTy; |
985 | | |
986 | | /// The class used to assign some variables some temporarily addresses. |
987 | | class OMPMapVars { |
988 | | DeclMapTy SavedLocals; |
989 | | DeclMapTy SavedTempAddresses; |
990 | | OMPMapVars(const OMPMapVars &) = delete; |
991 | | void operator=(const OMPMapVars &) = delete; |
992 | | |
993 | | public: |
994 | 153k | explicit OMPMapVars() = default; |
995 | 153k | ~OMPMapVars() { |
996 | 153k | assert(SavedLocals.empty() && "Did not restored original addresses."); |
997 | 153k | }; |
998 | | |
999 | | /// Sets the address of the variable \p LocalVD to be \p TempAddr in |
1000 | | /// function \p CGF. |
1001 | | /// \return true if at least one variable was set already, false otherwise. |
1002 | | bool setVarAddr(CodeGenFunction &CGF, const VarDecl *LocalVD, |
1003 | 174k | Address TempAddr) { |
1004 | 174k | LocalVD = LocalVD->getCanonicalDecl(); |
1005 | | // Only save it once. |
1006 | 174k | if (SavedLocals.count(LocalVD)) return false20.7k ; |
1007 | | |
1008 | | // Copy the existing local entry to SavedLocals. |
1009 | 154k | auto it = CGF.LocalDeclMap.find(LocalVD); |
1010 | 154k | if (it != CGF.LocalDeclMap.end()) |
1011 | 54.3k | SavedLocals.try_emplace(LocalVD, it->second); |
1012 | 99.7k | else |
1013 | 99.7k | SavedLocals.try_emplace(LocalVD, Address::invalid()); |
1014 | | |
1015 | | // Generate the private entry. |
1016 | 154k | QualType VarTy = LocalVD->getType(); |
1017 | 154k | if (VarTy->isReferenceType()) { |
1018 | 4.54k | Address Temp = CGF.CreateMemTemp(VarTy); |
1019 | 4.54k | CGF.Builder.CreateStore(TempAddr.getPointer(), Temp); |
1020 | 4.54k | TempAddr = Temp; |
1021 | 4.54k | } |
1022 | 154k | SavedTempAddresses.try_emplace(LocalVD, TempAddr); |
1023 | | |
1024 | 154k | return true; |
1025 | 174k | } |
1026 | | |
1027 | | /// Applies new addresses to the list of the variables. |
1028 | | /// \return true if at least one variable is using new address, false |
1029 | | /// otherwise. |
1030 | 139k | bool apply(CodeGenFunction &CGF) { |
1031 | 139k | copyInto(SavedTempAddresses, CGF.LocalDeclMap); |
1032 | 139k | SavedTempAddresses.clear(); |
1033 | 139k | return !SavedLocals.empty(); |
1034 | 139k | } |
1035 | | |
1036 | | /// Restores original addresses of the variables. |
1037 | 153k | void restore(CodeGenFunction &CGF) { |
1038 | 153k | if (!SavedLocals.empty()) { |
1039 | 84.1k | copyInto(SavedLocals, CGF.LocalDeclMap); |
1040 | 84.1k | SavedLocals.clear(); |
1041 | 84.1k | } |
1042 | 153k | } |
1043 | | |
1044 | | private: |
1045 | | /// Copy all the entries in the source map over the corresponding |
1046 | | /// entries in the destination, which must exist. |
1047 | 223k | static void copyInto(const DeclMapTy &Src, DeclMapTy &Dest) { |
1048 | 308k | for (auto &Pair : Src) { |
1049 | 308k | if (!Pair.second.isValid()) { |
1050 | 99.7k | Dest.erase(Pair.first); |
1051 | 99.7k | continue; |
1052 | 99.7k | } |
1053 | | |
1054 | 208k | auto I = Dest.find(Pair.first); |
1055 | 208k | if (I != Dest.end()) |
1056 | 108k | I->second = Pair.second; |
1057 | 99.7k | else |
1058 | 99.7k | Dest.insert(Pair); |
1059 | 208k | } |
1060 | 223k | } |
1061 | | }; |
1062 | | |
1063 | | /// The scope used to remap some variables as private in the OpenMP loop body |
1064 | | /// (or other captured region emitted without outlining), and to restore old |
1065 | | /// vars back on exit. |
1066 | | class OMPPrivateScope : public RunCleanupsScope { |
1067 | | OMPMapVars MappedVars; |
1068 | | OMPPrivateScope(const OMPPrivateScope &) = delete; |
1069 | | void operator=(const OMPPrivateScope &) = delete; |
1070 | | |
1071 | | public: |
1072 | | /// Enter a new OpenMP private scope. |
1073 | 133k | explicit OMPPrivateScope(CodeGenFunction &CGF) : RunCleanupsScope(CGF) {} |
1074 | | |
1075 | | /// Registers \p LocalVD variable as a private with \p Addr as the address |
1076 | | /// of the corresponding private variable. \p |
1077 | | /// PrivateGen is the address of the generated private variable. |
1078 | | /// \return true if the variable is registered as private, false if it has |
1079 | | /// been privatized already. |
1080 | 154k | bool addPrivate(const VarDecl *LocalVD, Address Addr) { |
1081 | 154k | assert(PerformCleanup && "adding private to dead scope"); |
1082 | 0 | return MappedVars.setVarAddr(CGF, LocalVD, Addr); |
1083 | 154k | } |
1084 | | |
1085 | | /// Privatizes local variables previously registered as private. |
1086 | | /// Registration is separate from the actual privatization to allow |
1087 | | /// initializers use values of the original variables, not the private one. |
1088 | | /// This is important, for example, if the private variable is a class |
1089 | | /// variable initialized by a constructor that references other private |
1090 | | /// variables. But at initialization original variables must be used, not |
1091 | | /// private copies. |
1092 | | /// \return true if at least one variable was privatized, false otherwise. |
1093 | 119k | bool Privatize() { return MappedVars.apply(CGF); } |
1094 | | |
1095 | 133k | void ForceCleanup() { |
1096 | 133k | RunCleanupsScope::ForceCleanup(); |
1097 | 133k | MappedVars.restore(CGF); |
1098 | 133k | } |
1099 | | |
1100 | | /// Exit scope - all the mapped variables are restored. |
1101 | 133k | ~OMPPrivateScope() { |
1102 | 133k | if (PerformCleanup) |
1103 | 108k | ForceCleanup(); |
1104 | 133k | } |
1105 | | |
1106 | | /// Checks if the global variable is captured in current function. |
1107 | 7.20k | bool isGlobalVarCaptured(const VarDecl *VD) const { |
1108 | 7.20k | VD = VD->getCanonicalDecl(); |
1109 | 7.20k | return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0905 ; |
1110 | 7.20k | } |
1111 | | }; |
1112 | | |
1113 | | /// Save/restore original map of previously emitted local vars in case when we |
1114 | | /// need to duplicate emission of the same code several times in the same |
1115 | | /// function for OpenMP code. |
1116 | | class OMPLocalDeclMapRAII { |
1117 | | CodeGenFunction &CGF; |
1118 | | DeclMapTy SavedMap; |
1119 | | |
1120 | | public: |
1121 | | OMPLocalDeclMapRAII(CodeGenFunction &CGF) |
1122 | 13.9k | : CGF(CGF), SavedMap(CGF.LocalDeclMap) {} |
1123 | 13.9k | ~OMPLocalDeclMapRAII() { SavedMap.swap(CGF.LocalDeclMap); } |
1124 | | }; |
1125 | | |
1126 | | /// Takes the old cleanup stack size and emits the cleanup blocks |
1127 | | /// that have been added. |
1128 | | void |
1129 | | PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, |
1130 | | std::initializer_list<llvm::Value **> ValuesToReload = {}); |
1131 | | |
1132 | | /// Takes the old cleanup stack size and emits the cleanup blocks |
1133 | | /// that have been added, then adds all lifetime-extended cleanups from |
1134 | | /// the given position to the stack. |
1135 | | void |
1136 | | PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, |
1137 | | size_t OldLifetimeExtendedStackSize, |
1138 | | std::initializer_list<llvm::Value **> ValuesToReload = {}); |
1139 | | |
1140 | | void ResolveBranchFixups(llvm::BasicBlock *Target); |
1141 | | |
1142 | | /// The given basic block lies in the current EH scope, but may be a |
1143 | | /// target of a potentially scope-crossing jump; get a stable handle |
1144 | | /// to which we can perform this jump later. |
1145 | 421k | JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) { |
1146 | 421k | return JumpDest(Target, |
1147 | 421k | EHStack.getInnermostNormalCleanup(), |
1148 | 421k | NextCleanupDestIndex++); |
1149 | 421k | } |
1150 | | |
1151 | | /// The given basic block lies in the current EH scope, but may be a |
1152 | | /// target of a potentially scope-crossing jump; get a stable handle |
1153 | | /// to which we can perform this jump later. |
1154 | 413k | JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) { |
1155 | 413k | return getJumpDestInCurrentScope(createBasicBlock(Name)); |
1156 | 413k | } |
1157 | | |
1158 | | /// EmitBranchThroughCleanup - Emit a branch from the current insert |
1159 | | /// block through the normal cleanup handling code (if any) and then |
1160 | | /// on to \arg Dest. |
1161 | | void EmitBranchThroughCleanup(JumpDest Dest); |
1162 | | |
1163 | | /// isObviouslyBranchWithoutCleanups - Return true if a branch to the |
1164 | | /// specified destination obviously has no cleanups to run. 'false' is always |
1165 | | /// a conservatively correct answer for this method. |
1166 | | bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const; |
1167 | | |
1168 | | /// popCatchScope - Pops the catch scope at the top of the EHScope |
1169 | | /// stack, emitting any required code (other than the catch handlers |
1170 | | /// themselves). |
1171 | | void popCatchScope(); |
1172 | | |
1173 | | llvm::BasicBlock *getEHResumeBlock(bool isCleanup); |
1174 | | llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope); |
1175 | | llvm::BasicBlock * |
1176 | | getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope); |
1177 | | |
1178 | | /// An object to manage conditionally-evaluated expressions. |
1179 | | class ConditionalEvaluation { |
1180 | | llvm::BasicBlock *StartBB; |
1181 | | |
1182 | | public: |
1183 | | ConditionalEvaluation(CodeGenFunction &CGF) |
1184 | 21.2k | : StartBB(CGF.Builder.GetInsertBlock()) {} |
1185 | | |
1186 | 30.8k | void begin(CodeGenFunction &CGF) { |
1187 | 30.8k | assert(CGF.OutermostConditional != this); |
1188 | 30.8k | if (!CGF.OutermostConditional) |
1189 | 30.6k | CGF.OutermostConditional = this; |
1190 | 30.8k | } |
1191 | | |
1192 | 30.8k | void end(CodeGenFunction &CGF) { |
1193 | 30.8k | assert(CGF.OutermostConditional != nullptr); |
1194 | 30.8k | if (CGF.OutermostConditional == this) |
1195 | 30.6k | CGF.OutermostConditional = nullptr; |
1196 | 30.8k | } |
1197 | | |
1198 | | /// Returns a block which will be executed prior to each |
1199 | | /// evaluation of the conditional code. |
1200 | 136 | llvm::BasicBlock *getStartingBlock() const { |
1201 | 136 | return StartBB; |
1202 | 136 | } |
1203 | | }; |
1204 | | |
1205 | | /// isInConditionalBranch - Return true if we're currently emitting |
1206 | | /// one branch or the other of a conditional expression. |
1207 | 10.9k | bool isInConditionalBranch() const { return OutermostConditional != nullptr; } |
1208 | | |
1209 | 136 | void setBeforeOutermostConditional(llvm::Value *value, Address addr) { |
1210 | 136 | assert(isInConditionalBranch()); |
1211 | 0 | llvm::BasicBlock *block = OutermostConditional->getStartingBlock(); |
1212 | 136 | auto store = new llvm::StoreInst(value, addr.getPointer(), &block->back()); |
1213 | 136 | store->setAlignment(addr.getAlignment().getAsAlign()); |
1214 | 136 | } |
1215 | | |
1216 | | /// An RAII object to record that we're evaluating a statement |
1217 | | /// expression. |
1218 | | class StmtExprEvaluation { |
1219 | | CodeGenFunction &CGF; |
1220 | | |
1221 | | /// We have to save the outermost conditional: cleanups in a |
1222 | | /// statement expression aren't conditional just because the |
1223 | | /// StmtExpr is. |
1224 | | ConditionalEvaluation *SavedOutermostConditional; |
1225 | | |
1226 | | public: |
1227 | | StmtExprEvaluation(CodeGenFunction &CGF) |
1228 | 4.27k | : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) { |
1229 | 4.27k | CGF.OutermostConditional = nullptr; |
1230 | 4.27k | } |
1231 | | |
1232 | 4.27k | ~StmtExprEvaluation() { |
1233 | 4.27k | CGF.OutermostConditional = SavedOutermostConditional; |
1234 | 4.27k | CGF.EnsureInsertPoint(); |
1235 | 4.27k | } |
1236 | | }; |
1237 | | |
1238 | | /// An object which temporarily prevents a value from being |
1239 | | /// destroyed by aggressive peephole optimizations that assume that |
1240 | | /// all uses of a value have been realized in the IR. |
1241 | | class PeepholeProtection { |
1242 | | llvm::Instruction *Inst; |
1243 | | friend class CodeGenFunction; |
1244 | | |
1245 | | public: |
1246 | 16.0k | PeepholeProtection() : Inst(nullptr) {} |
1247 | | }; |
1248 | | |
1249 | | /// A non-RAII class containing all the information about a bound |
1250 | | /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for |
1251 | | /// this which makes individual mappings very simple; using this |
1252 | | /// class directly is useful when you have a variable number of |
1253 | | /// opaque values or don't want the RAII functionality for some |
1254 | | /// reason. |
1255 | | class OpaqueValueMappingData { |
1256 | | const OpaqueValueExpr *OpaqueValue; |
1257 | | bool BoundLValue; |
1258 | | CodeGenFunction::PeepholeProtection Protection; |
1259 | | |
1260 | | OpaqueValueMappingData(const OpaqueValueExpr *ov, |
1261 | | bool boundLValue) |
1262 | 2.21k | : OpaqueValue(ov), BoundLValue(boundLValue) {} |
1263 | | public: |
1264 | 12.1k | OpaqueValueMappingData() : OpaqueValue(nullptr) {} |
1265 | | |
1266 | 7.65k | static bool shouldBindAsLValue(const Expr *expr) { |
1267 | | // gl-values should be bound as l-values for obvious reasons. |
1268 | | // Records should be bound as l-values because IR generation |
1269 | | // always keeps them in memory. Expressions of function type |
1270 | | // act exactly like l-values but are formally required to be |
1271 | | // r-values in C. |
1272 | 7.65k | return expr->isGLValue() || |
1273 | 7.65k | expr->getType()->isFunctionType()4.50k || |
1274 | 7.65k | hasAggregateEvaluationKind(expr->getType())4.50k ; |
1275 | 7.65k | } |
1276 | | |
1277 | | static OpaqueValueMappingData bind(CodeGenFunction &CGF, |
1278 | | const OpaqueValueExpr *ov, |
1279 | 622 | const Expr *e) { |
1280 | 622 | if (shouldBindAsLValue(ov)) |
1281 | 340 | return bind(CGF, ov, CGF.EmitLValue(e)); |
1282 | 282 | return bind(CGF, ov, CGF.EmitAnyExpr(e)); |
1283 | 622 | } |
1284 | | |
1285 | | static OpaqueValueMappingData bind(CodeGenFunction &CGF, |
1286 | | const OpaqueValueExpr *ov, |
1287 | 519 | const LValue &lv) { |
1288 | 519 | assert(shouldBindAsLValue(ov)); |
1289 | 0 | CGF.OpaqueLValues.insert(std::make_pair(ov, lv)); |
1290 | 519 | return OpaqueValueMappingData(ov, true); |
1291 | 519 | } |
1292 | | |
1293 | | static OpaqueValueMappingData bind(CodeGenFunction &CGF, |
1294 | | const OpaqueValueExpr *ov, |
1295 | 1.69k | const RValue &rv) { |
1296 | 1.69k | assert(!shouldBindAsLValue(ov)); |
1297 | 0 | CGF.OpaqueRValues.insert(std::make_pair(ov, rv)); |
1298 | | |
1299 | 1.69k | OpaqueValueMappingData data(ov, false); |
1300 | | |
1301 | | // Work around an extremely aggressive peephole optimization in |
1302 | | // EmitScalarConversion which assumes that all other uses of a |
1303 | | // value are extant. |
1304 | 1.69k | data.Protection = CGF.protectFromPeepholes(rv); |
1305 | | |
1306 | 1.69k | return data; |
1307 | 1.69k | } |
1308 | | |
1309 | 13.4k | bool isValid() const { return OpaqueValue != nullptr; } |
1310 | 6 | void clear() { OpaqueValue = nullptr; } |
1311 | | |
1312 | 2.21k | void unbind(CodeGenFunction &CGF) { |
1313 | 2.21k | assert(OpaqueValue && "no data to unbind!"); |
1314 | | |
1315 | 2.21k | if (BoundLValue) { |
1316 | 519 | CGF.OpaqueLValues.erase(OpaqueValue); |
1317 | 1.69k | } else { |
1318 | 1.69k | CGF.OpaqueRValues.erase(OpaqueValue); |
1319 | 1.69k | CGF.unprotectFromPeepholes(Protection); |
1320 | 1.69k | } |
1321 | 2.21k | } |
1322 | | }; |
1323 | | |
1324 | | /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr. |
1325 | | class OpaqueValueMapping { |
1326 | | CodeGenFunction &CGF; |
1327 | | OpaqueValueMappingData Data; |
1328 | | |
1329 | | public: |
1330 | 3.77k | static bool shouldBindAsLValue(const Expr *expr) { |
1331 | 3.77k | return OpaqueValueMappingData::shouldBindAsLValue(expr); |
1332 | 3.77k | } |
1333 | | |
1334 | | /// Build the opaque value mapping for the given conditional |
1335 | | /// operator if it's the GNU ?: extension. This is a common |
1336 | | /// enough pattern that the convenience operator is really |
1337 | | /// helpful. |
1338 | | /// |
1339 | | OpaqueValueMapping(CodeGenFunction &CGF, |
1340 | 11.8k | const AbstractConditionalOperator *op) : CGF(CGF) { |
1341 | 11.8k | if (isa<ConditionalOperator>(op)) |
1342 | | // Leave Data empty. |
1343 | 11.7k | return; |
1344 | | |
1345 | 29 | const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op); |
1346 | 29 | Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(), |
1347 | 29 | e->getCommon()); |
1348 | 29 | } |
1349 | | |
1350 | | /// Build the opaque value mapping for an OpaqueValueExpr whose source |
1351 | | /// expression is set to the expression the OVE represents. |
1352 | | OpaqueValueMapping(CodeGenFunction &CGF, const OpaqueValueExpr *OV) |
1353 | 39 | : CGF(CGF) { |
1354 | 39 | if (OV) { |
1355 | 39 | assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used " |
1356 | 39 | "for OVE with no source expression"); |
1357 | 0 | Data = OpaqueValueMappingData::bind(CGF, OV, OV->getSourceExpr()); |
1358 | 39 | } |
1359 | 39 | } |
1360 | | |
1361 | | OpaqueValueMapping(CodeGenFunction &CGF, |
1362 | | const OpaqueValueExpr *opaqueValue, |
1363 | | LValue lvalue) |
1364 | 169 | : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) { |
1365 | 169 | } |
1366 | | |
1367 | | OpaqueValueMapping(CodeGenFunction &CGF, |
1368 | | const OpaqueValueExpr *opaqueValue, |
1369 | | RValue rvalue) |
1370 | 1.41k | : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) { |
1371 | 1.41k | } |
1372 | | |
1373 | 6 | void pop() { |
1374 | 6 | Data.unbind(CGF); |
1375 | 6 | Data.clear(); |
1376 | 6 | } |
1377 | | |
1378 | 13.4k | ~OpaqueValueMapping() { |
1379 | 13.4k | if (Data.isValid()) Data.unbind(CGF)1.64k ; |
1380 | 13.4k | } |
1381 | | }; |
1382 | | |
1383 | | private: |
1384 | | CGDebugInfo *DebugInfo; |
1385 | | /// Used to create unique names for artificial VLA size debug info variables. |
1386 | | unsigned VLAExprCounter = 0; |
1387 | | bool DisableDebugInfo = false; |
1388 | | |
1389 | | /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid |
1390 | | /// calling llvm.stacksave for multiple VLAs in the same scope. |
1391 | | bool DidCallStackSave = false; |
1392 | | |
1393 | | /// IndirectBranch - The first time an indirect goto is seen we create a block |
1394 | | /// with an indirect branch. Every time we see the address of a label taken, |
1395 | | /// we add the label to the indirect goto. Every subsequent indirect goto is |
1396 | | /// codegen'd as a jump to the IndirectBranch's basic block. |
1397 | | llvm::IndirectBrInst *IndirectBranch = nullptr; |
1398 | | |
1399 | | /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C |
1400 | | /// decls. |
1401 | | DeclMapTy LocalDeclMap; |
1402 | | |
1403 | | // Keep track of the cleanups for callee-destructed parameters pushed to the |
1404 | | // cleanup stack so that they can be deactivated later. |
1405 | | llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator> |
1406 | | CalleeDestructedParamCleanups; |
1407 | | |
1408 | | /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this |
1409 | | /// will contain a mapping from said ParmVarDecl to its implicit "object_size" |
1410 | | /// parameter. |
1411 | | llvm::SmallDenseMap<const ParmVarDecl *, const ImplicitParamDecl *, 2> |
1412 | | SizeArguments; |
1413 | | |
1414 | | /// Track escaped local variables with auto storage. Used during SEH |
1415 | | /// outlining to produce a call to llvm.localescape. |
1416 | | llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals; |
1417 | | |
1418 | | /// LabelMap - This keeps track of the LLVM basic block for each C label. |
1419 | | llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap; |
1420 | | |
1421 | | // BreakContinueStack - This keeps track of where break and continue |
1422 | | // statements should jump to. |
1423 | | struct BreakContinue { |
1424 | | BreakContinue(JumpDest Break, JumpDest Continue) |
1425 | 46.3k | : BreakBlock(Break), ContinueBlock(Continue) {} |
1426 | | |
1427 | | JumpDest BreakBlock; |
1428 | | JumpDest ContinueBlock; |
1429 | | }; |
1430 | | SmallVector<BreakContinue, 8> BreakContinueStack; |
1431 | | |
1432 | | /// Handles cancellation exit points in OpenMP-related constructs. |
1433 | | class OpenMPCancelExitStack { |
1434 | | /// Tracks cancellation exit point and join point for cancel-related exit |
1435 | | /// and normal exit. |
1436 | | struct CancelExit { |
1437 | 316k | CancelExit() = default; |
1438 | | CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock, |
1439 | | JumpDest ContBlock) |
1440 | 4.42k | : Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {} |
1441 | | OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown; |
1442 | | /// true if the exit block has been emitted already by the special |
1443 | | /// emitExit() call, false if the default codegen is used. |
1444 | | bool HasBeenEmitted = false; |
1445 | | JumpDest ExitBlock; |
1446 | | JumpDest ContBlock; |
1447 | | }; |
1448 | | |
1449 | | SmallVector<CancelExit, 8> Stack; |
1450 | | |
1451 | | public: |
1452 | 316k | OpenMPCancelExitStack() : Stack(1) {} |
1453 | 316k | ~OpenMPCancelExitStack() = default; |
1454 | | /// Fetches the exit block for the current OpenMP construct. |
1455 | 9.13k | JumpDest getExitBlock() const { return Stack.back().ExitBlock; } |
1456 | | /// Emits exit block with special codegen procedure specific for the related |
1457 | | /// OpenMP construct + emits code for normal construct cleanup. |
1458 | | void emitExit(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, |
1459 | 5.01k | const llvm::function_ref<void(CodeGenFunction &)> CodeGen) { |
1460 | 5.01k | if (Stack.back().Kind == Kind && getExitBlock().isValid()4.39k ) { |
1461 | 93 | assert(CGF.getOMPCancelDestination(Kind).isValid()); |
1462 | 0 | assert(CGF.HaveInsertPoint()); |
1463 | 0 | assert(!Stack.back().HasBeenEmitted); |
1464 | 0 | auto IP = CGF.Builder.saveAndClearIP(); |
1465 | 93 | CGF.EmitBlock(Stack.back().ExitBlock.getBlock()); |
1466 | 93 | CodeGen(CGF); |
1467 | 93 | CGF.EmitBranch(Stack.back().ContBlock.getBlock()); |
1468 | 93 | CGF.Builder.restoreIP(IP); |
1469 | 93 | Stack.back().HasBeenEmitted = true; |
1470 | 93 | } |
1471 | 0 | CodeGen(CGF); |
1472 | 5.01k | } |
1473 | | /// Enter the cancel supporting \a Kind construct. |
1474 | | /// \param Kind OpenMP directive that supports cancel constructs. |
1475 | | /// \param HasCancel true, if the construct has inner cancel directive, |
1476 | | /// false otherwise. |
1477 | 4.42k | void enter(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, bool HasCancel) { |
1478 | 4.42k | Stack.push_back({Kind, |
1479 | 4.42k | HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")93 |
1480 | 4.42k | : JumpDest()4.33k , |
1481 | 4.42k | HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")93 |
1482 | 4.42k | : JumpDest()4.33k }); |
1483 | 4.42k | } |
1484 | | /// Emits default exit point for the cancel construct (if the special one |
1485 | | /// has not be used) + join point for cancel/normal exits. |
1486 | 4.42k | void exit(CodeGenFunction &CGF) { |
1487 | 4.42k | if (getExitBlock().isValid()) { |
1488 | 93 | assert(CGF.getOMPCancelDestination(Stack.back().Kind).isValid()); |
1489 | 0 | bool HaveIP = CGF.HaveInsertPoint(); |
1490 | 93 | if (!Stack.back().HasBeenEmitted) { |
1491 | 0 | if (HaveIP) |
1492 | 0 | CGF.EmitBranchThroughCleanup(Stack.back().ContBlock); |
1493 | 0 | CGF.EmitBlock(Stack.back().ExitBlock.getBlock()); |
1494 | 0 | CGF.EmitBranchThroughCleanup(Stack.back().ContBlock); |
1495 | 0 | } |
1496 | 93 | CGF.EmitBlock(Stack.back().ContBlock.getBlock()); |
1497 | 93 | if (!HaveIP) { |
1498 | 0 | CGF.Builder.CreateUnreachable(); |
1499 | 0 | CGF.Builder.ClearInsertionPoint(); |
1500 | 0 | } |
1501 | 93 | } |
1502 | 0 | Stack.pop_back(); |
1503 | 4.42k | } |
1504 | | }; |
1505 | | OpenMPCancelExitStack OMPCancelStack; |
1506 | | |
1507 | | /// Lower the Likelihood knowledge about the \p Cond via llvm.expect intrin. |
1508 | | llvm::Value *emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond, |
1509 | | Stmt::Likelihood LH); |
1510 | | |
1511 | | CodeGenPGO PGO; |
1512 | | |
1513 | | /// Calculate branch weights appropriate for PGO data |
1514 | | llvm::MDNode *createProfileWeights(uint64_t TrueCount, |
1515 | | uint64_t FalseCount) const; |
1516 | | llvm::MDNode *createProfileWeights(ArrayRef<uint64_t> Weights) const; |
1517 | | llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond, |
1518 | | uint64_t LoopCount) const; |
1519 | | |
1520 | | public: |
1521 | | /// Increment the profiler's counter for the given statement by \p StepV. |
1522 | | /// If \p StepV is null, the default increment is 1. |
1523 | 455k | void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) { |
1524 | 455k | if (CGM.getCodeGenOpts().hasProfileClangInstr() && |
1525 | 455k | !CurFn->hasFnAttribute(llvm::Attribute::NoProfile)1.13k ) |
1526 | 1.12k | PGO.emitCounterIncrement(Builder, S, StepV); |
1527 | 455k | PGO.setCurrentStmt(S); |
1528 | 455k | } |
1529 | | |
1530 | | /// Get the profiler's count for the given statement. |
1531 | 176k | uint64_t getProfileCount(const Stmt *S) { |
1532 | 176k | Optional<uint64_t> Count = PGO.getStmtCount(S); |
1533 | 176k | if (!Count.hasValue()) |
1534 | 176k | return 0; |
1535 | 489 | return *Count; |
1536 | 176k | } |
1537 | | |
1538 | | /// Set the profiler's current count. |
1539 | 9.22k | void setCurrentProfileCount(uint64_t Count) { |
1540 | 9.22k | PGO.setCurrentRegionCount(Count); |
1541 | 9.22k | } |
1542 | | |
1543 | | /// Get the profiler's current count. This is generally the count for the most |
1544 | | /// recently incremented counter. |
1545 | 158k | uint64_t getCurrentProfileCount() { |
1546 | 158k | return PGO.getCurrentRegionCount(); |
1547 | 158k | } |
1548 | | |
1549 | | private: |
1550 | | |
1551 | | /// SwitchInsn - This is nearest current switch instruction. It is null if |
1552 | | /// current context is not in a switch. |
1553 | | llvm::SwitchInst *SwitchInsn = nullptr; |
1554 | | /// The branch weights of SwitchInsn when doing instrumentation based PGO. |
1555 | | SmallVector<uint64_t, 16> *SwitchWeights = nullptr; |
1556 | | |
1557 | | /// The likelihood attributes of the SwitchCase. |
1558 | | SmallVector<Stmt::Likelihood, 16> *SwitchLikelihood = nullptr; |
1559 | | |
1560 | | /// CaseRangeBlock - This block holds if condition check for last case |
1561 | | /// statement range in current switch instruction. |
1562 | | llvm::BasicBlock *CaseRangeBlock = nullptr; |
1563 | | |
1564 | | /// OpaqueLValues - Keeps track of the current set of opaque value |
1565 | | /// expressions. |
1566 | | llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues; |
1567 | | llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues; |
1568 | | |
1569 | | // VLASizeMap - This keeps track of the associated size for each VLA type. |
1570 | | // We track this by the size expression rather than the type itself because |
1571 | | // in certain situations, like a const qualifier applied to an VLA typedef, |
1572 | | // multiple VLA types can share the same size expression. |
1573 | | // FIXME: Maybe this could be a stack of maps that is pushed/popped as we |
1574 | | // enter/leave scopes. |
1575 | | llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap; |
1576 | | |
1577 | | /// A block containing a single 'unreachable' instruction. Created |
1578 | | /// lazily by getUnreachableBlock(). |
1579 | | llvm::BasicBlock *UnreachableBlock = nullptr; |
1580 | | |
1581 | | /// Counts of the number return expressions in the function. |
1582 | | unsigned NumReturnExprs = 0; |
1583 | | |
1584 | | /// Count the number of simple (constant) return expressions in the function. |
1585 | | unsigned NumSimpleReturnExprs = 0; |
1586 | | |
1587 | | /// The last regular (non-return) debug location (breakpoint) in the function. |
1588 | | SourceLocation LastStopPoint; |
1589 | | |
1590 | | public: |
1591 | | /// Source location information about the default argument or member |
1592 | | /// initializer expression we're evaluating, if any. |
1593 | | CurrentSourceLocExprScope CurSourceLocExprScope; |
1594 | | using SourceLocExprScopeGuard = |
1595 | | CurrentSourceLocExprScope::SourceLocExprScopeGuard; |
1596 | | |
1597 | | /// A scope within which we are constructing the fields of an object which |
1598 | | /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use |
1599 | | /// if we need to evaluate a CXXDefaultInitExpr within the evaluation. |
1600 | | class FieldConstructionScope { |
1601 | | public: |
1602 | | FieldConstructionScope(CodeGenFunction &CGF, Address This) |
1603 | 25.4k | : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) { |
1604 | 25.4k | CGF.CXXDefaultInitExprThis = This; |
1605 | 25.4k | } |
1606 | 25.4k | ~FieldConstructionScope() { |
1607 | 25.4k | CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis; |
1608 | 25.4k | } |
1609 | | |
1610 | | private: |
1611 | | CodeGenFunction &CGF; |
1612 | | Address OldCXXDefaultInitExprThis; |
1613 | | }; |
1614 | | |
1615 | | /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this' |
1616 | | /// is overridden to be the object under construction. |
1617 | | class CXXDefaultInitExprScope { |
1618 | | public: |
1619 | | CXXDefaultInitExprScope(CodeGenFunction &CGF, const CXXDefaultInitExpr *E) |
1620 | | : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue), |
1621 | | OldCXXThisAlignment(CGF.CXXThisAlignment), |
1622 | 1.17k | SourceLocScope(E, CGF.CurSourceLocExprScope) { |
1623 | 1.17k | CGF.CXXThisValue = CGF.CXXDefaultInitExprThis.getPointer(); |
1624 | 1.17k | CGF.CXXThisAlignment = CGF.CXXDefaultInitExprThis.getAlignment(); |
1625 | 1.17k | } |
1626 | 1.17k | ~CXXDefaultInitExprScope() { |
1627 | 1.17k | CGF.CXXThisValue = OldCXXThisValue; |
1628 | 1.17k | CGF.CXXThisAlignment = OldCXXThisAlignment; |
1629 | 1.17k | } |
1630 | | |
1631 | | public: |
1632 | | CodeGenFunction &CGF; |
1633 | | llvm::Value *OldCXXThisValue; |
1634 | | CharUnits OldCXXThisAlignment; |
1635 | | SourceLocExprScopeGuard SourceLocScope; |
1636 | | }; |
1637 | | |
1638 | | struct CXXDefaultArgExprScope : SourceLocExprScopeGuard { |
1639 | | CXXDefaultArgExprScope(CodeGenFunction &CGF, const CXXDefaultArgExpr *E) |
1640 | 4.11k | : SourceLocExprScopeGuard(E, CGF.CurSourceLocExprScope) {} |
1641 | | }; |
1642 | | |
1643 | | /// The scope of an ArrayInitLoopExpr. Within this scope, the value of the |
1644 | | /// current loop index is overridden. |
1645 | | class ArrayInitLoopExprScope { |
1646 | | public: |
1647 | | ArrayInitLoopExprScope(CodeGenFunction &CGF, llvm::Value *Index) |
1648 | 39 | : CGF(CGF), OldArrayInitIndex(CGF.ArrayInitIndex) { |
1649 | 39 | CGF.ArrayInitIndex = Index; |
1650 | 39 | } |
1651 | 39 | ~ArrayInitLoopExprScope() { |
1652 | 39 | CGF.ArrayInitIndex = OldArrayInitIndex; |
1653 | 39 | } |
1654 | | |
1655 | | private: |
1656 | | CodeGenFunction &CGF; |
1657 | | llvm::Value *OldArrayInitIndex; |
1658 | | }; |
1659 | | |
1660 | | class InlinedInheritingConstructorScope { |
1661 | | public: |
1662 | | InlinedInheritingConstructorScope(CodeGenFunction &CGF, GlobalDecl GD) |
1663 | | : CGF(CGF), OldCurGD(CGF.CurGD), OldCurFuncDecl(CGF.CurFuncDecl), |
1664 | | OldCurCodeDecl(CGF.CurCodeDecl), |
1665 | | OldCXXABIThisDecl(CGF.CXXABIThisDecl), |
1666 | | OldCXXABIThisValue(CGF.CXXABIThisValue), |
1667 | | OldCXXThisValue(CGF.CXXThisValue), |
1668 | | OldCXXABIThisAlignment(CGF.CXXABIThisAlignment), |
1669 | | OldCXXThisAlignment(CGF.CXXThisAlignment), |
1670 | | OldReturnValue(CGF.ReturnValue), OldFnRetTy(CGF.FnRetTy), |
1671 | | OldCXXInheritedCtorInitExprArgs( |
1672 | 47 | std::move(CGF.CXXInheritedCtorInitExprArgs)) { |
1673 | 47 | CGF.CurGD = GD; |
1674 | 47 | CGF.CurFuncDecl = CGF.CurCodeDecl = |
1675 | 47 | cast<CXXConstructorDecl>(GD.getDecl()); |
1676 | 47 | CGF.CXXABIThisDecl = nullptr; |
1677 | 47 | CGF.CXXABIThisValue = nullptr; |
1678 | 47 | CGF.CXXThisValue = nullptr; |
1679 | 47 | CGF.CXXABIThisAlignment = CharUnits(); |
1680 | 47 | CGF.CXXThisAlignment = CharUnits(); |
1681 | 47 | CGF.ReturnValue = Address::invalid(); |
1682 | 47 | CGF.FnRetTy = QualType(); |
1683 | 47 | CGF.CXXInheritedCtorInitExprArgs.clear(); |
1684 | 47 | } |
1685 | 47 | ~InlinedInheritingConstructorScope() { |
1686 | 47 | CGF.CurGD = OldCurGD; |
1687 | 47 | CGF.CurFuncDecl = OldCurFuncDecl; |
1688 | 47 | CGF.CurCodeDecl = OldCurCodeDecl; |
1689 | 47 | CGF.CXXABIThisDecl = OldCXXABIThisDecl; |
1690 | 47 | CGF.CXXABIThisValue = OldCXXABIThisValue; |
1691 | 47 | CGF.CXXThisValue = OldCXXThisValue; |
1692 | 47 | CGF.CXXABIThisAlignment = OldCXXABIThisAlignment; |
1693 | 47 | CGF.CXXThisAlignment = OldCXXThisAlignment; |
1694 | 47 | CGF.ReturnValue = OldReturnValue; |
1695 | 47 | CGF.FnRetTy = OldFnRetTy; |
1696 | 47 | CGF.CXXInheritedCtorInitExprArgs = |
1697 | 47 | std::move(OldCXXInheritedCtorInitExprArgs); |
1698 | 47 | } |
1699 | | |
1700 | | private: |
1701 | | CodeGenFunction &CGF; |
1702 | | GlobalDecl OldCurGD; |
1703 | | const Decl *OldCurFuncDecl; |
1704 | | const Decl *OldCurCodeDecl; |
1705 | | ImplicitParamDecl *OldCXXABIThisDecl; |
1706 | | llvm::Value *OldCXXABIThisValue; |
1707 | | llvm::Value *OldCXXThisValue; |
1708 | | CharUnits OldCXXABIThisAlignment; |
1709 | | CharUnits OldCXXThisAlignment; |
1710 | | Address OldReturnValue; |
1711 | | QualType OldFnRetTy; |
1712 | | CallArgList OldCXXInheritedCtorInitExprArgs; |
1713 | | }; |
1714 | | |
1715 | | // Helper class for the OpenMP IR Builder. Allows reusability of code used for |
1716 | | // region body, and finalization codegen callbacks. This will class will also |
1717 | | // contain privatization functions used by the privatization call backs |
1718 | | // |
1719 | | // TODO: this is temporary class for things that are being moved out of |
1720 | | // CGOpenMPRuntime, new versions of current CodeGenFunction methods, or |
1721 | | // utility function for use with the OMPBuilder. Once that move to use the |
1722 | | // OMPBuilder is done, everything here will either become part of CodeGenFunc. |
1723 | | // directly, or a new helper class that will contain functions used by both |
1724 | | // this and the OMPBuilder |
1725 | | |
1726 | | struct OMPBuilderCBHelpers { |
1727 | | |
1728 | | OMPBuilderCBHelpers() = delete; |
1729 | | OMPBuilderCBHelpers(const OMPBuilderCBHelpers &) = delete; |
1730 | | OMPBuilderCBHelpers &operator=(const OMPBuilderCBHelpers &) = delete; |
1731 | | |
1732 | | using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy; |
1733 | | |
1734 | | /// Cleanup action for allocate support. |
1735 | | class OMPAllocateCleanupTy final : public EHScopeStack::Cleanup { |
1736 | | |
1737 | | private: |
1738 | | llvm::CallInst *RTLFnCI; |
1739 | | |
1740 | | public: |
1741 | 0 | OMPAllocateCleanupTy(llvm::CallInst *RLFnCI) : RTLFnCI(RLFnCI) { |
1742 | 0 | RLFnCI->removeFromParent(); |
1743 | 0 | } |
1744 | | |
1745 | 0 | void Emit(CodeGenFunction &CGF, Flags /*flags*/) override { |
1746 | 0 | if (!CGF.HaveInsertPoint()) |
1747 | 0 | return; |
1748 | 0 | CGF.Builder.Insert(RTLFnCI); |
1749 | 0 | } |
1750 | | }; |
1751 | | |
1752 | | /// Returns address of the threadprivate variable for the current |
1753 | | /// thread. This Also create any necessary OMP runtime calls. |
1754 | | /// |
1755 | | /// \param VD VarDecl for Threadprivate variable. |
1756 | | /// \param VDAddr Address of the Vardecl |
1757 | | /// \param Loc The location where the barrier directive was encountered |
1758 | | static Address getAddrOfThreadPrivate(CodeGenFunction &CGF, |
1759 | | const VarDecl *VD, Address VDAddr, |
1760 | | SourceLocation Loc); |
1761 | | |
1762 | | /// Gets the OpenMP-specific address of the local variable /p VD. |
1763 | | static Address getAddressOfLocalVariable(CodeGenFunction &CGF, |
1764 | | const VarDecl *VD); |
1765 | | /// Get the platform-specific name separator. |
1766 | | /// \param Parts different parts of the final name that needs separation |
1767 | | /// \param FirstSeparator First separator used between the initial two |
1768 | | /// parts of the name. |
1769 | | /// \param Separator separator used between all of the rest consecutinve |
1770 | | /// parts of the name |
1771 | | static std::string getNameWithSeparators(ArrayRef<StringRef> Parts, |
1772 | | StringRef FirstSeparator = ".", |
1773 | | StringRef Separator = "."); |
1774 | | /// Emit the Finalization for an OMP region |
1775 | | /// \param CGF The Codegen function this belongs to |
1776 | | /// \param IP Insertion point for generating the finalization code. |
1777 | 176 | static void FinalizeOMPRegion(CodeGenFunction &CGF, InsertPointTy IP) { |
1778 | 176 | CGBuilderTy::InsertPointGuard IPG(CGF.Builder); |
1779 | 176 | assert(IP.getBlock()->end() != IP.getPoint() && |
1780 | 176 | "OpenMP IR Builder should cause terminated block!"); |
1781 | | |
1782 | 0 | llvm::BasicBlock *IPBB = IP.getBlock(); |
1783 | 176 | llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor(); |
1784 | 176 | assert(DestBB && "Finalization block should have one successor!"); |
1785 | | |
1786 | | // erase and replace with cleanup branch. |
1787 | 0 | IPBB->getTerminator()->eraseFromParent(); |
1788 | 176 | CGF.Builder.SetInsertPoint(IPBB); |
1789 | 176 | CodeGenFunction::JumpDest Dest = CGF.getJumpDestInCurrentScope(DestBB); |
1790 | 176 | CGF.EmitBranchThroughCleanup(Dest); |
1791 | 176 | } |
1792 | | |
1793 | | /// Emit the body of an OMP region |
1794 | | /// \param CGF The Codegen function this belongs to |
1795 | | /// \param RegionBodyStmt The body statement for the OpenMP region being |
1796 | | /// generated |
1797 | | /// \param AllocaIP Where to insert alloca instructions |
1798 | | /// \param CodeGenIP Where to insert the region code |
1799 | | /// \param RegionName Name to be used for new blocks |
1800 | | static void EmitOMPInlinedRegionBody(CodeGenFunction &CGF, |
1801 | | const Stmt *RegionBodyStmt, |
1802 | | InsertPointTy AllocaIP, |
1803 | | InsertPointTy CodeGenIP, |
1804 | | Twine RegionName); |
1805 | | |
1806 | | static void EmitCaptureStmt(CodeGenFunction &CGF, InsertPointTy CodeGenIP, |
1807 | | llvm::BasicBlock &FiniBB, llvm::Function *Fn, |
1808 | 8 | ArrayRef<llvm::Value *> Args) { |
1809 | 8 | llvm::BasicBlock *CodeGenIPBB = CodeGenIP.getBlock(); |
1810 | 8 | if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator()) |
1811 | 0 | CodeGenIPBBTI->eraseFromParent(); |
1812 | | |
1813 | 8 | CGF.Builder.SetInsertPoint(CodeGenIPBB); |
1814 | | |
1815 | 8 | if (Fn->doesNotThrow()) |
1816 | 0 | CGF.EmitNounwindRuntimeCall(Fn, Args); |
1817 | 8 | else |
1818 | 8 | CGF.EmitRuntimeCall(Fn, Args); |
1819 | | |
1820 | 8 | if (CGF.Builder.saveIP().isSet()) |
1821 | 8 | CGF.Builder.CreateBr(&FiniBB); |
1822 | 8 | } |
1823 | | |
1824 | | /// Emit the body of an OMP region that will be outlined in |
1825 | | /// OpenMPIRBuilder::finalize(). |
1826 | | /// \param CGF The Codegen function this belongs to |
1827 | | /// \param RegionBodyStmt The body statement for the OpenMP region being |
1828 | | /// generated |
1829 | | /// \param AllocaIP Where to insert alloca instructions |
1830 | | /// \param CodeGenIP Where to insert the region code |
1831 | | /// \param RegionName Name to be used for new blocks |
1832 | | static void EmitOMPOutlinedRegionBody(CodeGenFunction &CGF, |
1833 | | const Stmt *RegionBodyStmt, |
1834 | | InsertPointTy AllocaIP, |
1835 | | InsertPointTy CodeGenIP, |
1836 | | Twine RegionName); |
1837 | | |
1838 | | /// RAII for preserving necessary info during Outlined region body codegen. |
1839 | | class OutlinedRegionBodyRAII { |
1840 | | |
1841 | | llvm::AssertingVH<llvm::Instruction> OldAllocaIP; |
1842 | | CodeGenFunction::JumpDest OldReturnBlock; |
1843 | | CodeGenFunction &CGF; |
1844 | | |
1845 | | public: |
1846 | | OutlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, |
1847 | | llvm::BasicBlock &RetBB) |
1848 | 50 | : CGF(cgf) { |
1849 | 50 | assert(AllocaIP.isSet() && |
1850 | 50 | "Must specify Insertion point for allocas of outlined function"); |
1851 | 0 | OldAllocaIP = CGF.AllocaInsertPt; |
1852 | 50 | CGF.AllocaInsertPt = &*AllocaIP.getPoint(); |
1853 | | |
1854 | 50 | OldReturnBlock = CGF.ReturnBlock; |
1855 | 50 | CGF.ReturnBlock = CGF.getJumpDestInCurrentScope(&RetBB); |
1856 | 50 | } |
1857 | | |
1858 | 50 | ~OutlinedRegionBodyRAII() { |
1859 | 50 | CGF.AllocaInsertPt = OldAllocaIP; |
1860 | 50 | CGF.ReturnBlock = OldReturnBlock; |
1861 | 50 | } |
1862 | | }; |
1863 | | |
1864 | | /// RAII for preserving necessary info during inlined region body codegen. |
1865 | | class InlinedRegionBodyRAII { |
1866 | | |
1867 | | llvm::AssertingVH<llvm::Instruction> OldAllocaIP; |
1868 | | CodeGenFunction &CGF; |
1869 | | |
1870 | | public: |
1871 | | InlinedRegionBodyRAII(CodeGenFunction &cgf, InsertPointTy &AllocaIP, |
1872 | | llvm::BasicBlock &FiniBB) |
1873 | 98 | : CGF(cgf) { |
1874 | | // Alloca insertion block should be in the entry block of the containing |
1875 | | // function so it expects an empty AllocaIP in which case will reuse the |
1876 | | // old alloca insertion point, or a new AllocaIP in the same block as |
1877 | | // the old one |
1878 | 98 | assert((!AllocaIP.isSet() || |
1879 | 98 | CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) && |
1880 | 98 | "Insertion point should be in the entry block of containing " |
1881 | 98 | "function!"); |
1882 | 0 | OldAllocaIP = CGF.AllocaInsertPt; |
1883 | 98 | if (AllocaIP.isSet()) |
1884 | 0 | CGF.AllocaInsertPt = &*AllocaIP.getPoint(); |
1885 | | |
1886 | | // TODO: Remove the call, after making sure the counter is not used by |
1887 | | // the EHStack. |
1888 | | // Since this is an inlined region, it should not modify the |
1889 | | // ReturnBlock, and should reuse the one for the enclosing outlined |
1890 | | // region. So, the JumpDest being return by the function is discarded |
1891 | 98 | (void)CGF.getJumpDestInCurrentScope(&FiniBB); |
1892 | 98 | } |
1893 | | |
1894 | 98 | ~InlinedRegionBodyRAII() { CGF.AllocaInsertPt = OldAllocaIP; } |
1895 | | }; |
1896 | | }; |
1897 | | |
1898 | | private: |
1899 | | /// CXXThisDecl - When generating code for a C++ member function, |
1900 | | /// this will hold the implicit 'this' declaration. |
1901 | | ImplicitParamDecl *CXXABIThisDecl = nullptr; |
1902 | | llvm::Value *CXXABIThisValue = nullptr; |
1903 | | llvm::Value *CXXThisValue = nullptr; |
1904 | | CharUnits CXXABIThisAlignment; |
1905 | | CharUnits CXXThisAlignment; |
1906 | | |
1907 | | /// The value of 'this' to use when evaluating CXXDefaultInitExprs within |
1908 | | /// this expression. |
1909 | | Address CXXDefaultInitExprThis = Address::invalid(); |
1910 | | |
1911 | | /// The current array initialization index when evaluating an |
1912 | | /// ArrayInitIndexExpr within an ArrayInitLoopExpr. |
1913 | | llvm::Value *ArrayInitIndex = nullptr; |
1914 | | |
1915 | | /// The values of function arguments to use when evaluating |
1916 | | /// CXXInheritedCtorInitExprs within this context. |
1917 | | CallArgList CXXInheritedCtorInitExprArgs; |
1918 | | |
1919 | | /// CXXStructorImplicitParamDecl - When generating code for a constructor or |
1920 | | /// destructor, this will hold the implicit argument (e.g. VTT). |
1921 | | ImplicitParamDecl *CXXStructorImplicitParamDecl = nullptr; |
1922 | | llvm::Value *CXXStructorImplicitParamValue = nullptr; |
1923 | | |
1924 | | /// OutermostConditional - Points to the outermost active |
1925 | | /// conditional control. This is used so that we know if a |
1926 | | /// temporary should be destroyed conditionally. |
1927 | | ConditionalEvaluation *OutermostConditional = nullptr; |
1928 | | |
1929 | | /// The current lexical scope. |
1930 | | LexicalScope *CurLexicalScope = nullptr; |
1931 | | |
1932 | | /// The current source location that should be used for exception |
1933 | | /// handling code. |
1934 | | SourceLocation CurEHLocation; |
1935 | | |
1936 | | /// BlockByrefInfos - For each __block variable, contains |
1937 | | /// information about the layout of the variable. |
1938 | | llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos; |
1939 | | |
1940 | | /// Used by -fsanitize=nullability-return to determine whether the return |
1941 | | /// value can be checked. |
1942 | | llvm::Value *RetValNullabilityPrecondition = nullptr; |
1943 | | |
1944 | | /// Check if -fsanitize=nullability-return instrumentation is required for |
1945 | | /// this function. |
1946 | 1.14M | bool requiresReturnValueNullabilityCheck() const { |
1947 | 1.14M | return RetValNullabilityPrecondition; |
1948 | 1.14M | } |
1949 | | |
1950 | | /// Used to store precise source locations for return statements by the |
1951 | | /// runtime return value checks. |
1952 | | Address ReturnLocation = Address::invalid(); |
1953 | | |
1954 | | /// Check if the return value of this function requires sanitization. |
1955 | | bool requiresReturnValueCheck() const; |
1956 | | |
1957 | | llvm::BasicBlock *TerminateLandingPad = nullptr; |
1958 | | llvm::BasicBlock *TerminateHandler = nullptr; |
1959 | | llvm::SmallVector<llvm::BasicBlock *, 2> TrapBBs; |
1960 | | |
1961 | | /// Terminate funclets keyed by parent funclet pad. |
1962 | | llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets; |
1963 | | |
1964 | | /// Largest vector width used in ths function. Will be used to create a |
1965 | | /// function attribute. |
1966 | | unsigned LargestVectorWidth = 0; |
1967 | | |
1968 | | /// True if we need emit the life-time markers. This is initially set in |
1969 | | /// the constructor, but could be overwritten to true if this is a coroutine. |
1970 | | bool ShouldEmitLifetimeMarkers; |
1971 | | |
1972 | | /// Add OpenCL kernel arg metadata and the kernel attribute metadata to |
1973 | | /// the function metadata. |
1974 | | void EmitOpenCLKernelMetadata(const FunctionDecl *FD, |
1975 | | llvm::Function *Fn); |
1976 | | |
1977 | | public: |
1978 | | CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false); |
1979 | | ~CodeGenFunction(); |
1980 | | |
1981 | 551k | CodeGenTypes &getTypes() const { return CGM.getTypes(); } |
1982 | 15.9M | ASTContext &getContext() const { return CGM.getContext(); } |
1983 | 12.0M | CGDebugInfo *getDebugInfo() { |
1984 | 12.0M | if (DisableDebugInfo) |
1985 | 7.76k | return nullptr; |
1986 | 12.0M | return DebugInfo; |
1987 | 12.0M | } |
1988 | 2.80k | void disableDebugInfo() { DisableDebugInfo = true; } |
1989 | 2.80k | void enableDebugInfo() { DisableDebugInfo = false; } |
1990 | | |
1991 | 229 | bool shouldUseFusedARCCalls() { |
1992 | 229 | return CGM.getCodeGenOpts().OptimizationLevel == 0; |
1993 | 229 | } |
1994 | | |
1995 | 11.6M | const LangOptions &getLangOpts() const { return CGM.getLangOpts(); } |
1996 | | |
1997 | | /// Returns a pointer to the function's exception object and selector slot, |
1998 | | /// which is assigned in every landing pad. |
1999 | | Address getExceptionSlot(); |
2000 | | Address getEHSelectorSlot(); |
2001 | | |
2002 | | /// Returns the contents of the function's exception object and selector |
2003 | | /// slots. |
2004 | | llvm::Value *getExceptionFromSlot(); |
2005 | | llvm::Value *getSelectorFromSlot(); |
2006 | | |
2007 | | Address getNormalCleanupDestSlot(); |
2008 | | |
2009 | 435 | llvm::BasicBlock *getUnreachableBlock() { |
2010 | 435 | if (!UnreachableBlock) { |
2011 | 390 | UnreachableBlock = createBasicBlock("unreachable"); |
2012 | 390 | new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock); |
2013 | 390 | } |
2014 | 435 | return UnreachableBlock; |
2015 | 435 | } |
2016 | | |
2017 | 229k | llvm::BasicBlock *getInvokeDest() { |
2018 | 229k | if (!EHStack.requiresLandingPad()) return nullptr191k ; |
2019 | 38.2k | return getInvokeDestImpl(); |
2020 | 229k | } |
2021 | | |
2022 | 366k | bool currentFunctionUsesSEHTry() const { return CurSEHParent != nullptr; } |
2023 | | |
2024 | 607k | const TargetInfo &getTarget() const { return Target; } |
2025 | 3.38M | llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); } |
2026 | 28.5k | const TargetCodeGenInfo &getTargetHooks() const { |
2027 | 28.5k | return CGM.getTargetCodeGenInfo(); |
2028 | 28.5k | } |
2029 | | |
2030 | | //===--------------------------------------------------------------------===// |
2031 | | // Cleanups |
2032 | | //===--------------------------------------------------------------------===// |
2033 | | |
2034 | | typedef void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty); |
2035 | | |
2036 | | void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, |
2037 | | Address arrayEndPointer, |
2038 | | QualType elementType, |
2039 | | CharUnits elementAlignment, |
2040 | | Destroyer *destroyer); |
2041 | | void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, |
2042 | | llvm::Value *arrayEnd, |
2043 | | QualType elementType, |
2044 | | CharUnits elementAlignment, |
2045 | | Destroyer *destroyer); |
2046 | | |
2047 | | void pushDestroy(QualType::DestructionKind dtorKind, |
2048 | | Address addr, QualType type); |
2049 | | void pushEHDestroy(QualType::DestructionKind dtorKind, |
2050 | | Address addr, QualType type); |
2051 | | void pushDestroy(CleanupKind kind, Address addr, QualType type, |
2052 | | Destroyer *destroyer, bool useEHCleanupForArray); |
2053 | | void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, |
2054 | | QualType type, Destroyer *destroyer, |
2055 | | bool useEHCleanupForArray); |
2056 | | void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, |
2057 | | llvm::Value *CompletePtr, |
2058 | | QualType ElementType); |
2059 | | void pushStackRestore(CleanupKind kind, Address SPMem); |
2060 | | void emitDestroy(Address addr, QualType type, Destroyer *destroyer, |
2061 | | bool useEHCleanupForArray); |
2062 | | llvm::Function *generateDestroyHelper(Address addr, QualType type, |
2063 | | Destroyer *destroyer, |
2064 | | bool useEHCleanupForArray, |
2065 | | const VarDecl *VD); |
2066 | | void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, |
2067 | | QualType elementType, CharUnits elementAlign, |
2068 | | Destroyer *destroyer, |
2069 | | bool checkZeroLength, bool useEHCleanup); |
2070 | | |
2071 | | Destroyer *getDestroyer(QualType::DestructionKind destructionKind); |
2072 | | |
2073 | | /// Determines whether an EH cleanup is required to destroy a type |
2074 | | /// with the given destruction kind. |
2075 | 23.5k | bool needsEHCleanup(QualType::DestructionKind kind) { |
2076 | 23.5k | switch (kind) { |
2077 | 17.3k | case QualType::DK_none: |
2078 | 17.3k | return false; |
2079 | 5.07k | case QualType::DK_cxx_destructor: |
2080 | 5.56k | case QualType::DK_objc_weak_lifetime: |
2081 | 5.65k | case QualType::DK_nontrivial_c_struct: |
2082 | 5.65k | return getLangOpts().Exceptions; |
2083 | 559 | case QualType::DK_objc_strong_lifetime: |
2084 | 559 | return getLangOpts().Exceptions && |
2085 | 559 | CGM.getCodeGenOpts().ObjCAutoRefCountExceptions90 ; |
2086 | 23.5k | } |
2087 | 0 | llvm_unreachable("bad destruction kind"); |
2088 | 0 | } |
2089 | | |
2090 | 1.83k | CleanupKind getCleanupKind(QualType::DestructionKind kind) { |
2091 | 1.83k | return (needsEHCleanup(kind) ? NormalAndEHCleanup906 : NormalCleanup929 ); |
2092 | 1.83k | } |
2093 | | |
2094 | | //===--------------------------------------------------------------------===// |
2095 | | // Objective-C |
2096 | | //===--------------------------------------------------------------------===// |
2097 | | |
2098 | | void GenerateObjCMethod(const ObjCMethodDecl *OMD); |
2099 | | |
2100 | | void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD); |
2101 | | |
2102 | | /// GenerateObjCGetter - Synthesize an Objective-C property getter function. |
2103 | | void GenerateObjCGetter(ObjCImplementationDecl *IMP, |
2104 | | const ObjCPropertyImplDecl *PID); |
2105 | | void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, |
2106 | | const ObjCPropertyImplDecl *propImpl, |
2107 | | const ObjCMethodDecl *GetterMothodDecl, |
2108 | | llvm::Constant *AtomicHelperFn); |
2109 | | |
2110 | | void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, |
2111 | | ObjCMethodDecl *MD, bool ctor); |
2112 | | |
2113 | | /// GenerateObjCSetter - Synthesize an Objective-C property setter function |
2114 | | /// for the given property. |
2115 | | void GenerateObjCSetter(ObjCImplementationDecl *IMP, |
2116 | | const ObjCPropertyImplDecl *PID); |
2117 | | void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, |
2118 | | const ObjCPropertyImplDecl *propImpl, |
2119 | | llvm::Constant *AtomicHelperFn); |
2120 | | |
2121 | | //===--------------------------------------------------------------------===// |
2122 | | // Block Bits |
2123 | | //===--------------------------------------------------------------------===// |
2124 | | |
2125 | | /// Emit block literal. |
2126 | | /// \return an LLVM value which is a pointer to a struct which contains |
2127 | | /// information about the block, including the block invoke function, the |
2128 | | /// captured variables, etc. |
2129 | | llvm::Value *EmitBlockLiteral(const BlockExpr *); |
2130 | | |
2131 | | llvm::Function *GenerateBlockFunction(GlobalDecl GD, |
2132 | | const CGBlockInfo &Info, |
2133 | | const DeclMapTy &ldm, |
2134 | | bool IsLambdaConversionToBlock, |
2135 | | bool BuildGlobalBlock); |
2136 | | |
2137 | | /// Check if \p T is a C++ class that has a destructor that can throw. |
2138 | | static bool cxxDestructorCanThrow(QualType T); |
2139 | | |
2140 | | llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo); |
2141 | | llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo); |
2142 | | llvm::Constant *GenerateObjCAtomicSetterCopyHelperFunction( |
2143 | | const ObjCPropertyImplDecl *PID); |
2144 | | llvm::Constant *GenerateObjCAtomicGetterCopyHelperFunction( |
2145 | | const ObjCPropertyImplDecl *PID); |
2146 | | llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty); |
2147 | | |
2148 | | void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags, |
2149 | | bool CanThrow); |
2150 | | |
2151 | | class AutoVarEmission; |
2152 | | |
2153 | | void emitByrefStructureInit(const AutoVarEmission &emission); |
2154 | | |
2155 | | /// Enter a cleanup to destroy a __block variable. Note that this |
2156 | | /// cleanup should be a no-op if the variable hasn't left the stack |
2157 | | /// yet; if a cleanup is required for the variable itself, that needs |
2158 | | /// to be done externally. |
2159 | | /// |
2160 | | /// \param Kind Cleanup kind. |
2161 | | /// |
2162 | | /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block |
2163 | | /// structure that will be passed to _Block_object_dispose. When |
2164 | | /// \p LoadBlockVarAddr is true, the address of the field of the block |
2165 | | /// structure that holds the address of the __block structure. |
2166 | | /// |
2167 | | /// \param Flags The flag that will be passed to _Block_object_dispose. |
2168 | | /// |
2169 | | /// \param LoadBlockVarAddr Indicates whether we need to emit a load from |
2170 | | /// \p Addr to get the address of the __block structure. |
2171 | | void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, |
2172 | | bool LoadBlockVarAddr, bool CanThrow); |
2173 | | |
2174 | | void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, |
2175 | | llvm::Value *ptr); |
2176 | | |
2177 | | Address LoadBlockStruct(); |
2178 | | Address GetAddrOfBlockDecl(const VarDecl *var); |
2179 | | |
2180 | | /// BuildBlockByrefAddress - Computes the location of the |
2181 | | /// data in a variable which is declared as __block. |
2182 | | Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V, |
2183 | | bool followForward = true); |
2184 | | Address emitBlockByrefAddress(Address baseAddr, |
2185 | | const BlockByrefInfo &info, |
2186 | | bool followForward, |
2187 | | const llvm::Twine &name); |
2188 | | |
2189 | | const BlockByrefInfo &getBlockByrefInfo(const VarDecl *var); |
2190 | | |
2191 | | QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args); |
2192 | | |
2193 | | void GenerateCode(GlobalDecl GD, llvm::Function *Fn, |
2194 | | const CGFunctionInfo &FnInfo); |
2195 | | |
2196 | | /// Annotate the function with an attribute that disables TSan checking at |
2197 | | /// runtime. |
2198 | | void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn); |
2199 | | |
2200 | | /// Emit code for the start of a function. |
2201 | | /// \param Loc The location to be associated with the function. |
2202 | | /// \param StartLoc The location of the function body. |
2203 | | void StartFunction(GlobalDecl GD, |
2204 | | QualType RetTy, |
2205 | | llvm::Function *Fn, |
2206 | | const CGFunctionInfo &FnInfo, |
2207 | | const FunctionArgList &Args, |
2208 | | SourceLocation Loc = SourceLocation(), |
2209 | | SourceLocation StartLoc = SourceLocation()); |
2210 | | |
2211 | | static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor); |
2212 | | |
2213 | | void EmitConstructorBody(FunctionArgList &Args); |
2214 | | void EmitDestructorBody(FunctionArgList &Args); |
2215 | | void emitImplicitAssignmentOperatorBody(FunctionArgList &Args); |
2216 | | void EmitFunctionBody(const Stmt *Body); |
2217 | | void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S); |
2218 | | |
2219 | | void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator, |
2220 | | CallArgList &CallArgs); |
2221 | | void EmitLambdaBlockInvokeBody(); |
2222 | | void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD); |
2223 | | void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD); |
2224 | 71 | void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV) { |
2225 | 71 | EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV); |
2226 | 71 | } |
2227 | | void EmitAsanPrologueOrEpilogue(bool Prologue); |
2228 | | |
2229 | | /// Emit the unified return block, trying to avoid its emission when |
2230 | | /// possible. |
2231 | | /// \return The debug location of the user written return statement if the |
2232 | | /// return block is is avoided. |
2233 | | llvm::DebugLoc EmitReturnBlock(); |
2234 | | |
2235 | | /// FinishFunction - Complete IR generation of the current function. It is |
2236 | | /// legal to call this function even if there is no current insertion point. |
2237 | | void FinishFunction(SourceLocation EndLoc=SourceLocation()); |
2238 | | |
2239 | | void StartThunk(llvm::Function *Fn, GlobalDecl GD, |
2240 | | const CGFunctionInfo &FnInfo, bool IsUnprototyped); |
2241 | | |
2242 | | void EmitCallAndReturnForThunk(llvm::FunctionCallee Callee, |
2243 | | const ThunkInfo *Thunk, bool IsUnprototyped); |
2244 | | |
2245 | | void FinishThunk(); |
2246 | | |
2247 | | /// Emit a musttail call for a thunk with a potentially adjusted this pointer. |
2248 | | void EmitMustTailThunk(GlobalDecl GD, llvm::Value *AdjustedThisPtr, |
2249 | | llvm::FunctionCallee Callee); |
2250 | | |
2251 | | /// Generate a thunk for the given method. |
2252 | | void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, |
2253 | | GlobalDecl GD, const ThunkInfo &Thunk, |
2254 | | bool IsUnprototyped); |
2255 | | |
2256 | | llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn, |
2257 | | const CGFunctionInfo &FnInfo, |
2258 | | GlobalDecl GD, const ThunkInfo &Thunk); |
2259 | | |
2260 | | void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, |
2261 | | FunctionArgList &Args); |
2262 | | |
2263 | | void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init); |
2264 | | |
2265 | | /// Struct with all information about dynamic [sub]class needed to set vptr. |
2266 | | struct VPtr { |
2267 | | BaseSubobject Base; |
2268 | | const CXXRecordDecl *NearestVBase; |
2269 | | CharUnits OffsetFromNearestVBase; |
2270 | | const CXXRecordDecl *VTableClass; |
2271 | | }; |
2272 | | |
2273 | | /// Initialize the vtable pointer of the given subobject. |
2274 | | void InitializeVTablePointer(const VPtr &vptr); |
2275 | | |
2276 | | typedef llvm::SmallVector<VPtr, 4> VPtrsVector; |
2277 | | |
2278 | | typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy; |
2279 | | VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass); |
2280 | | |
2281 | | void getVTablePointers(BaseSubobject Base, const CXXRecordDecl *NearestVBase, |
2282 | | CharUnits OffsetFromNearestVBase, |
2283 | | bool BaseIsNonVirtualPrimaryBase, |
2284 | | const CXXRecordDecl *VTableClass, |
2285 | | VisitedVirtualBasesSetTy &VBases, VPtrsVector &vptrs); |
2286 | | |
2287 | | void InitializeVTablePointers(const CXXRecordDecl *ClassDecl); |
2288 | | |
2289 | | /// GetVTablePtr - Return the Value of the vtable pointer member pointed |
2290 | | /// to by This. |
2291 | | llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy, |
2292 | | const CXXRecordDecl *VTableClass); |
2293 | | |
2294 | | enum CFITypeCheckKind { |
2295 | | CFITCK_VCall, |
2296 | | CFITCK_NVCall, |
2297 | | CFITCK_DerivedCast, |
2298 | | CFITCK_UnrelatedCast, |
2299 | | CFITCK_ICall, |
2300 | | CFITCK_NVMFCall, |
2301 | | CFITCK_VMFCall, |
2302 | | }; |
2303 | | |
2304 | | /// Derived is the presumed address of an object of type T after a |
2305 | | /// cast. If T is a polymorphic class type, emit a check that the virtual |
2306 | | /// table for Derived belongs to a class derived from T. |
2307 | | void EmitVTablePtrCheckForCast(QualType T, Address Derived, bool MayBeNull, |
2308 | | CFITypeCheckKind TCK, SourceLocation Loc); |
2309 | | |
2310 | | /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable. |
2311 | | /// If vptr CFI is enabled, emit a check that VTable is valid. |
2312 | | void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, |
2313 | | CFITypeCheckKind TCK, SourceLocation Loc); |
2314 | | |
2315 | | /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for |
2316 | | /// RD using llvm.type.test. |
2317 | | void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable, |
2318 | | CFITypeCheckKind TCK, SourceLocation Loc); |
2319 | | |
2320 | | /// If whole-program virtual table optimization is enabled, emit an assumption |
2321 | | /// that VTable is a member of RD's type identifier. Or, if vptr CFI is |
2322 | | /// enabled, emit a check that VTable is a member of RD's type identifier. |
2323 | | void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, |
2324 | | llvm::Value *VTable, SourceLocation Loc); |
2325 | | |
2326 | | /// Returns whether we should perform a type checked load when loading a |
2327 | | /// virtual function for virtual calls to members of RD. This is generally |
2328 | | /// true when both vcall CFI and whole-program-vtables are enabled. |
2329 | | bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD); |
2330 | | |
2331 | | /// Emit a type checked load from the given vtable. |
2332 | | llvm::Value *EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, |
2333 | | llvm::Value *VTable, |
2334 | | llvm::Type *VTableTy, |
2335 | | uint64_t VTableByteOffset); |
2336 | | |
2337 | | /// EnterDtorCleanups - Enter the cleanups necessary to complete the |
2338 | | /// given phase of destruction for a destructor. The end result |
2339 | | /// should call destructors on members and base classes in reverse |
2340 | | /// order of their construction. |
2341 | | void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type); |
2342 | | |
2343 | | /// ShouldInstrumentFunction - Return true if the current function should be |
2344 | | /// instrumented with __cyg_profile_func_* calls |
2345 | | bool ShouldInstrumentFunction(); |
2346 | | |
2347 | | /// ShouldSkipSanitizerInstrumentation - Return true if the current function |
2348 | | /// should not be instrumented with sanitizers. |
2349 | | bool ShouldSkipSanitizerInstrumentation(); |
2350 | | |
2351 | | /// ShouldXRayInstrument - Return true if the current function should be |
2352 | | /// instrumented with XRay nop sleds. |
2353 | | bool ShouldXRayInstrumentFunction() const; |
2354 | | |
2355 | | /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit |
2356 | | /// XRay custom event handling calls. |
2357 | | bool AlwaysEmitXRayCustomEvents() const; |
2358 | | |
2359 | | /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit |
2360 | | /// XRay typed event handling calls. |
2361 | | bool AlwaysEmitXRayTypedEvents() const; |
2362 | | |
2363 | | /// Encode an address into a form suitable for use in a function prologue. |
2364 | | llvm::Constant *EncodeAddrForUseInPrologue(llvm::Function *F, |
2365 | | llvm::Constant *Addr); |
2366 | | |
2367 | | /// Decode an address used in a function prologue, encoded by \c |
2368 | | /// EncodeAddrForUseInPrologue. |
2369 | | llvm::Value *DecodeAddrUsedInPrologue(llvm::Value *F, |
2370 | | llvm::Value *EncodedAddr); |
2371 | | |
2372 | | /// EmitFunctionProlog - Emit the target specific LLVM code to load the |
2373 | | /// arguments for the given function. This is also responsible for naming the |
2374 | | /// LLVM function arguments. |
2375 | | void EmitFunctionProlog(const CGFunctionInfo &FI, |
2376 | | llvm::Function *Fn, |
2377 | | const FunctionArgList &Args); |
2378 | | |
2379 | | /// EmitFunctionEpilog - Emit the target specific LLVM code to return the |
2380 | | /// given temporary. |
2381 | | void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, |
2382 | | SourceLocation EndLoc); |
2383 | | |
2384 | | /// Emit a test that checks if the return value \p RV is nonnull. |
2385 | | void EmitReturnValueCheck(llvm::Value *RV); |
2386 | | |
2387 | | /// EmitStartEHSpec - Emit the start of the exception spec. |
2388 | | void EmitStartEHSpec(const Decl *D); |
2389 | | |
2390 | | /// EmitEndEHSpec - Emit the end of the exception spec. |
2391 | | void EmitEndEHSpec(const Decl *D); |
2392 | | |
2393 | | /// getTerminateLandingPad - Return a landing pad that just calls terminate. |
2394 | | llvm::BasicBlock *getTerminateLandingPad(); |
2395 | | |
2396 | | /// getTerminateLandingPad - Return a cleanup funclet that just calls |
2397 | | /// terminate. |
2398 | | llvm::BasicBlock *getTerminateFunclet(); |
2399 | | |
2400 | | /// getTerminateHandler - Return a handler (not a landing pad, just |
2401 | | /// a catch handler) that just calls terminate. This is used when |
2402 | | /// a terminate scope encloses a try. |
2403 | | llvm::BasicBlock *getTerminateHandler(); |
2404 | | |
2405 | | llvm::Type *ConvertTypeForMem(QualType T); |
2406 | | llvm::Type *ConvertType(QualType T); |
2407 | 22.2k | llvm::Type *ConvertType(const TypeDecl *T) { |
2408 | 22.2k | return ConvertType(getContext().getTypeDeclType(T)); |
2409 | 22.2k | } |
2410 | | |
2411 | | /// LoadObjCSelf - Load the value of self. This function is only valid while |
2412 | | /// generating code for an Objective-C method. |
2413 | | llvm::Value *LoadObjCSelf(); |
2414 | | |
2415 | | /// TypeOfSelfObject - Return type of object that this self represents. |
2416 | | QualType TypeOfSelfObject(); |
2417 | | |
2418 | | /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T. |
2419 | | static TypeEvaluationKind getEvaluationKind(QualType T); |
2420 | | |
2421 | 3.88M | static bool hasScalarEvaluationKind(QualType T) { |
2422 | 3.88M | return getEvaluationKind(T) == TEK_Scalar; |
2423 | 3.88M | } |
2424 | | |
2425 | 769k | static bool hasAggregateEvaluationKind(QualType T) { |
2426 | 769k | return getEvaluationKind(T) == TEK_Aggregate; |
2427 | 769k | } |
2428 | | |
2429 | | /// createBasicBlock - Create an LLVM basic block. |
2430 | | llvm::BasicBlock *createBasicBlock(const Twine &name = "", |
2431 | | llvm::Function *parent = nullptr, |
2432 | 1.22M | llvm::BasicBlock *before = nullptr) { |
2433 | 1.22M | return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before); |
2434 | 1.22M | } |
2435 | | |
2436 | | /// getBasicBlockForLabel - Return the LLVM basicblock that the specified |
2437 | | /// label maps to. |
2438 | | JumpDest getJumpDestForLabel(const LabelDecl *S); |
2439 | | |
2440 | | /// SimplifyForwardingBlocks - If the given basic block is only a branch to |
2441 | | /// another basic block, simplify it. This assumes that no other code could |
2442 | | /// potentially reference the basic block. |
2443 | | void SimplifyForwardingBlocks(llvm::BasicBlock *BB); |
2444 | | |
2445 | | /// EmitBlock - Emit the given block \arg BB and set it as the insert point, |
2446 | | /// adding a fall-through branch from the current insert block if |
2447 | | /// necessary. It is legal to call this function even if there is no current |
2448 | | /// insertion point. |
2449 | | /// |
2450 | | /// IsFinished - If true, indicates that the caller has finished emitting |
2451 | | /// branches to the given block and does not expect to emit code into it. This |
2452 | | /// means the block can be ignored if it is unreachable. |
2453 | | void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false); |
2454 | | |
2455 | | /// EmitBlockAfterUses - Emit the given block somewhere hopefully |
2456 | | /// near its uses, and leave the insertion point in it. |
2457 | | void EmitBlockAfterUses(llvm::BasicBlock *BB); |
2458 | | |
2459 | | /// EmitBranch - Emit a branch to the specified basic block from the current |
2460 | | /// insert block, taking care to avoid creation of branches from dummy |
2461 | | /// blocks. It is legal to call this function even if there is no current |
2462 | | /// insertion point. |
2463 | | /// |
2464 | | /// This function clears the current insertion point. The caller should follow |
2465 | | /// calls to this function with calls to Emit*Block prior to generation new |
2466 | | /// code. |
2467 | | void EmitBranch(llvm::BasicBlock *Block); |
2468 | | |
2469 | | /// HaveInsertPoint - True if an insertion point is defined. If not, this |
2470 | | /// indicates that the current code being emitted is unreachable. |
2471 | 2.34M | bool HaveInsertPoint() const { |
2472 | 2.34M | return Builder.GetInsertBlock() != nullptr; |
2473 | 2.34M | } |
2474 | | |
2475 | | /// EnsureInsertPoint - Ensure that an insertion point is defined so that |
2476 | | /// emitted IR has a place to go. Note that by definition, if this function |
2477 | | /// creates a block then that block is unreachable; callers may do better to |
2478 | | /// detect when no insertion point is defined and simply skip IR generation. |
2479 | 22.0k | void EnsureInsertPoint() { |
2480 | 22.0k | if (!HaveInsertPoint()) |
2481 | 2.36k | EmitBlock(createBasicBlock()); |
2482 | 22.0k | } |
2483 | | |
2484 | | /// ErrorUnsupported - Print out an error that codegen doesn't support the |
2485 | | /// specified stmt yet. |
2486 | | void ErrorUnsupported(const Stmt *S, const char *Type); |
2487 | | |
2488 | | //===--------------------------------------------------------------------===// |
2489 | | // Helpers |
2490 | | //===--------------------------------------------------------------------===// |
2491 | | |
2492 | | LValue MakeAddrLValue(Address Addr, QualType T, |
2493 | 2.25M | AlignmentSource Source = AlignmentSource::Type) { |
2494 | 2.25M | return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source), |
2495 | 2.25M | CGM.getTBAAAccessInfo(T)); |
2496 | 2.25M | } |
2497 | | |
2498 | | LValue MakeAddrLValue(Address Addr, QualType T, LValueBaseInfo BaseInfo, |
2499 | 720k | TBAAAccessInfo TBAAInfo) { |
2500 | 720k | return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo); |
2501 | 720k | } |
2502 | | |
2503 | | LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment, |
2504 | 3.45k | AlignmentSource Source = AlignmentSource::Type) { |
2505 | 3.45k | Address Addr(V, ConvertTypeForMem(T), Alignment); |
2506 | 3.45k | return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source), |
2507 | 3.45k | CGM.getTBAAAccessInfo(T)); |
2508 | 3.45k | } |
2509 | | |
2510 | | LValue |
2511 | | MakeAddrLValueWithoutTBAA(Address Addr, QualType T, |
2512 | 30 | AlignmentSource Source = AlignmentSource::Type) { |
2513 | 30 | return LValue::MakeAddr(Addr, T, getContext(), LValueBaseInfo(Source), |
2514 | 30 | TBAAAccessInfo()); |
2515 | 30 | } |
2516 | | |
2517 | | LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T); |
2518 | | LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T); |
2519 | | |
2520 | | Address EmitLoadOfReference(LValue RefLVal, |
2521 | | LValueBaseInfo *PointeeBaseInfo = nullptr, |
2522 | | TBAAAccessInfo *PointeeTBAAInfo = nullptr); |
2523 | | LValue EmitLoadOfReferenceLValue(LValue RefLVal); |
2524 | | LValue EmitLoadOfReferenceLValue(Address RefAddr, QualType RefTy, |
2525 | | AlignmentSource Source = |
2526 | 63.9k | AlignmentSource::Type) { |
2527 | 63.9k | LValue RefLVal = MakeAddrLValue(RefAddr, RefTy, LValueBaseInfo(Source), |
2528 | 63.9k | CGM.getTBAAAccessInfo(RefTy)); |
2529 | 63.9k | return EmitLoadOfReferenceLValue(RefLVal); |
2530 | 63.9k | } |
2531 | | |
2532 | | /// Load a pointer with type \p PtrTy stored at address \p Ptr. |
2533 | | /// Note that \p PtrTy is the type of the loaded pointer, not the addresses |
2534 | | /// it is loaded from. |
2535 | | Address EmitLoadOfPointer(Address Ptr, const PointerType *PtrTy, |
2536 | | LValueBaseInfo *BaseInfo = nullptr, |
2537 | | TBAAAccessInfo *TBAAInfo = nullptr); |
2538 | | LValue EmitLoadOfPointerLValue(Address Ptr, const PointerType *PtrTy); |
2539 | | |
2540 | | /// CreateTempAlloca - This creates an alloca and inserts it into the entry |
2541 | | /// block if \p ArraySize is nullptr, otherwise inserts it at the current |
2542 | | /// insertion point of the builder. The caller is responsible for setting an |
2543 | | /// appropriate alignment on |
2544 | | /// the alloca. |
2545 | | /// |
2546 | | /// \p ArraySize is the number of array elements to be allocated if it |
2547 | | /// is not nullptr. |
2548 | | /// |
2549 | | /// LangAS::Default is the address space of pointers to local variables and |
2550 | | /// temporaries, as exposed in the source language. In certain |
2551 | | /// configurations, this is not the same as the alloca address space, and a |
2552 | | /// cast is needed to lift the pointer from the alloca AS into |
2553 | | /// LangAS::Default. This can happen when the target uses a restricted |
2554 | | /// address space for the stack but the source language requires |
2555 | | /// LangAS::Default to be a generic address space. The latter condition is |
2556 | | /// common for most programming languages; OpenCL is an exception in that |
2557 | | /// LangAS::Default is the private address space, which naturally maps |
2558 | | /// to the stack. |
2559 | | /// |
2560 | | /// Because the address of a temporary is often exposed to the program in |
2561 | | /// various ways, this function will perform the cast. The original alloca |
2562 | | /// instruction is returned through \p Alloca if it is not nullptr. |
2563 | | /// |
2564 | | /// The cast is not performaed in CreateTempAllocaWithoutCast. This is |
2565 | | /// more efficient if the caller knows that the address will not be exposed. |
2566 | | llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp", |
2567 | | llvm::Value *ArraySize = nullptr); |
2568 | | Address CreateTempAlloca(llvm::Type *Ty, CharUnits align, |
2569 | | const Twine &Name = "tmp", |
2570 | | llvm::Value *ArraySize = nullptr, |
2571 | | Address *Alloca = nullptr); |
2572 | | Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, |
2573 | | const Twine &Name = "tmp", |
2574 | | llvm::Value *ArraySize = nullptr); |
2575 | | |
2576 | | /// CreateDefaultAlignedTempAlloca - This creates an alloca with the |
2577 | | /// default ABI alignment of the given LLVM type. |
2578 | | /// |
2579 | | /// IMPORTANT NOTE: This is *not* generally the right alignment for |
2580 | | /// any given AST type that happens to have been lowered to the |
2581 | | /// given IR type. This should only ever be used for function-local, |
2582 | | /// IR-driven manipulations like saving and restoring a value. Do |
2583 | | /// not hand this address off to arbitrary IRGen routines, and especially |
2584 | | /// do not pass it as an argument to a function that might expect a |
2585 | | /// properly ABI-aligned value. |
2586 | | Address CreateDefaultAlignTempAlloca(llvm::Type *Ty, |
2587 | | const Twine &Name = "tmp"); |
2588 | | |
2589 | | /// CreateIRTemp - Create a temporary IR object of the given type, with |
2590 | | /// appropriate alignment. This routine should only be used when an temporary |
2591 | | /// value needs to be stored into an alloca (for example, to avoid explicit |
2592 | | /// PHI construction), but the type is the IR type, not the type appropriate |
2593 | | /// for storing in memory. |
2594 | | /// |
2595 | | /// That is, this is exactly equivalent to CreateMemTemp, but calling |
2596 | | /// ConvertType instead of ConvertTypeForMem. |
2597 | | Address CreateIRTemp(QualType T, const Twine &Name = "tmp"); |
2598 | | |
2599 | | /// CreateMemTemp - Create a temporary memory object of the given type, with |
2600 | | /// appropriate alignmen and cast it to the default address space. Returns |
2601 | | /// the original alloca instruction by \p Alloca if it is not nullptr. |
2602 | | Address CreateMemTemp(QualType T, const Twine &Name = "tmp", |
2603 | | Address *Alloca = nullptr); |
2604 | | Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp", |
2605 | | Address *Alloca = nullptr); |
2606 | | |
2607 | | /// CreateMemTemp - Create a temporary memory object of the given type, with |
2608 | | /// appropriate alignmen without casting it to the default address space. |
2609 | | Address CreateMemTempWithoutCast(QualType T, const Twine &Name = "tmp"); |
2610 | | Address CreateMemTempWithoutCast(QualType T, CharUnits Align, |
2611 | | const Twine &Name = "tmp"); |
2612 | | |
2613 | | /// CreateAggTemp - Create a temporary memory object for the given |
2614 | | /// aggregate type. |
2615 | | AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp", |
2616 | 10.1k | Address *Alloca = nullptr) { |
2617 | 10.1k | return AggValueSlot::forAddr(CreateMemTemp(T, Name, Alloca), |
2618 | 10.1k | T.getQualifiers(), |
2619 | 10.1k | AggValueSlot::IsNotDestructed, |
2620 | 10.1k | AggValueSlot::DoesNotNeedGCBarriers, |
2621 | 10.1k | AggValueSlot::IsNotAliased, |
2622 | 10.1k | AggValueSlot::DoesNotOverlap); |
2623 | 10.1k | } |
2624 | | |
2625 | | /// Emit a cast to void* in the appropriate address space. |
2626 | | llvm::Value *EmitCastToVoidPtr(llvm::Value *value); |
2627 | | |
2628 | | /// EvaluateExprAsBool - Perform the usual unary conversions on the specified |
2629 | | /// expression and compare the result against zero, returning an Int1Ty value. |
2630 | | llvm::Value *EvaluateExprAsBool(const Expr *E); |
2631 | | |
2632 | | /// EmitIgnoredExpr - Emit an expression in a context which ignores the result. |
2633 | | void EmitIgnoredExpr(const Expr *E); |
2634 | | |
2635 | | /// EmitAnyExpr - Emit code to compute the specified expression which can have |
2636 | | /// any type. The result is returned as an RValue struct. If this is an |
2637 | | /// aggregate expression, the aggloc/agglocvolatile arguments indicate where |
2638 | | /// the result should be returned. |
2639 | | /// |
2640 | | /// \param ignoreResult True if the resulting value isn't used. |
2641 | | RValue EmitAnyExpr(const Expr *E, |
2642 | | AggValueSlot aggSlot = AggValueSlot::ignored(), |
2643 | | bool ignoreResult = false); |
2644 | | |
2645 | | // EmitVAListRef - Emit a "reference" to a va_list; this is either the address |
2646 | | // or the value of the expression, depending on how va_list is defined. |
2647 | | Address EmitVAListRef(const Expr *E); |
2648 | | |
2649 | | /// Emit a "reference" to a __builtin_ms_va_list; this is |
2650 | | /// always the value of the expression, because a __builtin_ms_va_list is a |
2651 | | /// pointer to a char. |
2652 | | Address EmitMSVAListRef(const Expr *E); |
2653 | | |
2654 | | /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will |
2655 | | /// always be accessible even if no aggregate location is provided. |
2656 | | RValue EmitAnyExprToTemp(const Expr *E); |
2657 | | |
2658 | | /// EmitAnyExprToMem - Emits the code necessary to evaluate an |
2659 | | /// arbitrary expression into the given memory location. |
2660 | | void EmitAnyExprToMem(const Expr *E, Address Location, |
2661 | | Qualifiers Quals, bool IsInitializer); |
2662 | | |
2663 | | void EmitAnyExprToExn(const Expr *E, Address Addr); |
2664 | | |
2665 | | /// EmitExprAsInit - Emits the code necessary to initialize a |
2666 | | /// location in memory with the given initializer. |
2667 | | void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue, |
2668 | | bool capturedByInit); |
2669 | | |
2670 | | /// hasVolatileMember - returns true if aggregate type has a volatile |
2671 | | /// member. |
2672 | 4.63k | bool hasVolatileMember(QualType T) { |
2673 | 4.63k | if (const RecordType *RT = T->getAs<RecordType>()) { |
2674 | 3.14k | const RecordDecl *RD = cast<RecordDecl>(RT->getDecl()); |
2675 | 3.14k | return RD->hasVolatileMember(); |
2676 | 3.14k | } |
2677 | 1.48k | return false; |
2678 | 4.63k | } |
2679 | | |
2680 | | /// Determine whether a return value slot may overlap some other object. |
2681 | 6.54k | AggValueSlot::Overlap_t getOverlapForReturnValue() { |
2682 | | // FIXME: Assuming no overlap here breaks guaranteed copy elision for base |
2683 | | // class subobjects. These cases may need to be revisited depending on the |
2684 | | // resolution of the relevant core issue. |
2685 | 6.54k | return AggValueSlot::DoesNotOverlap; |
2686 | 6.54k | } |
2687 | | |
2688 | | /// Determine whether a field initialization may overlap some other object. |
2689 | | AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD); |
2690 | | |
2691 | | /// Determine whether a base class initialization may overlap some other |
2692 | | /// object. |
2693 | | AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, |
2694 | | const CXXRecordDecl *BaseRD, |
2695 | | bool IsVirtual); |
2696 | | |
2697 | | /// Emit an aggregate assignment. |
2698 | 4.17k | void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy) { |
2699 | 4.17k | bool IsVolatile = hasVolatileMember(EltTy); |
2700 | 4.17k | EmitAggregateCopy(Dest, Src, EltTy, AggValueSlot::MayOverlap, IsVolatile); |
2701 | 4.17k | } |
2702 | | |
2703 | | void EmitAggregateCopyCtor(LValue Dest, LValue Src, |
2704 | 5.83k | AggValueSlot::Overlap_t MayOverlap) { |
2705 | 5.83k | EmitAggregateCopy(Dest, Src, Src.getType(), MayOverlap); |
2706 | 5.83k | } |
2707 | | |
2708 | | /// EmitAggregateCopy - Emit an aggregate copy. |
2709 | | /// |
2710 | | /// \param isVolatile \c true iff either the source or the destination is |
2711 | | /// volatile. |
2712 | | /// \param MayOverlap Whether the tail padding of the destination might be |
2713 | | /// occupied by some other object. More efficient code can often be |
2714 | | /// generated if not. |
2715 | | void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, |
2716 | | AggValueSlot::Overlap_t MayOverlap, |
2717 | | bool isVolatile = false); |
2718 | | |
2719 | | /// GetAddrOfLocalVar - Return the address of a local variable. |
2720 | 196k | Address GetAddrOfLocalVar(const VarDecl *VD) { |
2721 | 196k | auto it = LocalDeclMap.find(VD); |
2722 | 196k | assert(it != LocalDeclMap.end() && |
2723 | 196k | "Invalid argument to GetAddrOfLocalVar(), no decl!"); |
2724 | 0 | return it->second; |
2725 | 196k | } |
2726 | | |
2727 | | /// Given an opaque value expression, return its LValue mapping if it exists, |
2728 | | /// otherwise create one. |
2729 | | LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e); |
2730 | | |
2731 | | /// Given an opaque value expression, return its RValue mapping if it exists, |
2732 | | /// otherwise create one. |
2733 | | RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e); |
2734 | | |
2735 | | /// Get the index of the current ArrayInitLoopExpr, if any. |
2736 | 78 | llvm::Value *getArrayInitIndex() { return ArrayInitIndex; } |
2737 | | |
2738 | | /// getAccessedFieldNo - Given an encoded value and a result number, return |
2739 | | /// the input field number being accessed. |
2740 | | static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts); |
2741 | | |
2742 | | llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L); |
2743 | | llvm::BasicBlock *GetIndirectGotoBlock(); |
2744 | | |
2745 | | /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts. |
2746 | | static bool IsWrappedCXXThis(const Expr *E); |
2747 | | |
2748 | | /// EmitNullInitialization - Generate code to set a value of the given type to |
2749 | | /// null, If the type contains data member pointers, they will be initialized |
2750 | | /// to -1 in accordance with the Itanium C++ ABI. |
2751 | | void EmitNullInitialization(Address DestPtr, QualType Ty); |
2752 | | |
2753 | | /// Emits a call to an LLVM variable-argument intrinsic, either |
2754 | | /// \c llvm.va_start or \c llvm.va_end. |
2755 | | /// \param ArgValue A reference to the \c va_list as emitted by either |
2756 | | /// \c EmitVAListRef or \c EmitMSVAListRef. |
2757 | | /// \param IsStart If \c true, emits a call to \c llvm.va_start; otherwise, |
2758 | | /// calls \c llvm.va_end. |
2759 | | llvm::Value *EmitVAStartEnd(llvm::Value *ArgValue, bool IsStart); |
2760 | | |
2761 | | /// Generate code to get an argument from the passed in pointer |
2762 | | /// and update it accordingly. |
2763 | | /// \param VE The \c VAArgExpr for which to generate code. |
2764 | | /// \param VAListAddr Receives a reference to the \c va_list as emitted by |
2765 | | /// either \c EmitVAListRef or \c EmitMSVAListRef. |
2766 | | /// \returns A pointer to the argument. |
2767 | | // FIXME: We should be able to get rid of this method and use the va_arg |
2768 | | // instruction in LLVM instead once it works well enough. |
2769 | | Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr); |
2770 | | |
2771 | | /// emitArrayLength - Compute the length of an array, even if it's a |
2772 | | /// VLA, and drill down to the base element type. |
2773 | | llvm::Value *emitArrayLength(const ArrayType *arrayType, |
2774 | | QualType &baseType, |
2775 | | Address &addr); |
2776 | | |
2777 | | /// EmitVLASize - Capture all the sizes for the VLA expressions in |
2778 | | /// the given variably-modified type and store them in the VLASizeMap. |
2779 | | /// |
2780 | | /// This function can be called with a null (unreachable) insert point. |
2781 | | void EmitVariablyModifiedType(QualType Ty); |
2782 | | |
2783 | | struct VlaSizePair { |
2784 | | llvm::Value *NumElts; |
2785 | | QualType Type; |
2786 | | |
2787 | 12.2k | VlaSizePair(llvm::Value *NE, QualType T) : NumElts(NE), Type(T) {} |
2788 | | }; |
2789 | | |
2790 | | /// Return the number of elements for a single dimension |
2791 | | /// for the given array type. |
2792 | | VlaSizePair getVLAElements1D(const VariableArrayType *vla); |
2793 | | VlaSizePair getVLAElements1D(QualType vla); |
2794 | | |
2795 | | /// Returns an LLVM value that corresponds to the size, |
2796 | | /// in non-variably-sized elements, of a variable length array type, |
2797 | | /// plus that largest non-variably-sized element type. Assumes that |
2798 | | /// the type has already been emitted with EmitVariablyModifiedType. |
2799 | | VlaSizePair getVLASize(const VariableArrayType *vla); |
2800 | | VlaSizePair getVLASize(QualType vla); |
2801 | | |
2802 | | /// LoadCXXThis - Load the value of 'this'. This function is only valid while |
2803 | | /// generating code for an C++ member function. |
2804 | 160k | llvm::Value *LoadCXXThis() { |
2805 | 160k | assert(CXXThisValue && "no 'this' value for this function"); |
2806 | 0 | return CXXThisValue; |
2807 | 160k | } |
2808 | | Address LoadCXXThisAddress(); |
2809 | | |
2810 | | /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have |
2811 | | /// virtual bases. |
2812 | | // FIXME: Every place that calls LoadCXXVTT is something |
2813 | | // that needs to be abstracted properly. |
2814 | 325 | llvm::Value *LoadCXXVTT() { |
2815 | 325 | assert(CXXStructorImplicitParamValue && "no VTT value for this function"); |
2816 | 0 | return CXXStructorImplicitParamValue; |
2817 | 325 | } |
2818 | | |
2819 | | /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a |
2820 | | /// complete class to the given direct base. |
2821 | | Address |
2822 | | GetAddressOfDirectBaseInCompleteClass(Address Value, |
2823 | | const CXXRecordDecl *Derived, |
2824 | | const CXXRecordDecl *Base, |
2825 | | bool BaseIsVirtual); |
2826 | | |
2827 | | static bool ShouldNullCheckClassCastValue(const CastExpr *Cast); |
2828 | | |
2829 | | /// GetAddressOfBaseClass - This function will add the necessary delta to the |
2830 | | /// load of 'this' and returns address of the base class. |
2831 | | Address GetAddressOfBaseClass(Address Value, |
2832 | | const CXXRecordDecl *Derived, |
2833 | | CastExpr::path_const_iterator PathBegin, |
2834 | | CastExpr::path_const_iterator PathEnd, |
2835 | | bool NullCheckValue, SourceLocation Loc); |
2836 | | |
2837 | | Address GetAddressOfDerivedClass(Address Value, |
2838 | | const CXXRecordDecl *Derived, |
2839 | | CastExpr::path_const_iterator PathBegin, |
2840 | | CastExpr::path_const_iterator PathEnd, |
2841 | | bool NullCheckValue); |
2842 | | |
2843 | | /// GetVTTParameter - Return the VTT parameter that should be passed to a |
2844 | | /// base constructor/destructor with virtual bases. |
2845 | | /// FIXME: VTTs are Itanium ABI-specific, so the definition should move |
2846 | | /// to ItaniumCXXABI.cpp together with all the references to VTT. |
2847 | | llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, |
2848 | | bool Delegating); |
2849 | | |
2850 | | void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, |
2851 | | CXXCtorType CtorType, |
2852 | | const FunctionArgList &Args, |
2853 | | SourceLocation Loc); |
2854 | | // It's important not to confuse this and the previous function. Delegating |
2855 | | // constructors are the C++0x feature. The constructor delegate optimization |
2856 | | // is used to reduce duplication in the base and complete consturctors where |
2857 | | // they are substantially the same. |
2858 | | void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, |
2859 | | const FunctionArgList &Args); |
2860 | | |
2861 | | /// Emit a call to an inheriting constructor (that is, one that invokes a |
2862 | | /// constructor inherited from a base class) by inlining its definition. This |
2863 | | /// is necessary if the ABI does not support forwarding the arguments to the |
2864 | | /// base class constructor (because they're variadic or similar). |
2865 | | void EmitInlinedInheritingCXXConstructorCall(const CXXConstructorDecl *Ctor, |
2866 | | CXXCtorType CtorType, |
2867 | | bool ForVirtualBase, |
2868 | | bool Delegating, |
2869 | | CallArgList &Args); |
2870 | | |
2871 | | /// Emit a call to a constructor inherited from a base class, passing the |
2872 | | /// current constructor's arguments along unmodified (without even making |
2873 | | /// a copy). |
2874 | | void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, |
2875 | | bool ForVirtualBase, Address This, |
2876 | | bool InheritedFromVBase, |
2877 | | const CXXInheritedCtorInitExpr *E); |
2878 | | |
2879 | | void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, |
2880 | | bool ForVirtualBase, bool Delegating, |
2881 | | AggValueSlot ThisAVS, const CXXConstructExpr *E); |
2882 | | |
2883 | | void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, |
2884 | | bool ForVirtualBase, bool Delegating, |
2885 | | Address This, CallArgList &Args, |
2886 | | AggValueSlot::Overlap_t Overlap, |
2887 | | SourceLocation Loc, bool NewPointerIsChecked); |
2888 | | |
2889 | | /// Emit assumption load for all bases. Requires to be be called only on |
2890 | | /// most-derived class and not under construction of the object. |
2891 | | void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This); |
2892 | | |
2893 | | /// Emit assumption that vptr load == global vtable. |
2894 | | void EmitVTableAssumptionLoad(const VPtr &vptr, Address This); |
2895 | | |
2896 | | void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, |
2897 | | Address This, Address Src, |
2898 | | const CXXConstructExpr *E); |
2899 | | |
2900 | | void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, |
2901 | | const ArrayType *ArrayTy, |
2902 | | Address ArrayPtr, |
2903 | | const CXXConstructExpr *E, |
2904 | | bool NewPointerIsChecked, |
2905 | | bool ZeroInitialization = false); |
2906 | | |
2907 | | void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, |
2908 | | llvm::Value *NumElements, |
2909 | | Address ArrayPtr, |
2910 | | const CXXConstructExpr *E, |
2911 | | bool NewPointerIsChecked, |
2912 | | bool ZeroInitialization = false); |
2913 | | |
2914 | | static Destroyer destroyCXXObject; |
2915 | | |
2916 | | void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, |
2917 | | bool ForVirtualBase, bool Delegating, Address This, |
2918 | | QualType ThisTy); |
2919 | | |
2920 | | void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, |
2921 | | llvm::Type *ElementTy, Address NewPtr, |
2922 | | llvm::Value *NumElements, |
2923 | | llvm::Value *AllocSizeWithoutCookie); |
2924 | | |
2925 | | void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, |
2926 | | Address Ptr); |
2927 | | |
2928 | | void EmitSehCppScopeBegin(); |
2929 | | void EmitSehCppScopeEnd(); |
2930 | | void EmitSehTryScopeBegin(); |
2931 | | void EmitSehTryScopeEnd(); |
2932 | | |
2933 | | llvm::Value *EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr); |
2934 | | void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr); |
2935 | | |
2936 | | llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E); |
2937 | | void EmitCXXDeleteExpr(const CXXDeleteExpr *E); |
2938 | | |
2939 | | void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, |
2940 | | QualType DeleteTy, llvm::Value *NumElements = nullptr, |
2941 | | CharUnits CookieSize = CharUnits()); |
2942 | | |
2943 | | RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, |
2944 | | const CallExpr *TheCallExpr, bool IsDelete); |
2945 | | |
2946 | | llvm::Value *EmitCXXTypeidExpr(const CXXTypeidExpr *E); |
2947 | | llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE); |
2948 | | Address EmitCXXUuidofExpr(const CXXUuidofExpr *E); |
2949 | | |
2950 | | /// Situations in which we might emit a check for the suitability of a |
2951 | | /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in |
2952 | | /// compiler-rt. |
2953 | | enum TypeCheckKind { |
2954 | | /// Checking the operand of a load. Must be suitably sized and aligned. |
2955 | | TCK_Load, |
2956 | | /// Checking the destination of a store. Must be suitably sized and aligned. |
2957 | | TCK_Store, |
2958 | | /// Checking the bound value in a reference binding. Must be suitably sized |
2959 | | /// and aligned, but is not required to refer to an object (until the |
2960 | | /// reference is used), per core issue 453. |
2961 | | TCK_ReferenceBinding, |
2962 | | /// Checking the object expression in a non-static data member access. Must |
2963 | | /// be an object within its lifetime. |
2964 | | TCK_MemberAccess, |
2965 | | /// Checking the 'this' pointer for a call to a non-static member function. |
2966 | | /// Must be an object within its lifetime. |
2967 | | TCK_MemberCall, |
2968 | | /// Checking the 'this' pointer for a constructor call. |
2969 | | TCK_ConstructorCall, |
2970 | | /// Checking the operand of a static_cast to a derived pointer type. Must be |
2971 | | /// null or an object within its lifetime. |
2972 | | TCK_DowncastPointer, |
2973 | | /// Checking the operand of a static_cast to a derived reference type. Must |
2974 | | /// be an object within its lifetime. |
2975 | | TCK_DowncastReference, |
2976 | | /// Checking the operand of a cast to a base object. Must be suitably sized |
2977 | | /// and aligned. |
2978 | | TCK_Upcast, |
2979 | | /// Checking the operand of a cast to a virtual base object. Must be an |
2980 | | /// object within its lifetime. |
2981 | | TCK_UpcastToVirtualBase, |
2982 | | /// Checking the value assigned to a _Nonnull pointer. Must not be null. |
2983 | | TCK_NonnullAssign, |
2984 | | /// Checking the operand of a dynamic_cast or a typeid expression. Must be |
2985 | | /// null or an object within its lifetime. |
2986 | | TCK_DynamicOperation |
2987 | | }; |
2988 | | |
2989 | | /// Determine whether the pointer type check \p TCK permits null pointers. |
2990 | | static bool isNullPointerAllowed(TypeCheckKind TCK); |
2991 | | |
2992 | | /// Determine whether the pointer type check \p TCK requires a vptr check. |
2993 | | static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty); |
2994 | | |
2995 | | /// Whether any type-checking sanitizers are enabled. If \c false, |
2996 | | /// calls to EmitTypeCheck can be skipped. |
2997 | | bool sanitizePerformTypeCheck() const; |
2998 | | |
2999 | | /// Emit a check that \p V is the address of storage of the |
3000 | | /// appropriate size and alignment for an object of type \p Type |
3001 | | /// (or if ArraySize is provided, for an array of that bound). |
3002 | | void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, |
3003 | | QualType Type, CharUnits Alignment = CharUnits::Zero(), |
3004 | | SanitizerSet SkippedChecks = SanitizerSet(), |
3005 | | llvm::Value *ArraySize = nullptr); |
3006 | | |
3007 | | /// Emit a check that \p Base points into an array object, which |
3008 | | /// we can access at index \p Index. \p Accessed should be \c false if we |
3009 | | /// this expression is used as an lvalue, for instance in "&Arr[Idx]". |
3010 | | void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, |
3011 | | QualType IndexType, bool Accessed); |
3012 | | |
3013 | | llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, |
3014 | | bool isInc, bool isPre); |
3015 | | ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, |
3016 | | bool isInc, bool isPre); |
3017 | | |
3018 | | /// Converts Location to a DebugLoc, if debug information is enabled. |
3019 | | llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location); |
3020 | | |
3021 | | /// Get the record field index as represented in debug info. |
3022 | | unsigned getDebugInfoFIndex(const RecordDecl *Rec, unsigned FieldIndex); |
3023 | | |
3024 | | |
3025 | | //===--------------------------------------------------------------------===// |
3026 | | // Declaration Emission |
3027 | | //===--------------------------------------------------------------------===// |
3028 | | |
3029 | | /// EmitDecl - Emit a declaration. |
3030 | | /// |
3031 | | /// This function can be called with a null (unreachable) insert point. |
3032 | | void EmitDecl(const Decl &D); |
3033 | | |
3034 | | /// EmitVarDecl - Emit a local variable declaration. |
3035 | | /// |
3036 | | /// This function can be called with a null (unreachable) insert point. |
3037 | | void EmitVarDecl(const VarDecl &D); |
3038 | | |
3039 | | void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, |
3040 | | bool capturedByInit); |
3041 | | |
3042 | | typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D, |
3043 | | llvm::Value *Address); |
3044 | | |
3045 | | /// Determine whether the given initializer is trivial in the sense |
3046 | | /// that it requires no code to be generated. |
3047 | | bool isTrivialInitializer(const Expr *Init); |
3048 | | |
3049 | | /// EmitAutoVarDecl - Emit an auto variable declaration. |
3050 | | /// |
3051 | | /// This function can be called with a null (unreachable) insert point. |
3052 | | void EmitAutoVarDecl(const VarDecl &D); |
3053 | | |
3054 | | class AutoVarEmission { |
3055 | | friend class CodeGenFunction; |
3056 | | |
3057 | | const VarDecl *Variable; |
3058 | | |
3059 | | /// The address of the alloca for languages with explicit address space |
3060 | | /// (e.g. OpenCL) or alloca casted to generic pointer for address space |
3061 | | /// agnostic languages (e.g. C++). Invalid if the variable was emitted |
3062 | | /// as a global constant. |
3063 | | Address Addr; |
3064 | | |
3065 | | llvm::Value *NRVOFlag; |
3066 | | |
3067 | | /// True if the variable is a __block variable that is captured by an |
3068 | | /// escaping block. |
3069 | | bool IsEscapingByRef; |
3070 | | |
3071 | | /// True if the variable is of aggregate type and has a constant |
3072 | | /// initializer. |
3073 | | bool IsConstantAggregate; |
3074 | | |
3075 | | /// Non-null if we should use lifetime annotations. |
3076 | | llvm::Value *SizeForLifetimeMarkers; |
3077 | | |
3078 | | /// Address with original alloca instruction. Invalid if the variable was |
3079 | | /// emitted as a global constant. |
3080 | | Address AllocaAddr; |
3081 | | |
3082 | | struct Invalid {}; |
3083 | | AutoVarEmission(Invalid) |
3084 | | : Variable(nullptr), Addr(Address::invalid()), |
3085 | 68 | AllocaAddr(Address::invalid()) {} |
3086 | | |
3087 | | AutoVarEmission(const VarDecl &variable) |
3088 | | : Variable(&variable), Addr(Address::invalid()), NRVOFlag(nullptr), |
3089 | | IsEscapingByRef(false), IsConstantAggregate(false), |
3090 | 254k | SizeForLifetimeMarkers(nullptr), AllocaAddr(Address::invalid()) {} |
3091 | | |
3092 | 491k | bool wasEmittedAsGlobal() const { return !Addr.isValid(); } |
3093 | | |
3094 | | public: |
3095 | 68 | static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); } |
3096 | | |
3097 | 258k | bool useLifetimeMarkers() const { |
3098 | 258k | return SizeForLifetimeMarkers != nullptr; |
3099 | 258k | } |
3100 | 3.79k | llvm::Value *getSizeForLifetimeMarkers() const { |
3101 | 3.79k | assert(useLifetimeMarkers()); |
3102 | 0 | return SizeForLifetimeMarkers; |
3103 | 3.79k | } |
3104 | | |
3105 | | /// Returns the raw, allocated address, which is not necessarily |
3106 | | /// the address of the object itself. It is casted to default |
3107 | | /// address space for address space agnostic languages. |
3108 | 36.3k | Address getAllocatedAddress() const { |
3109 | 36.3k | return Addr; |
3110 | 36.3k | } |
3111 | | |
3112 | | /// Returns the address for the original alloca instruction. |
3113 | 3.79k | Address getOriginalAllocatedAddress() const { return AllocaAddr; } |
3114 | | |
3115 | | /// Returns the address of the object within this declaration. |
3116 | | /// Note that this does not chase the forwarding pointer for |
3117 | | /// __block decls. |
3118 | 246k | Address getObjectAddress(CodeGenFunction &CGF) const { |
3119 | 246k | if (!IsEscapingByRef) return Addr245k ; |
3120 | | |
3121 | 257 | return CGF.emitBlockByrefAddress(Addr, Variable, /*forward*/ false); |
3122 | 246k | } |
3123 | | }; |
3124 | | AutoVarEmission EmitAutoVarAlloca(const VarDecl &var); |
3125 | | void EmitAutoVarInit(const AutoVarEmission &emission); |
3126 | | void EmitAutoVarCleanups(const AutoVarEmission &emission); |
3127 | | void emitAutoVarTypeCleanup(const AutoVarEmission &emission, |
3128 | | QualType::DestructionKind dtorKind); |
3129 | | |
3130 | | /// Emits the alloca and debug information for the size expressions for each |
3131 | | /// dimension of an array. It registers the association of its (1-dimensional) |
3132 | | /// QualTypes and size expression's debug node, so that CGDebugInfo can |
3133 | | /// reference this node when creating the DISubrange object to describe the |
3134 | | /// array types. |
3135 | | void EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI, |
3136 | | const VarDecl &D, |
3137 | | bool EmitDebugInfo); |
3138 | | |
3139 | | void EmitStaticVarDecl(const VarDecl &D, |
3140 | | llvm::GlobalValue::LinkageTypes Linkage); |
3141 | | |
3142 | | class ParamValue { |
3143 | | llvm::Value *Value; |
3144 | | llvm::Type *ElementType; |
3145 | | unsigned Alignment; |
3146 | | ParamValue(llvm::Value *V, llvm::Type *T, unsigned A) |
3147 | 526k | : Value(V), ElementType(T), Alignment(A) {} |
3148 | | public: |
3149 | 512k | static ParamValue forDirect(llvm::Value *value) { |
3150 | 512k | return ParamValue(value, nullptr, 0); |
3151 | 512k | } |
3152 | 14.3k | static ParamValue forIndirect(Address addr) { |
3153 | 14.3k | assert(!addr.getAlignment().isZero()); |
3154 | 0 | return ParamValue(addr.getPointer(), addr.getElementType(), |
3155 | 14.3k | addr.getAlignment().getQuantity()); |
3156 | 14.3k | } |
3157 | | |
3158 | 1.05M | bool isIndirect() const { return Alignment != 0; } |
3159 | 526k | llvm::Value *getAnyValue() const { return Value; } |
3160 | | |
3161 | 512k | llvm::Value *getDirectValue() const { |
3162 | 512k | assert(!isIndirect()); |
3163 | 0 | return Value; |
3164 | 512k | } |
3165 | | |
3166 | 14.3k | Address getIndirectAddress() const { |
3167 | 14.3k | assert(isIndirect()); |
3168 | 0 | return Address(Value, ElementType, CharUnits::fromQuantity(Alignment)); |
3169 | 14.3k | } |
3170 | | }; |
3171 | | |
3172 | | /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl. |
3173 | | void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo); |
3174 | | |
3175 | | /// protectFromPeepholes - Protect a value that we're intending to |
3176 | | /// store to the side, but which will probably be used later, from |
3177 | | /// aggressive peepholing optimizations that might delete it. |
3178 | | /// |
3179 | | /// Pass the result to unprotectFromPeepholes to declare that |
3180 | | /// protection is no longer required. |
3181 | | /// |
3182 | | /// There's no particular reason why this shouldn't apply to |
3183 | | /// l-values, it's just that no existing peepholes work on pointers. |
3184 | | PeepholeProtection protectFromPeepholes(RValue rvalue); |
3185 | | void unprotectFromPeepholes(PeepholeProtection protection); |
3186 | | |
3187 | | void emitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, |
3188 | | SourceLocation Loc, |
3189 | | SourceLocation AssumptionLoc, |
3190 | | llvm::Value *Alignment, |
3191 | | llvm::Value *OffsetValue, |
3192 | | llvm::Value *TheCheck, |
3193 | | llvm::Instruction *Assumption); |
3194 | | |
3195 | | void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, |
3196 | | SourceLocation Loc, SourceLocation AssumptionLoc, |
3197 | | llvm::Value *Alignment, |
3198 | | llvm::Value *OffsetValue = nullptr); |
3199 | | |
3200 | | void emitAlignmentAssumption(llvm::Value *PtrValue, const Expr *E, |
3201 | | SourceLocation AssumptionLoc, |
3202 | | llvm::Value *Alignment, |
3203 | | llvm::Value *OffsetValue = nullptr); |
3204 | | |
3205 | | //===--------------------------------------------------------------------===// |
3206 | | // Statement Emission |
3207 | | //===--------------------------------------------------------------------===// |
3208 | | |
3209 | | /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info. |
3210 | | void EmitStopPoint(const Stmt *S); |
3211 | | |
3212 | | /// EmitStmt - Emit the code for the statement \arg S. It is legal to call |
3213 | | /// this function even if there is no current insertion point. |
3214 | | /// |
3215 | | /// This function may clear the current insertion point; callers should use |
3216 | | /// EnsureInsertPoint if they wish to subsequently generate code without first |
3217 | | /// calling EmitBlock, EmitBranch, or EmitStmt. |
3218 | | void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = None); |
3219 | | |
3220 | | /// EmitSimpleStmt - Try to emit a "simple" statement which does not |
3221 | | /// necessarily require an insertion point or debug information; typically |
3222 | | /// because the statement amounts to a jump or a container of other |
3223 | | /// statements. |
3224 | | /// |
3225 | | /// \return True if the statement was handled. |
3226 | | bool EmitSimpleStmt(const Stmt *S, ArrayRef<const Attr *> Attrs); |
3227 | | |
3228 | | Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false, |
3229 | | AggValueSlot AVS = AggValueSlot::ignored()); |
3230 | | Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, |
3231 | | bool GetLast = false, |
3232 | | AggValueSlot AVS = |
3233 | | AggValueSlot::ignored()); |
3234 | | |
3235 | | /// EmitLabel - Emit the block for the given label. It is legal to call this |
3236 | | /// function even if there is no current insertion point. |
3237 | | void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt. |
3238 | | |
3239 | | void EmitLabelStmt(const LabelStmt &S); |
3240 | | void EmitAttributedStmt(const AttributedStmt &S); |
3241 | | void EmitGotoStmt(const GotoStmt &S); |
3242 | | void EmitIndirectGotoStmt(const IndirectGotoStmt &S); |
3243 | | void EmitIfStmt(const IfStmt &S); |
3244 | | |
3245 | | void EmitWhileStmt(const WhileStmt &S, |
3246 | | ArrayRef<const Attr *> Attrs = None); |
3247 | | void EmitDoStmt(const DoStmt &S, ArrayRef<const Attr *> Attrs = None); |
3248 | | void EmitForStmt(const ForStmt &S, |
3249 | | ArrayRef<const Attr *> Attrs = None); |
3250 | | void EmitReturnStmt(const ReturnStmt &S); |
3251 | | void EmitDeclStmt(const DeclStmt &S); |
3252 | | void EmitBreakStmt(const BreakStmt &S); |
3253 | | void EmitContinueStmt(const ContinueStmt &S); |
3254 | | void EmitSwitchStmt(const SwitchStmt &S); |
3255 | | void EmitDefaultStmt(const DefaultStmt &S, ArrayRef<const Attr *> Attrs); |
3256 | | void EmitCaseStmt(const CaseStmt &S, ArrayRef<const Attr *> Attrs); |
3257 | | void EmitCaseStmtRange(const CaseStmt &S, ArrayRef<const Attr *> Attrs); |
3258 | | void EmitAsmStmt(const AsmStmt &S); |
3259 | | |
3260 | | void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S); |
3261 | | void EmitObjCAtTryStmt(const ObjCAtTryStmt &S); |
3262 | | void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S); |
3263 | | void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S); |
3264 | | void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S); |
3265 | | |
3266 | | void EmitCoroutineBody(const CoroutineBodyStmt &S); |
3267 | | void EmitCoreturnStmt(const CoreturnStmt &S); |
3268 | | RValue EmitCoawaitExpr(const CoawaitExpr &E, |
3269 | | AggValueSlot aggSlot = AggValueSlot::ignored(), |
3270 | | bool ignoreResult = false); |
3271 | | LValue EmitCoawaitLValue(const CoawaitExpr *E); |
3272 | | RValue EmitCoyieldExpr(const CoyieldExpr &E, |
3273 | | AggValueSlot aggSlot = AggValueSlot::ignored(), |
3274 | | bool ignoreResult = false); |
3275 | | LValue EmitCoyieldLValue(const CoyieldExpr *E); |
3276 | | RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID); |
3277 | | |
3278 | | void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false); |
3279 | | void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false); |
3280 | | |
3281 | | void EmitCXXTryStmt(const CXXTryStmt &S); |
3282 | | void EmitSEHTryStmt(const SEHTryStmt &S); |
3283 | | void EmitSEHLeaveStmt(const SEHLeaveStmt &S); |
3284 | | void EnterSEHTryStmt(const SEHTryStmt &S); |
3285 | | void ExitSEHTryStmt(const SEHTryStmt &S); |
3286 | | void VolatilizeTryBlocks(llvm::BasicBlock *BB, |
3287 | | llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V); |
3288 | | |
3289 | | void pushSEHCleanup(CleanupKind kind, |
3290 | | llvm::Function *FinallyFunc); |
3291 | | void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, |
3292 | | const Stmt *OutlinedStmt); |
3293 | | |
3294 | | llvm::Function *GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, |
3295 | | const SEHExceptStmt &Except); |
3296 | | |
3297 | | llvm::Function *GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, |
3298 | | const SEHFinallyStmt &Finally); |
3299 | | |
3300 | | void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, |
3301 | | llvm::Value *ParentFP, |
3302 | | llvm::Value *EntryEBP); |
3303 | | llvm::Value *EmitSEHExceptionCode(); |
3304 | | llvm::Value *EmitSEHExceptionInfo(); |
3305 | | llvm::Value *EmitSEHAbnormalTermination(); |
3306 | | |
3307 | | /// Emit simple code for OpenMP directives in Simd-only mode. |
3308 | | void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D); |
3309 | | |
3310 | | /// Scan the outlined statement for captures from the parent function. For |
3311 | | /// each capture, mark the capture as escaped and emit a call to |
3312 | | /// llvm.localrecover. Insert the localrecover result into the LocalDeclMap. |
3313 | | void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, |
3314 | | bool IsFilter); |
3315 | | |
3316 | | /// Recovers the address of a local in a parent function. ParentVar is the |
3317 | | /// address of the variable used in the immediate parent function. It can |
3318 | | /// either be an alloca or a call to llvm.localrecover if there are nested |
3319 | | /// outlined functions. ParentFP is the frame pointer of the outermost parent |
3320 | | /// frame. |
3321 | | Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, |
3322 | | Address ParentVar, |
3323 | | llvm::Value *ParentFP); |
3324 | | |
3325 | | void EmitCXXForRangeStmt(const CXXForRangeStmt &S, |
3326 | | ArrayRef<const Attr *> Attrs = None); |
3327 | | |
3328 | | /// Controls insertion of cancellation exit blocks in worksharing constructs. |
3329 | | class OMPCancelStackRAII { |
3330 | | CodeGenFunction &CGF; |
3331 | | |
3332 | | public: |
3333 | | OMPCancelStackRAII(CodeGenFunction &CGF, OpenMPDirectiveKind Kind, |
3334 | | bool HasCancel) |
3335 | 4.42k | : CGF(CGF) { |
3336 | 4.42k | CGF.OMPCancelStack.enter(CGF, Kind, HasCancel); |
3337 | 4.42k | } |
3338 | 4.42k | ~OMPCancelStackRAII() { CGF.OMPCancelStack.exit(CGF); } |
3339 | | }; |
3340 | | |
3341 | | /// Returns calculated size of the specified type. |
3342 | | llvm::Value *getTypeSize(QualType Ty); |
3343 | | LValue InitCapturedStruct(const CapturedStmt &S); |
3344 | | llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K); |
3345 | | llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S); |
3346 | | Address GenerateCapturedStmtArgument(const CapturedStmt &S); |
3347 | | llvm::Function *GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S, |
3348 | | SourceLocation Loc); |
3349 | | void GenerateOpenMPCapturedVars(const CapturedStmt &S, |
3350 | | SmallVectorImpl<llvm::Value *> &CapturedVars); |
3351 | | void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy, |
3352 | | SourceLocation Loc); |
3353 | | /// Perform element by element copying of arrays with type \a |
3354 | | /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure |
3355 | | /// generated by \a CopyGen. |
3356 | | /// |
3357 | | /// \param DestAddr Address of the destination array. |
3358 | | /// \param SrcAddr Address of the source array. |
3359 | | /// \param OriginalType Type of destination and source arrays. |
3360 | | /// \param CopyGen Copying procedure that copies value of single array element |
3361 | | /// to another single array element. |
3362 | | void EmitOMPAggregateAssign( |
3363 | | Address DestAddr, Address SrcAddr, QualType OriginalType, |
3364 | | const llvm::function_ref<void(Address, Address)> CopyGen); |
3365 | | /// Emit proper copying of data from one variable to another. |
3366 | | /// |
3367 | | /// \param OriginalType Original type of the copied variables. |
3368 | | /// \param DestAddr Destination address. |
3369 | | /// \param SrcAddr Source address. |
3370 | | /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has |
3371 | | /// type of the base array element). |
3372 | | /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of |
3373 | | /// the base array element). |
3374 | | /// \param Copy Actual copygin expression for copying data from \a SrcVD to \a |
3375 | | /// DestVD. |
3376 | | void EmitOMPCopy(QualType OriginalType, |
3377 | | Address DestAddr, Address SrcAddr, |
3378 | | const VarDecl *DestVD, const VarDecl *SrcVD, |
3379 | | const Expr *Copy); |
3380 | | /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or |
3381 | | /// \a X = \a E \a BO \a E. |
3382 | | /// |
3383 | | /// \param X Value to be updated. |
3384 | | /// \param E Update value. |
3385 | | /// \param BO Binary operation for update operation. |
3386 | | /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update |
3387 | | /// expression, false otherwise. |
3388 | | /// \param AO Atomic ordering of the generated atomic instructions. |
3389 | | /// \param CommonGen Code generator for complex expressions that cannot be |
3390 | | /// expressed through atomicrmw instruction. |
3391 | | /// \returns <true, OldAtomicValue> if simple 'atomicrmw' instruction was |
3392 | | /// generated, <false, RValue::get(nullptr)> otherwise. |
3393 | | std::pair<bool, RValue> EmitOMPAtomicSimpleUpdateExpr( |
3394 | | LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart, |
3395 | | llvm::AtomicOrdering AO, SourceLocation Loc, |
3396 | | const llvm::function_ref<RValue(RValue)> CommonGen); |
3397 | | bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D, |
3398 | | OMPPrivateScope &PrivateScope); |
3399 | | void EmitOMPPrivateClause(const OMPExecutableDirective &D, |
3400 | | OMPPrivateScope &PrivateScope); |
3401 | | void EmitOMPUseDevicePtrClause( |
3402 | | const OMPUseDevicePtrClause &C, OMPPrivateScope &PrivateScope, |
3403 | | const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap); |
3404 | | void EmitOMPUseDeviceAddrClause( |
3405 | | const OMPUseDeviceAddrClause &C, OMPPrivateScope &PrivateScope, |
3406 | | const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap); |
3407 | | /// Emit code for copyin clause in \a D directive. The next code is |
3408 | | /// generated at the start of outlined functions for directives: |
3409 | | /// \code |
3410 | | /// threadprivate_var1 = master_threadprivate_var1; |
3411 | | /// operator=(threadprivate_var2, master_threadprivate_var2); |
3412 | | /// ... |
3413 | | /// __kmpc_barrier(&loc, global_tid); |
3414 | | /// \endcode |
3415 | | /// |
3416 | | /// \param D OpenMP directive possibly with 'copyin' clause(s). |
3417 | | /// \returns true if at least one copyin variable is found, false otherwise. |
3418 | | bool EmitOMPCopyinClause(const OMPExecutableDirective &D); |
3419 | | /// Emit initial code for lastprivate variables. If some variable is |
3420 | | /// not also firstprivate, then the default initialization is used. Otherwise |
3421 | | /// initialization of this variable is performed by EmitOMPFirstprivateClause |
3422 | | /// method. |
3423 | | /// |
3424 | | /// \param D Directive that may have 'lastprivate' directives. |
3425 | | /// \param PrivateScope Private scope for capturing lastprivate variables for |
3426 | | /// proper codegen in internal captured statement. |
3427 | | /// |
3428 | | /// \returns true if there is at least one lastprivate variable, false |
3429 | | /// otherwise. |
3430 | | bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D, |
3431 | | OMPPrivateScope &PrivateScope); |
3432 | | /// Emit final copying of lastprivate values to original variables at |
3433 | | /// the end of the worksharing or simd directive. |
3434 | | /// |
3435 | | /// \param D Directive that has at least one 'lastprivate' directives. |
3436 | | /// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if |
3437 | | /// it is the last iteration of the loop code in associated directive, or to |
3438 | | /// 'i1 false' otherwise. If this item is nullptr, no final check is required. |
3439 | | void EmitOMPLastprivateClauseFinal(const OMPExecutableDirective &D, |
3440 | | bool NoFinals, |
3441 | | llvm::Value *IsLastIterCond = nullptr); |
3442 | | /// Emit initial code for linear clauses. |
3443 | | void EmitOMPLinearClause(const OMPLoopDirective &D, |
3444 | | CodeGenFunction::OMPPrivateScope &PrivateScope); |
3445 | | /// Emit final code for linear clauses. |
3446 | | /// \param CondGen Optional conditional code for final part of codegen for |
3447 | | /// linear clause. |
3448 | | void EmitOMPLinearClauseFinal( |
3449 | | const OMPLoopDirective &D, |
3450 | | const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen); |
3451 | | /// Emit initial code for reduction variables. Creates reduction copies |
3452 | | /// and initializes them with the values according to OpenMP standard. |
3453 | | /// |
3454 | | /// \param D Directive (possibly) with the 'reduction' clause. |
3455 | | /// \param PrivateScope Private scope for capturing reduction variables for |
3456 | | /// proper codegen in internal captured statement. |
3457 | | /// |
3458 | | void EmitOMPReductionClauseInit(const OMPExecutableDirective &D, |
3459 | | OMPPrivateScope &PrivateScope, |
3460 | | bool ForInscan = false); |
3461 | | /// Emit final update of reduction values to original variables at |
3462 | | /// the end of the directive. |
3463 | | /// |
3464 | | /// \param D Directive that has at least one 'reduction' directives. |
3465 | | /// \param ReductionKind The kind of reduction to perform. |
3466 | | void EmitOMPReductionClauseFinal(const OMPExecutableDirective &D, |
3467 | | const OpenMPDirectiveKind ReductionKind); |
3468 | | /// Emit initial code for linear variables. Creates private copies |
3469 | | /// and initializes them with the values according to OpenMP standard. |
3470 | | /// |
3471 | | /// \param D Directive (possibly) with the 'linear' clause. |
3472 | | /// \return true if at least one linear variable is found that should be |
3473 | | /// initialized with the value of the original variable, false otherwise. |
3474 | | bool EmitOMPLinearClauseInit(const OMPLoopDirective &D); |
3475 | | |
3476 | | typedef const llvm::function_ref<void(CodeGenFunction & /*CGF*/, |
3477 | | llvm::Function * /*OutlinedFn*/, |
3478 | | const OMPTaskDataTy & /*Data*/)> |
3479 | | TaskGenTy; |
3480 | | void EmitOMPTaskBasedDirective(const OMPExecutableDirective &S, |
3481 | | const OpenMPDirectiveKind CapturedRegion, |
3482 | | const RegionCodeGenTy &BodyGen, |
3483 | | const TaskGenTy &TaskGen, OMPTaskDataTy &Data); |
3484 | | struct OMPTargetDataInfo { |
3485 | | Address BasePointersArray = Address::invalid(); |
3486 | | Address PointersArray = Address::invalid(); |
3487 | | Address SizesArray = Address::invalid(); |
3488 | | Address MappersArray = Address::invalid(); |
3489 | | unsigned NumberOfTargetItems = 0; |
3490 | 9.82k | explicit OMPTargetDataInfo() = default; |
3491 | | OMPTargetDataInfo(Address BasePointersArray, Address PointersArray, |
3492 | | Address SizesArray, Address MappersArray, |
3493 | | unsigned NumberOfTargetItems) |
3494 | | : BasePointersArray(BasePointersArray), PointersArray(PointersArray), |
3495 | | SizesArray(SizesArray), MappersArray(MappersArray), |
3496 | 0 | NumberOfTargetItems(NumberOfTargetItems) {} |
3497 | | }; |
3498 | | void EmitOMPTargetTaskBasedDirective(const OMPExecutableDirective &S, |
3499 | | const RegionCodeGenTy &BodyGen, |
3500 | | OMPTargetDataInfo &InputInfo); |
3501 | | |
3502 | | void EmitOMPMetaDirective(const OMPMetaDirective &S); |
3503 | | void EmitOMPParallelDirective(const OMPParallelDirective &S); |
3504 | | void EmitOMPSimdDirective(const OMPSimdDirective &S); |
3505 | | void EmitOMPTileDirective(const OMPTileDirective &S); |
3506 | | void EmitOMPUnrollDirective(const OMPUnrollDirective &S); |
3507 | | void EmitOMPForDirective(const OMPForDirective &S); |
3508 | | void EmitOMPForSimdDirective(const OMPForSimdDirective &S); |
3509 | | void EmitOMPSectionsDirective(const OMPSectionsDirective &S); |
3510 | | void EmitOMPSectionDirective(const OMPSectionDirective &S); |
3511 | | void EmitOMPSingleDirective(const OMPSingleDirective &S); |
3512 | | void EmitOMPMasterDirective(const OMPMasterDirective &S); |
3513 | | void EmitOMPMaskedDirective(const OMPMaskedDirective &S); |
3514 | | void EmitOMPCriticalDirective(const OMPCriticalDirective &S); |
3515 | | void EmitOMPParallelForDirective(const OMPParallelForDirective &S); |
3516 | | void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S); |
3517 | | void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S); |
3518 | | void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S); |
3519 | | void EmitOMPTaskDirective(const OMPTaskDirective &S); |
3520 | | void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S); |
3521 | | void EmitOMPBarrierDirective(const OMPBarrierDirective &S); |
3522 | | void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S); |
3523 | | void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S); |
3524 | | void EmitOMPFlushDirective(const OMPFlushDirective &S); |
3525 | | void EmitOMPDepobjDirective(const OMPDepobjDirective &S); |
3526 | | void EmitOMPScanDirective(const OMPScanDirective &S); |
3527 | | void EmitOMPOrderedDirective(const OMPOrderedDirective &S); |
3528 | | void EmitOMPAtomicDirective(const OMPAtomicDirective &S); |
3529 | | void EmitOMPTargetDirective(const OMPTargetDirective &S); |
3530 | | void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S); |
3531 | | void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S); |
3532 | | void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S); |
3533 | | void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S); |
3534 | | void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S); |
3535 | | void |
3536 | | EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S); |
3537 | | void EmitOMPTeamsDirective(const OMPTeamsDirective &S); |
3538 | | void |
3539 | | EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S); |
3540 | | void EmitOMPCancelDirective(const OMPCancelDirective &S); |
3541 | | void EmitOMPTaskLoopBasedDirective(const OMPLoopDirective &S); |
3542 | | void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S); |
3543 | | void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S); |
3544 | | void EmitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &S); |
3545 | | void |
3546 | | EmitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &S); |
3547 | | void EmitOMPParallelMasterTaskLoopDirective( |
3548 | | const OMPParallelMasterTaskLoopDirective &S); |
3549 | | void EmitOMPParallelMasterTaskLoopSimdDirective( |
3550 | | const OMPParallelMasterTaskLoopSimdDirective &S); |
3551 | | void EmitOMPDistributeDirective(const OMPDistributeDirective &S); |
3552 | | void EmitOMPDistributeParallelForDirective( |
3553 | | const OMPDistributeParallelForDirective &S); |
3554 | | void EmitOMPDistributeParallelForSimdDirective( |
3555 | | const OMPDistributeParallelForSimdDirective &S); |
3556 | | void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S); |
3557 | | void EmitOMPTargetParallelForSimdDirective( |
3558 | | const OMPTargetParallelForSimdDirective &S); |
3559 | | void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S); |
3560 | | void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S); |
3561 | | void |
3562 | | EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S); |
3563 | | void EmitOMPTeamsDistributeParallelForSimdDirective( |
3564 | | const OMPTeamsDistributeParallelForSimdDirective &S); |
3565 | | void EmitOMPTeamsDistributeParallelForDirective( |
3566 | | const OMPTeamsDistributeParallelForDirective &S); |
3567 | | void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S); |
3568 | | void EmitOMPTargetTeamsDistributeDirective( |
3569 | | const OMPTargetTeamsDistributeDirective &S); |
3570 | | void EmitOMPTargetTeamsDistributeParallelForDirective( |
3571 | | const OMPTargetTeamsDistributeParallelForDirective &S); |
3572 | | void EmitOMPTargetTeamsDistributeParallelForSimdDirective( |
3573 | | const OMPTargetTeamsDistributeParallelForSimdDirective &S); |
3574 | | void EmitOMPTargetTeamsDistributeSimdDirective( |
3575 | | const OMPTargetTeamsDistributeSimdDirective &S); |
3576 | | void EmitOMPGenericLoopDirective(const OMPGenericLoopDirective &S); |
3577 | | void EmitOMPInteropDirective(const OMPInteropDirective &S); |
3578 | | |
3579 | | /// Emit device code for the target directive. |
3580 | | static void EmitOMPTargetDeviceFunction(CodeGenModule &CGM, |
3581 | | StringRef ParentName, |
3582 | | const OMPTargetDirective &S); |
3583 | | static void |
3584 | | EmitOMPTargetParallelDeviceFunction(CodeGenModule &CGM, StringRef ParentName, |
3585 | | const OMPTargetParallelDirective &S); |
3586 | | /// Emit device code for the target parallel for directive. |
3587 | | static void EmitOMPTargetParallelForDeviceFunction( |
3588 | | CodeGenModule &CGM, StringRef ParentName, |
3589 | | const OMPTargetParallelForDirective &S); |
3590 | | /// Emit device code for the target parallel for simd directive. |
3591 | | static void EmitOMPTargetParallelForSimdDeviceFunction( |
3592 | | CodeGenModule &CGM, StringRef ParentName, |
3593 | | const OMPTargetParallelForSimdDirective &S); |
3594 | | /// Emit device code for the target teams directive. |
3595 | | static void |
3596 | | EmitOMPTargetTeamsDeviceFunction(CodeGenModule &CGM, StringRef ParentName, |
3597 | | const OMPTargetTeamsDirective &S); |
3598 | | /// Emit device code for the target teams distribute directive. |
3599 | | static void EmitOMPTargetTeamsDistributeDeviceFunction( |
3600 | | CodeGenModule &CGM, StringRef ParentName, |
3601 | | const OMPTargetTeamsDistributeDirective &S); |
3602 | | /// Emit device code for the target teams distribute simd directive. |
3603 | | static void EmitOMPTargetTeamsDistributeSimdDeviceFunction( |
3604 | | CodeGenModule &CGM, StringRef ParentName, |
3605 | | const OMPTargetTeamsDistributeSimdDirective &S); |
3606 | | /// Emit device code for the target simd directive. |
3607 | | static void EmitOMPTargetSimdDeviceFunction(CodeGenModule &CGM, |
3608 | | StringRef ParentName, |
3609 | | const OMPTargetSimdDirective &S); |
3610 | | /// Emit device code for the target teams distribute parallel for simd |
3611 | | /// directive. |
3612 | | static void EmitOMPTargetTeamsDistributeParallelForSimdDeviceFunction( |
3613 | | CodeGenModule &CGM, StringRef ParentName, |
3614 | | const OMPTargetTeamsDistributeParallelForSimdDirective &S); |
3615 | | |
3616 | | static void EmitOMPTargetTeamsDistributeParallelForDeviceFunction( |
3617 | | CodeGenModule &CGM, StringRef ParentName, |
3618 | | const OMPTargetTeamsDistributeParallelForDirective &S); |
3619 | | |
3620 | | /// Emit the Stmt \p S and return its topmost canonical loop, if any. |
3621 | | /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the |
3622 | | /// future it is meant to be the number of loops expected in the loop nests |
3623 | | /// (usually specified by the "collapse" clause) that are collapsed to a |
3624 | | /// single loop by this function. |
3625 | | llvm::CanonicalLoopInfo *EmitOMPCollapsedCanonicalLoopNest(const Stmt *S, |
3626 | | int Depth); |
3627 | | |
3628 | | /// Emit an OMPCanonicalLoop using the OpenMPIRBuilder. |
3629 | | void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S); |
3630 | | |
3631 | | /// Emit inner loop of the worksharing/simd construct. |
3632 | | /// |
3633 | | /// \param S Directive, for which the inner loop must be emitted. |
3634 | | /// \param RequiresCleanup true, if directive has some associated private |
3635 | | /// variables. |
3636 | | /// \param LoopCond Bollean condition for loop continuation. |
3637 | | /// \param IncExpr Increment expression for loop control variable. |
3638 | | /// \param BodyGen Generator for the inner body of the inner loop. |
3639 | | /// \param PostIncGen Genrator for post-increment code (required for ordered |
3640 | | /// loop directvies). |
3641 | | void EmitOMPInnerLoop( |
3642 | | const OMPExecutableDirective &S, bool RequiresCleanup, |
3643 | | const Expr *LoopCond, const Expr *IncExpr, |
3644 | | const llvm::function_ref<void(CodeGenFunction &)> BodyGen, |
3645 | | const llvm::function_ref<void(CodeGenFunction &)> PostIncGen); |
3646 | | |
3647 | | JumpDest getOMPCancelDestination(OpenMPDirectiveKind Kind); |
3648 | | /// Emit initial code for loop counters of loop-based directives. |
3649 | | void EmitOMPPrivateLoopCounters(const OMPLoopDirective &S, |
3650 | | OMPPrivateScope &LoopScope); |
3651 | | |
3652 | | /// Helper for the OpenMP loop directives. |
3653 | | void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit); |
3654 | | |
3655 | | /// Emit code for the worksharing loop-based directive. |
3656 | | /// \return true, if this construct has any lastprivate clause, false - |
3657 | | /// otherwise. |
3658 | | bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB, |
3659 | | const CodeGenLoopBoundsTy &CodeGenLoopBounds, |
3660 | | const CodeGenDispatchBoundsTy &CGDispatchBounds); |
3661 | | |
3662 | | /// Emit code for the distribute loop-based directive. |
3663 | | void EmitOMPDistributeLoop(const OMPLoopDirective &S, |
3664 | | const CodeGenLoopTy &CodeGenLoop, Expr *IncExpr); |
3665 | | |
3666 | | /// Helpers for the OpenMP loop directives. |
3667 | | void EmitOMPSimdInit(const OMPLoopDirective &D); |
3668 | | void EmitOMPSimdFinal( |
3669 | | const OMPLoopDirective &D, |
3670 | | const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen); |
3671 | | |
3672 | | /// Emits the lvalue for the expression with possibly captured variable. |
3673 | | LValue EmitOMPSharedLValue(const Expr *E); |
3674 | | |
3675 | | private: |
3676 | | /// Helpers for blocks. |
3677 | | llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info); |
3678 | | |
3679 | | /// struct with the values to be passed to the OpenMP loop-related functions |
3680 | | struct OMPLoopArguments { |
3681 | | /// loop lower bound |
3682 | | Address LB = Address::invalid(); |
3683 | | /// loop upper bound |
3684 | | Address UB = Address::invalid(); |
3685 | | /// loop stride |
3686 | | Address ST = Address::invalid(); |
3687 | | /// isLastIteration argument for runtime functions |
3688 | | Address IL = Address::invalid(); |
3689 | | /// Chunk value generated by sema |
3690 | | llvm::Value *Chunk = nullptr; |
3691 | | /// EnsureUpperBound |
3692 | | Expr *EUB = nullptr; |
3693 | | /// IncrementExpression |
3694 | | Expr *IncExpr = nullptr; |
3695 | | /// Loop initialization |
3696 | | Expr *Init = nullptr; |
3697 | | /// Loop exit condition |
3698 | | Expr *Cond = nullptr; |
3699 | | /// Update of LB after a whole chunk has been executed |
3700 | | Expr *NextLB = nullptr; |
3701 | | /// Update of UB after a whole chunk has been executed |
3702 | | Expr *NextUB = nullptr; |
3703 | 164 | OMPLoopArguments() = default; |
3704 | | OMPLoopArguments(Address LB, Address UB, Address ST, Address IL, |
3705 | | llvm::Value *Chunk = nullptr, Expr *EUB = nullptr, |
3706 | | Expr *IncExpr = nullptr, Expr *Init = nullptr, |
3707 | | Expr *Cond = nullptr, Expr *NextLB = nullptr, |
3708 | | Expr *NextUB = nullptr) |
3709 | | : LB(LB), UB(UB), ST(ST), IL(IL), Chunk(Chunk), EUB(EUB), |
3710 | | IncExpr(IncExpr), Init(Init), Cond(Cond), NextLB(NextLB), |
3711 | 2.27k | NextUB(NextUB) {} |
3712 | | }; |
3713 | | void EmitOMPOuterLoop(bool DynamicOrOrdered, bool IsMonotonic, |
3714 | | const OMPLoopDirective &S, OMPPrivateScope &LoopScope, |
3715 | | const OMPLoopArguments &LoopArgs, |
3716 | | const CodeGenLoopTy &CodeGenLoop, |
3717 | | const CodeGenOrderedTy &CodeGenOrdered); |
3718 | | void EmitOMPForOuterLoop(const OpenMPScheduleTy &ScheduleKind, |
3719 | | bool IsMonotonic, const OMPLoopDirective &S, |
3720 | | OMPPrivateScope &LoopScope, bool Ordered, |
3721 | | const OMPLoopArguments &LoopArgs, |
3722 | | const CodeGenDispatchBoundsTy &CGDispatchBounds); |
3723 | | void EmitOMPDistributeOuterLoop(OpenMPDistScheduleClauseKind ScheduleKind, |
3724 | | const OMPLoopDirective &S, |
3725 | | OMPPrivateScope &LoopScope, |
3726 | | const OMPLoopArguments &LoopArgs, |
3727 | | const CodeGenLoopTy &CodeGenLoopContent); |
3728 | | /// Emit code for sections directive. |
3729 | | void EmitSections(const OMPExecutableDirective &S); |
3730 | | |
3731 | | public: |
3732 | | |
3733 | | //===--------------------------------------------------------------------===// |
3734 | | // LValue Expression Emission |
3735 | | //===--------------------------------------------------------------------===// |
3736 | | |
3737 | | /// Create a check that a scalar RValue is non-null. |
3738 | | llvm::Value *EmitNonNullRValueCheck(RValue RV, QualType T); |
3739 | | |
3740 | | /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type. |
3741 | | RValue GetUndefRValue(QualType Ty); |
3742 | | |
3743 | | /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E |
3744 | | /// and issue an ErrorUnsupported style diagnostic (using the |
3745 | | /// provided Name). |
3746 | | RValue EmitUnsupportedRValue(const Expr *E, |
3747 | | const char *Name); |
3748 | | |
3749 | | /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue |
3750 | | /// an ErrorUnsupported style diagnostic (using the provided Name). |
3751 | | LValue EmitUnsupportedLValue(const Expr *E, |
3752 | | const char *Name); |
3753 | | |
3754 | | /// EmitLValue - Emit code to compute a designator that specifies the location |
3755 | | /// of the expression. |
3756 | | /// |
3757 | | /// This can return one of two things: a simple address or a bitfield |
3758 | | /// reference. In either case, the LLVM Value* in the LValue structure is |
3759 | | /// guaranteed to be an LLVM pointer type. |
3760 | | /// |
3761 | | /// If this returns a bitfield reference, nothing about the pointee type of |
3762 | | /// the LLVM value is known: For example, it may not be a pointer to an |
3763 | | /// integer. |
3764 | | /// |
3765 | | /// If this returns a normal address, and if the lvalue's C type is fixed |
3766 | | /// size, this method guarantees that the returned pointer type will point to |
3767 | | /// an LLVM type of the same size of the lvalue's type. If the lvalue has a |
3768 | | /// variable length type, this is not possible. |
3769 | | /// |
3770 | | LValue EmitLValue(const Expr *E); |
3771 | | |
3772 | | /// Same as EmitLValue but additionally we generate checking code to |
3773 | | /// guard against undefined behavior. This is only suitable when we know |
3774 | | /// that the address will be used to access the object. |
3775 | | LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK); |
3776 | | |
3777 | | RValue convertTempToRValue(Address addr, QualType type, |
3778 | | SourceLocation Loc); |
3779 | | |
3780 | | void EmitAtomicInit(Expr *E, LValue lvalue); |
3781 | | |
3782 | | bool LValueIsSuitableForInlineAtomic(LValue Src); |
3783 | | |
3784 | | RValue EmitAtomicLoad(LValue LV, SourceLocation SL, |
3785 | | AggValueSlot Slot = AggValueSlot::ignored()); |
3786 | | |
3787 | | RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc, |
3788 | | llvm::AtomicOrdering AO, bool IsVolatile = false, |
3789 | | AggValueSlot slot = AggValueSlot::ignored()); |
3790 | | |
3791 | | void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit); |
3792 | | |
3793 | | void EmitAtomicStore(RValue rvalue, LValue lvalue, llvm::AtomicOrdering AO, |
3794 | | bool IsVolatile, bool isInit); |
3795 | | |
3796 | | std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange( |
3797 | | LValue Obj, RValue Expected, RValue Desired, SourceLocation Loc, |
3798 | | llvm::AtomicOrdering Success = |
3799 | | llvm::AtomicOrdering::SequentiallyConsistent, |
3800 | | llvm::AtomicOrdering Failure = |
3801 | | llvm::AtomicOrdering::SequentiallyConsistent, |
3802 | | bool IsWeak = false, AggValueSlot Slot = AggValueSlot::ignored()); |
3803 | | |
3804 | | void EmitAtomicUpdate(LValue LVal, llvm::AtomicOrdering AO, |
3805 | | const llvm::function_ref<RValue(RValue)> &UpdateOp, |
3806 | | bool IsVolatile); |
3807 | | |
3808 | | /// EmitToMemory - Change a scalar value from its value |
3809 | | /// representation to its in-memory representation. |
3810 | | llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty); |
3811 | | |
3812 | | /// EmitFromMemory - Change a scalar value from its memory |
3813 | | /// representation to its value representation. |
3814 | | llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty); |
3815 | | |
3816 | | /// Check if the scalar \p Value is within the valid range for the given |
3817 | | /// type \p Ty. |
3818 | | /// |
3819 | | /// Returns true if a check is needed (even if the range is unknown). |
3820 | | bool EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, |
3821 | | SourceLocation Loc); |
3822 | | |
3823 | | /// EmitLoadOfScalar - Load a scalar value from an address, taking |
3824 | | /// care to appropriately convert from the memory representation to |
3825 | | /// the LLVM value representation. |
3826 | | llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, |
3827 | | SourceLocation Loc, |
3828 | | AlignmentSource Source = AlignmentSource::Type, |
3829 | 4.66k | bool isNontemporal = false) { |
3830 | 4.66k | return EmitLoadOfScalar(Addr, Volatile, Ty, Loc, LValueBaseInfo(Source), |
3831 | 4.66k | CGM.getTBAAAccessInfo(Ty), isNontemporal); |
3832 | 4.66k | } |
3833 | | |
3834 | | llvm::Value *EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, |
3835 | | SourceLocation Loc, LValueBaseInfo BaseInfo, |
3836 | | TBAAAccessInfo TBAAInfo, |
3837 | | bool isNontemporal = false); |
3838 | | |
3839 | | /// EmitLoadOfScalar - Load a scalar value from an address, taking |
3840 | | /// care to appropriately convert from the memory representation to |
3841 | | /// the LLVM value representation. The l-value must be a simple |
3842 | | /// l-value. |
3843 | | llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc); |
3844 | | |
3845 | | /// EmitStoreOfScalar - Store a scalar value to an address, taking |
3846 | | /// care to appropriately convert from the memory representation to |
3847 | | /// the LLVM value representation. |
3848 | | void EmitStoreOfScalar(llvm::Value *Value, Address Addr, |
3849 | | bool Volatile, QualType Ty, |
3850 | | AlignmentSource Source = AlignmentSource::Type, |
3851 | 1.19k | bool isInit = false, bool isNontemporal = false) { |
3852 | 1.19k | EmitStoreOfScalar(Value, Addr, Volatile, Ty, LValueBaseInfo(Source), |
3853 | 1.19k | CGM.getTBAAAccessInfo(Ty), isInit, isNontemporal); |
3854 | 1.19k | } |
3855 | | |
3856 | | void EmitStoreOfScalar(llvm::Value *Value, Address Addr, |
3857 | | bool Volatile, QualType Ty, |
3858 | | LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo, |
3859 | | bool isInit = false, bool isNontemporal = false); |
3860 | | |
3861 | | /// EmitStoreOfScalar - Store a scalar value to an address, taking |
3862 | | /// care to appropriately convert from the memory representation to |
3863 | | /// the LLVM value representation. The l-value must be a simple |
3864 | | /// l-value. The isInit flag indicates whether this is an initialization. |
3865 | | /// If so, atomic qualifiers are ignored and the store is always non-atomic. |
3866 | | void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false); |
3867 | | |
3868 | | /// EmitLoadOfLValue - Given an expression that represents a value lvalue, |
3869 | | /// this method emits the address of the lvalue, then loads the result as an |
3870 | | /// rvalue, returning the rvalue. |
3871 | | RValue EmitLoadOfLValue(LValue V, SourceLocation Loc); |
3872 | | RValue EmitLoadOfExtVectorElementLValue(LValue V); |
3873 | | RValue EmitLoadOfBitfieldLValue(LValue LV, SourceLocation Loc); |
3874 | | RValue EmitLoadOfGlobalRegLValue(LValue LV); |
3875 | | |
3876 | | /// EmitStoreThroughLValue - Store the specified rvalue into the specified |
3877 | | /// lvalue, where both are guaranteed to the have the same type, and that type |
3878 | | /// is 'Ty'. |
3879 | | void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false); |
3880 | | void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst); |
3881 | | void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst); |
3882 | | |
3883 | | /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints |
3884 | | /// as EmitStoreThroughLValue. |
3885 | | /// |
3886 | | /// \param Result [out] - If non-null, this will be set to a Value* for the |
3887 | | /// bit-field contents after the store, appropriate for use as the result of |
3888 | | /// an assignment to the bit-field. |
3889 | | void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, |
3890 | | llvm::Value **Result=nullptr); |
3891 | | |
3892 | | /// Emit an l-value for an assignment (simple or compound) of complex type. |
3893 | | LValue EmitComplexAssignmentLValue(const BinaryOperator *E); |
3894 | | LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E); |
3895 | | LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, |
3896 | | llvm::Value *&Result); |
3897 | | |
3898 | | // Note: only available for agg return types |
3899 | | LValue EmitBinaryOperatorLValue(const BinaryOperator *E); |
3900 | | LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E); |
3901 | | // Note: only available for agg return types |
3902 | | LValue EmitCallExprLValue(const CallExpr *E); |
3903 | | // Note: only available for agg return types |
3904 | | LValue EmitVAArgExprLValue(const VAArgExpr *E); |
3905 | | LValue EmitDeclRefLValue(const DeclRefExpr *E); |
3906 | | LValue EmitStringLiteralLValue(const StringLiteral *E); |
3907 | | LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E); |
3908 | | LValue EmitPredefinedLValue(const PredefinedExpr *E); |
3909 | | LValue EmitUnaryOpLValue(const UnaryOperator *E); |
3910 | | LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, |
3911 | | bool Accessed = false); |
3912 | | LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E); |
3913 | | LValue EmitOMPArraySectionExpr(const OMPArraySectionExpr *E, |
3914 | | bool IsLowerBound = true); |
3915 | | LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E); |
3916 | | LValue EmitMemberExpr(const MemberExpr *E); |
3917 | | LValue EmitObjCIsaExpr(const ObjCIsaExpr *E); |
3918 | | LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E); |
3919 | | LValue EmitInitListLValue(const InitListExpr *E); |
3920 | | void EmitIgnoredConditionalOperator(const AbstractConditionalOperator *E); |
3921 | | LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E); |
3922 | | LValue EmitCastLValue(const CastExpr *E); |
3923 | | LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E); |
3924 | | LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e); |
3925 | | |
3926 | | Address EmitExtVectorElementLValue(LValue V); |
3927 | | |
3928 | | RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc); |
3929 | | |
3930 | | Address EmitArrayToPointerDecay(const Expr *Array, |
3931 | | LValueBaseInfo *BaseInfo = nullptr, |
3932 | | TBAAAccessInfo *TBAAInfo = nullptr); |
3933 | | |
3934 | | class ConstantEmission { |
3935 | | llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference; |
3936 | | ConstantEmission(llvm::Constant *C, bool isReference) |
3937 | 6.48k | : ValueAndIsReference(C, isReference) {} |
3938 | | public: |
3939 | 1.00M | ConstantEmission() {} |
3940 | 60 | static ConstantEmission forReference(llvm::Constant *C) { |
3941 | 60 | return ConstantEmission(C, true); |
3942 | 60 | } |
3943 | 6.42k | static ConstantEmission forValue(llvm::Constant *C) { |
3944 | 6.42k | return ConstantEmission(C, false); |
3945 | 6.42k | } |
3946 | | |
3947 | 1.02M | explicit operator bool() const { |
3948 | 1.02M | return ValueAndIsReference.getOpaqueValue() != nullptr; |
3949 | 1.02M | } |
3950 | | |
3951 | 12.9k | bool isReference() const { return ValueAndIsReference.getInt(); } |
3952 | 60 | LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const { |
3953 | 60 | assert(isReference()); |
3954 | 0 | return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(), |
3955 | 60 | refExpr->getType()); |
3956 | 60 | } |
3957 | | |
3958 | 6.42k | llvm::Constant *getValue() const { |
3959 | 6.42k | assert(!isReference()); |
3960 | 0 | return ValueAndIsReference.getPointer(); |
3961 | 6.42k | } |
3962 | | }; |
3963 | | |
3964 | | ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr); |
3965 | | ConstantEmission tryEmitAsConstant(const MemberExpr *ME); |
3966 | | llvm::Value *emitScalarConstant(const ConstantEmission &Constant, Expr *E); |
3967 | | |
3968 | | RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, |
3969 | | AggValueSlot slot = AggValueSlot::ignored()); |
3970 | | LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e); |
3971 | | |
3972 | | llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface, |
3973 | | const ObjCIvarDecl *Ivar); |
3974 | | LValue EmitLValueForField(LValue Base, const FieldDecl* Field); |
3975 | | LValue EmitLValueForLambdaField(const FieldDecl *Field); |
3976 | | |
3977 | | /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that |
3978 | | /// if the Field is a reference, this will return the address of the reference |
3979 | | /// and not the address of the value stored in the reference. |
3980 | | LValue EmitLValueForFieldInitialization(LValue Base, |
3981 | | const FieldDecl* Field); |
3982 | | |
3983 | | LValue EmitLValueForIvar(QualType ObjectTy, |
3984 | | llvm::Value* Base, const ObjCIvarDecl *Ivar, |
3985 | | unsigned CVRQualifiers); |
3986 | | |
3987 | | LValue EmitCXXConstructLValue(const CXXConstructExpr *E); |
3988 | | LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E); |
3989 | | LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E); |
3990 | | LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E); |
3991 | | |
3992 | | LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E); |
3993 | | LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E); |
3994 | | LValue EmitStmtExprLValue(const StmtExpr *E); |
3995 | | LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E); |
3996 | | LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E); |
3997 | | void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init); |
3998 | | |
3999 | | //===--------------------------------------------------------------------===// |
4000 | | // Scalar Expression Emission |
4001 | | //===--------------------------------------------------------------------===// |
4002 | | |
4003 | | /// EmitCall - Generate a call of the given function, expecting the given |
4004 | | /// result type, and using the given argument list which specifies both the |
4005 | | /// LLVM arguments and the types they were derived from. |
4006 | | RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, |
4007 | | ReturnValueSlot ReturnValue, const CallArgList &Args, |
4008 | | llvm::CallBase **callOrInvoke, bool IsMustTail, |
4009 | | SourceLocation Loc); |
4010 | | RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, |
4011 | | ReturnValueSlot ReturnValue, const CallArgList &Args, |
4012 | | llvm::CallBase **callOrInvoke = nullptr, |
4013 | 18.4k | bool IsMustTail = false) { |
4014 | 18.4k | return EmitCall(CallInfo, Callee, ReturnValue, Args, callOrInvoke, |
4015 | 18.4k | IsMustTail, SourceLocation()); |
4016 | 18.4k | } |
4017 | | RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E, |
4018 | | ReturnValueSlot ReturnValue, llvm::Value *Chain = nullptr); |
4019 | | RValue EmitCallExpr(const CallExpr *E, |
4020 | | ReturnValueSlot ReturnValue = ReturnValueSlot()); |
4021 | | RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue); |
4022 | | CGCallee EmitCallee(const Expr *E); |
4023 | | |
4024 | | void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl); |
4025 | | void checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl); |
4026 | | |
4027 | | llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee, |
4028 | | const Twine &name = ""); |
4029 | | llvm::CallInst *EmitRuntimeCall(llvm::FunctionCallee callee, |
4030 | | ArrayRef<llvm::Value *> args, |
4031 | | const Twine &name = ""); |
4032 | | llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee, |
4033 | | const Twine &name = ""); |
4034 | | llvm::CallInst *EmitNounwindRuntimeCall(llvm::FunctionCallee callee, |
4035 | | ArrayRef<llvm::Value *> args, |
4036 | | const Twine &name = ""); |
4037 | | |
4038 | | SmallVector<llvm::OperandBundleDef, 1> |
4039 | | getBundlesForFunclet(llvm::Value *Callee); |
4040 | | |
4041 | | llvm::CallBase *EmitCallOrInvoke(llvm::FunctionCallee Callee, |
4042 | | ArrayRef<llvm::Value *> Args, |
4043 | | const Twine &Name = ""); |
4044 | | llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, |
4045 | | ArrayRef<llvm::Value *> args, |
4046 | | const Twine &name = ""); |
4047 | | llvm::CallBase *EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, |
4048 | | const Twine &name = ""); |
4049 | | void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, |
4050 | | ArrayRef<llvm::Value *> args); |
4051 | | |
4052 | | CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, |
4053 | | NestedNameSpecifier *Qual, |
4054 | | llvm::Type *Ty); |
4055 | | |
4056 | | CGCallee BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD, |
4057 | | CXXDtorType Type, |
4058 | | const CXXRecordDecl *RD); |
4059 | | |
4060 | | // Return the copy constructor name with the prefix "__copy_constructor_" |
4061 | | // removed. |
4062 | | static std::string getNonTrivialCopyConstructorStr(QualType QT, |
4063 | | CharUnits Alignment, |
4064 | | bool IsVolatile, |
4065 | | ASTContext &Ctx); |
4066 | | |
4067 | | // Return the destructor name with the prefix "__destructor_" removed. |
4068 | | static std::string getNonTrivialDestructorStr(QualType QT, |
4069 | | CharUnits Alignment, |
4070 | | bool IsVolatile, |
4071 | | ASTContext &Ctx); |
4072 | | |
4073 | | // These functions emit calls to the special functions of non-trivial C |
4074 | | // structs. |
4075 | | void defaultInitNonTrivialCStructVar(LValue Dst); |
4076 | | void callCStructDefaultConstructor(LValue Dst); |
4077 | | void callCStructDestructor(LValue Dst); |
4078 | | void callCStructCopyConstructor(LValue Dst, LValue Src); |
4079 | | void callCStructMoveConstructor(LValue Dst, LValue Src); |
4080 | | void callCStructCopyAssignmentOperator(LValue Dst, LValue Src); |
4081 | | void callCStructMoveAssignmentOperator(LValue Dst, LValue Src); |
4082 | | |
4083 | | RValue |
4084 | | EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method, |
4085 | | const CGCallee &Callee, |
4086 | | ReturnValueSlot ReturnValue, llvm::Value *This, |
4087 | | llvm::Value *ImplicitParam, |
4088 | | QualType ImplicitParamTy, const CallExpr *E, |
4089 | | CallArgList *RtlArgs); |
4090 | | RValue EmitCXXDestructorCall(GlobalDecl Dtor, const CGCallee &Callee, |
4091 | | llvm::Value *This, QualType ThisTy, |
4092 | | llvm::Value *ImplicitParam, |
4093 | | QualType ImplicitParamTy, const CallExpr *E); |
4094 | | RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, |
4095 | | ReturnValueSlot ReturnValue); |
4096 | | RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, |
4097 | | const CXXMethodDecl *MD, |
4098 | | ReturnValueSlot ReturnValue, |
4099 | | bool HasQualifier, |
4100 | | NestedNameSpecifier *Qualifier, |
4101 | | bool IsArrow, const Expr *Base); |
4102 | | // Compute the object pointer. |
4103 | | Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, |
4104 | | llvm::Value *memberPtr, |
4105 | | const MemberPointerType *memberPtrType, |
4106 | | LValueBaseInfo *BaseInfo = nullptr, |
4107 | | TBAAAccessInfo *TBAAInfo = nullptr); |
4108 | | RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, |
4109 | | ReturnValueSlot ReturnValue); |
4110 | | |
4111 | | RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, |
4112 | | const CXXMethodDecl *MD, |
4113 | | ReturnValueSlot ReturnValue); |
4114 | | RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E); |
4115 | | |
4116 | | RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, |
4117 | | ReturnValueSlot ReturnValue); |
4118 | | |
4119 | | RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E); |
4120 | | RValue EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E); |
4121 | | RValue EmitOpenMPDevicePrintfCallExpr(const CallExpr *E); |
4122 | | |
4123 | | RValue EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, |
4124 | | const CallExpr *E, ReturnValueSlot ReturnValue); |
4125 | | |
4126 | | RValue emitRotate(const CallExpr *E, bool IsRotateRight); |
4127 | | |
4128 | | /// Emit IR for __builtin_os_log_format. |
4129 | | RValue emitBuiltinOSLogFormat(const CallExpr &E); |
4130 | | |
4131 | | /// Emit IR for __builtin_is_aligned. |
4132 | | RValue EmitBuiltinIsAligned(const CallExpr *E); |
4133 | | /// Emit IR for __builtin_align_up/__builtin_align_down. |
4134 | | RValue EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp); |
4135 | | |
4136 | | llvm::Function *generateBuiltinOSLogHelperFunction( |
4137 | | const analyze_os_log::OSLogBufferLayout &Layout, |
4138 | | CharUnits BufferAlignment); |
4139 | | |
4140 | | RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue); |
4141 | | |
4142 | | /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call |
4143 | | /// is unhandled by the current target. |
4144 | | llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4145 | | ReturnValueSlot ReturnValue); |
4146 | | |
4147 | | llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty, |
4148 | | const llvm::CmpInst::Predicate Fp, |
4149 | | const llvm::CmpInst::Predicate Ip, |
4150 | | const llvm::Twine &Name = ""); |
4151 | | llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4152 | | ReturnValueSlot ReturnValue, |
4153 | | llvm::Triple::ArchType Arch); |
4154 | | llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4155 | | ReturnValueSlot ReturnValue, |
4156 | | llvm::Triple::ArchType Arch); |
4157 | | llvm::Value *EmitARMCDEBuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4158 | | ReturnValueSlot ReturnValue, |
4159 | | llvm::Triple::ArchType Arch); |
4160 | | llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::IntegerType *ITy, |
4161 | | QualType RTy); |
4162 | | llvm::Value *EmitCMSEClearRecord(llvm::Value *V, llvm::ArrayType *ATy, |
4163 | | QualType RTy); |
4164 | | |
4165 | | llvm::Value *EmitCommonNeonBuiltinExpr(unsigned BuiltinID, |
4166 | | unsigned LLVMIntrinsic, |
4167 | | unsigned AltLLVMIntrinsic, |
4168 | | const char *NameHint, |
4169 | | unsigned Modifier, |
4170 | | const CallExpr *E, |
4171 | | SmallVectorImpl<llvm::Value *> &Ops, |
4172 | | Address PtrOp0, Address PtrOp1, |
4173 | | llvm::Triple::ArchType Arch); |
4174 | | |
4175 | | llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID, |
4176 | | unsigned Modifier, llvm::Type *ArgTy, |
4177 | | const CallExpr *E); |
4178 | | llvm::Value *EmitNeonCall(llvm::Function *F, |
4179 | | SmallVectorImpl<llvm::Value*> &O, |
4180 | | const char *name, |
4181 | | unsigned shift = 0, bool rightshift = false); |
4182 | | llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx, |
4183 | | const llvm::ElementCount &Count); |
4184 | | llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx); |
4185 | | llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty, |
4186 | | bool negateForRightShift); |
4187 | | llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt, |
4188 | | llvm::Type *Ty, bool usgn, const char *name); |
4189 | | llvm::Value *vectorWrapScalar16(llvm::Value *Op); |
4190 | | /// SVEBuiltinMemEltTy - Returns the memory element type for this memory |
4191 | | /// access builtin. Only required if it can't be inferred from the base |
4192 | | /// pointer operand. |
4193 | | llvm::Type *SVEBuiltinMemEltTy(const SVETypeFlags &TypeFlags); |
4194 | | |
4195 | | SmallVector<llvm::Type *, 2> |
4196 | | getSVEOverloadTypes(const SVETypeFlags &TypeFlags, llvm::Type *ReturnType, |
4197 | | ArrayRef<llvm::Value *> Ops); |
4198 | | llvm::Type *getEltType(const SVETypeFlags &TypeFlags); |
4199 | | llvm::ScalableVectorType *getSVEType(const SVETypeFlags &TypeFlags); |
4200 | | llvm::ScalableVectorType *getSVEPredType(const SVETypeFlags &TypeFlags); |
4201 | | llvm::Value *EmitSVEAllTruePred(const SVETypeFlags &TypeFlags); |
4202 | | llvm::Value *EmitSVEDupX(llvm::Value *Scalar); |
4203 | | llvm::Value *EmitSVEDupX(llvm::Value *Scalar, llvm::Type *Ty); |
4204 | | llvm::Value *EmitSVEReinterpret(llvm::Value *Val, llvm::Type *Ty); |
4205 | | llvm::Value *EmitSVEPMull(const SVETypeFlags &TypeFlags, |
4206 | | llvm::SmallVectorImpl<llvm::Value *> &Ops, |
4207 | | unsigned BuiltinID); |
4208 | | llvm::Value *EmitSVEMovl(const SVETypeFlags &TypeFlags, |
4209 | | llvm::ArrayRef<llvm::Value *> Ops, |
4210 | | unsigned BuiltinID); |
4211 | | llvm::Value *EmitSVEPredicateCast(llvm::Value *Pred, |
4212 | | llvm::ScalableVectorType *VTy); |
4213 | | llvm::Value *EmitSVEGatherLoad(const SVETypeFlags &TypeFlags, |
4214 | | llvm::SmallVectorImpl<llvm::Value *> &Ops, |
4215 | | unsigned IntID); |
4216 | | llvm::Value *EmitSVEScatterStore(const SVETypeFlags &TypeFlags, |
4217 | | llvm::SmallVectorImpl<llvm::Value *> &Ops, |
4218 | | unsigned IntID); |
4219 | | llvm::Value *EmitSVEMaskedLoad(const CallExpr *, llvm::Type *ReturnTy, |
4220 | | SmallVectorImpl<llvm::Value *> &Ops, |
4221 | | unsigned BuiltinID, bool IsZExtReturn); |
4222 | | llvm::Value *EmitSVEMaskedStore(const CallExpr *, |
4223 | | SmallVectorImpl<llvm::Value *> &Ops, |
4224 | | unsigned BuiltinID); |
4225 | | llvm::Value *EmitSVEPrefetchLoad(const SVETypeFlags &TypeFlags, |
4226 | | SmallVectorImpl<llvm::Value *> &Ops, |
4227 | | unsigned BuiltinID); |
4228 | | llvm::Value *EmitSVEGatherPrefetch(const SVETypeFlags &TypeFlags, |
4229 | | SmallVectorImpl<llvm::Value *> &Ops, |
4230 | | unsigned IntID); |
4231 | | llvm::Value *EmitSVEStructLoad(const SVETypeFlags &TypeFlags, |
4232 | | SmallVectorImpl<llvm::Value *> &Ops, |
4233 | | unsigned IntID); |
4234 | | llvm::Value *EmitSVEStructStore(const SVETypeFlags &TypeFlags, |
4235 | | SmallVectorImpl<llvm::Value *> &Ops, |
4236 | | unsigned IntID); |
4237 | | llvm::Value *EmitAArch64SVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4238 | | |
4239 | | llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4240 | | llvm::Triple::ArchType Arch); |
4241 | | llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4242 | | |
4243 | | llvm::Value *BuildVector(ArrayRef<llvm::Value*> Ops); |
4244 | | llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4245 | | llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4246 | | llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4247 | | llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4248 | | llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4249 | | llvm::Value *EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, |
4250 | | const CallExpr *E); |
4251 | | llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E); |
4252 | | llvm::Value *EmitRISCVBuiltinExpr(unsigned BuiltinID, const CallExpr *E, |
4253 | | ReturnValueSlot ReturnValue); |
4254 | | bool ProcessOrderScopeAMDGCN(llvm::Value *Order, llvm::Value *Scope, |
4255 | | llvm::AtomicOrdering &AO, |
4256 | | llvm::SyncScope::ID &SSID); |
4257 | | |
4258 | | enum class MSVCIntrin; |
4259 | | llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E); |
4260 | | |
4261 | | llvm::Value *EmitBuiltinAvailable(const VersionTuple &Version); |
4262 | | |
4263 | | llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); |
4264 | | llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E); |
4265 | | llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E); |
4266 | | llvm::Value *EmitObjCArrayLiteral(const ObjCArrayLiteral *E); |
4267 | | llvm::Value *EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E); |
4268 | | llvm::Value *EmitObjCCollectionLiteral(const Expr *E, |
4269 | | const ObjCMethodDecl *MethodWithObjects); |
4270 | | llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E); |
4271 | | RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, |
4272 | | ReturnValueSlot Return = ReturnValueSlot()); |
4273 | | |
4274 | | /// Retrieves the default cleanup kind for an ARC cleanup. |
4275 | | /// Except under -fobjc-arc-eh, ARC cleanups are normal-only. |
4276 | 1.13k | CleanupKind getARCCleanupKind() { |
4277 | 1.13k | return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions |
4278 | 1.13k | ? NormalAndEHCleanup84 : NormalCleanup1.05k ; |
4279 | 1.13k | } |
4280 | | |
4281 | | // ARC primitives. |
4282 | | void EmitARCInitWeak(Address addr, llvm::Value *value); |
4283 | | void EmitARCDestroyWeak(Address addr); |
4284 | | llvm::Value *EmitARCLoadWeak(Address addr); |
4285 | | llvm::Value *EmitARCLoadWeakRetained(Address addr); |
4286 | | llvm::Value *EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored); |
4287 | | void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr); |
4288 | | void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr); |
4289 | | void EmitARCCopyWeak(Address dst, Address src); |
4290 | | void EmitARCMoveWeak(Address dst, Address src); |
4291 | | llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value); |
4292 | | llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value); |
4293 | | llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value, |
4294 | | bool resultIgnored); |
4295 | | llvm::Value *EmitARCStoreStrongCall(Address addr, llvm::Value *value, |
4296 | | bool resultIgnored); |
4297 | | llvm::Value *EmitARCRetain(QualType type, llvm::Value *value); |
4298 | | llvm::Value *EmitARCRetainNonBlock(llvm::Value *value); |
4299 | | llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory); |
4300 | | void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise); |
4301 | | void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise); |
4302 | | llvm::Value *EmitARCAutorelease(llvm::Value *value); |
4303 | | llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value); |
4304 | | llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value); |
4305 | | llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value); |
4306 | | llvm::Value *EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value); |
4307 | | |
4308 | | llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType); |
4309 | | llvm::Value *EmitObjCRetainNonBlock(llvm::Value *value, |
4310 | | llvm::Type *returnType); |
4311 | | void EmitObjCRelease(llvm::Value *value, ARCPreciseLifetime_t precise); |
4312 | | |
4313 | | std::pair<LValue,llvm::Value*> |
4314 | | EmitARCStoreAutoreleasing(const BinaryOperator *e); |
4315 | | std::pair<LValue,llvm::Value*> |
4316 | | EmitARCStoreStrong(const BinaryOperator *e, bool ignored); |
4317 | | std::pair<LValue,llvm::Value*> |
4318 | | EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored); |
4319 | | |
4320 | | llvm::Value *EmitObjCAlloc(llvm::Value *value, |
4321 | | llvm::Type *returnType); |
4322 | | llvm::Value *EmitObjCAllocWithZone(llvm::Value *value, |
4323 | | llvm::Type *returnType); |
4324 | | llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType); |
4325 | | |
4326 | | llvm::Value *EmitObjCThrowOperand(const Expr *expr); |
4327 | | llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr); |
4328 | | llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr); |
4329 | | |
4330 | | llvm::Value *EmitARCExtendBlockObject(const Expr *expr); |
4331 | | llvm::Value *EmitARCReclaimReturnedObject(const Expr *e, |
4332 | | bool allowUnsafeClaim); |
4333 | | llvm::Value *EmitARCRetainScalarExpr(const Expr *expr); |
4334 | | llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr); |
4335 | | llvm::Value *EmitARCUnsafeUnretainedScalarExpr(const Expr *expr); |
4336 | | |
4337 | | void EmitARCIntrinsicUse(ArrayRef<llvm::Value*> values); |
4338 | | |
4339 | | void EmitARCNoopIntrinsicUse(ArrayRef<llvm::Value *> values); |
4340 | | |
4341 | | static Destroyer destroyARCStrongImprecise; |
4342 | | static Destroyer destroyARCStrongPrecise; |
4343 | | static Destroyer destroyARCWeak; |
4344 | | static Destroyer emitARCIntrinsicUse; |
4345 | | static Destroyer destroyNonTrivialCStruct; |
4346 | | |
4347 | | void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr); |
4348 | | llvm::Value *EmitObjCAutoreleasePoolPush(); |
4349 | | llvm::Value *EmitObjCMRRAutoreleasePoolPush(); |
4350 | | void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr); |
4351 | | void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr); |
4352 | | |
4353 | | /// Emits a reference binding to the passed in expression. |
4354 | | RValue EmitReferenceBindingToExpr(const Expr *E); |
4355 | | |
4356 | | //===--------------------------------------------------------------------===// |
4357 | | // Expression Emission |
4358 | | //===--------------------------------------------------------------------===// |
4359 | | |
4360 | | // Expressions are broken into three classes: scalar, complex, aggregate. |
4361 | | |
4362 | | /// EmitScalarExpr - Emit the computation of the specified expression of LLVM |
4363 | | /// scalar type, returning the result. |
4364 | | llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false); |
4365 | | |
4366 | | /// Emit a conversion from the specified type to the specified destination |
4367 | | /// type, both of which are LLVM scalar types. |
4368 | | llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy, |
4369 | | QualType DstTy, SourceLocation Loc); |
4370 | | |
4371 | | /// Emit a conversion from the specified complex type to the specified |
4372 | | /// destination type, where the destination type is an LLVM scalar type. |
4373 | | llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, |
4374 | | QualType DstTy, |
4375 | | SourceLocation Loc); |
4376 | | |
4377 | | /// EmitAggExpr - Emit the computation of the specified expression |
4378 | | /// of aggregate type. The result is computed into the given slot, |
4379 | | /// which may be null to indicate that the value is not needed. |
4380 | | void EmitAggExpr(const Expr *E, AggValueSlot AS); |
4381 | | |
4382 | | /// EmitAggExprToLValue - Emit the computation of the specified expression of |
4383 | | /// aggregate type into a temporary LValue. |
4384 | | LValue EmitAggExprToLValue(const Expr *E); |
4385 | | |
4386 | | /// Build all the stores needed to initialize an aggregate at Dest with the |
4387 | | /// value Val. |
4388 | | void EmitAggregateStore(llvm::Value *Val, Address Dest, bool DestIsVolatile); |
4389 | | |
4390 | | /// EmitExtendGCLifetime - Given a pointer to an Objective-C object, |
4391 | | /// make sure it survives garbage collection until this point. |
4392 | | void EmitExtendGCLifetime(llvm::Value *object); |
4393 | | |
4394 | | /// EmitComplexExpr - Emit the computation of the specified expression of |
4395 | | /// complex type, returning the result. |
4396 | | ComplexPairTy EmitComplexExpr(const Expr *E, |
4397 | | bool IgnoreReal = false, |
4398 | | bool IgnoreImag = false); |
4399 | | |
4400 | | /// EmitComplexExprIntoLValue - Emit the given expression of complex |
4401 | | /// type and place its result into the specified l-value. |
4402 | | void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit); |
4403 | | |
4404 | | /// EmitStoreOfComplex - Store a complex number into the specified l-value. |
4405 | | void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit); |
4406 | | |
4407 | | /// EmitLoadOfComplex - Load a complex number from the specified l-value. |
4408 | | ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc); |
4409 | | |
4410 | | Address emitAddrOfRealComponent(Address complex, QualType complexType); |
4411 | | Address emitAddrOfImagComponent(Address complex, QualType complexType); |
4412 | | |
4413 | | /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the |
4414 | | /// global variable that has already been created for it. If the initializer |
4415 | | /// has a different type than GV does, this may free GV and return a different |
4416 | | /// one. Otherwise it just returns GV. |
4417 | | llvm::GlobalVariable * |
4418 | | AddInitializerToStaticVarDecl(const VarDecl &D, |
4419 | | llvm::GlobalVariable *GV); |
4420 | | |
4421 | | // Emit an @llvm.invariant.start call for the given memory region. |
4422 | | void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size); |
4423 | | |
4424 | | /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++ |
4425 | | /// variable with global storage. |
4426 | | void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::GlobalVariable *GV, |
4427 | | bool PerformInit); |
4428 | | |
4429 | | llvm::Function *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor, |
4430 | | llvm::Constant *Addr); |
4431 | | |
4432 | | llvm::Function *createTLSAtExitStub(const VarDecl &VD, |
4433 | | llvm::FunctionCallee Dtor, |
4434 | | llvm::Constant *Addr, |
4435 | | llvm::FunctionCallee &AtExit); |
4436 | | |
4437 | | /// Call atexit() with a function that passes the given argument to |
4438 | | /// the given function. |
4439 | | void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn, |
4440 | | llvm::Constant *addr); |
4441 | | |
4442 | | /// Call atexit() with function dtorStub. |
4443 | | void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub); |
4444 | | |
4445 | | /// Call unatexit() with function dtorStub. |
4446 | | llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Constant *dtorStub); |
4447 | | |
4448 | | /// Emit code in this function to perform a guarded variable |
4449 | | /// initialization. Guarded initializations are used when it's not |
4450 | | /// possible to prove that an initialization will be done exactly |
4451 | | /// once, e.g. with a static local variable or a static data member |
4452 | | /// of a class template. |
4453 | | void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, |
4454 | | bool PerformInit); |
4455 | | |
4456 | | enum class GuardKind { VariableGuard, TlsGuard }; |
4457 | | |
4458 | | /// Emit a branch to select whether or not to perform guarded initialization. |
4459 | | void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit, |
4460 | | llvm::BasicBlock *InitBlock, |
4461 | | llvm::BasicBlock *NoInitBlock, |
4462 | | GuardKind Kind, const VarDecl *D); |
4463 | | |
4464 | | /// GenerateCXXGlobalInitFunc - Generates code for initializing global |
4465 | | /// variables. |
4466 | | void |
4467 | | GenerateCXXGlobalInitFunc(llvm::Function *Fn, |
4468 | | ArrayRef<llvm::Function *> CXXThreadLocals, |
4469 | | ConstantAddress Guard = ConstantAddress::invalid()); |
4470 | | |
4471 | | /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global |
4472 | | /// variables. |
4473 | | void GenerateCXXGlobalCleanUpFunc( |
4474 | | llvm::Function *Fn, |
4475 | | ArrayRef<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH, |
4476 | | llvm::Constant *>> |
4477 | | DtorsOrStermFinalizers); |
4478 | | |
4479 | | void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, |
4480 | | const VarDecl *D, |
4481 | | llvm::GlobalVariable *Addr, |
4482 | | bool PerformInit); |
4483 | | |
4484 | | void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest); |
4485 | | |
4486 | | void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp); |
4487 | | |
4488 | | void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true); |
4489 | | |
4490 | | RValue EmitAtomicExpr(AtomicExpr *E); |
4491 | | |
4492 | | //===--------------------------------------------------------------------===// |
4493 | | // Annotations Emission |
4494 | | //===--------------------------------------------------------------------===// |
4495 | | |
4496 | | /// Emit an annotation call (intrinsic). |
4497 | | llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn, |
4498 | | llvm::Value *AnnotatedVal, |
4499 | | StringRef AnnotationStr, |
4500 | | SourceLocation Location, |
4501 | | const AnnotateAttr *Attr); |
4502 | | |
4503 | | /// Emit local annotations for the local variable V, declared by D. |
4504 | | void EmitVarAnnotations(const VarDecl *D, llvm::Value *V); |
4505 | | |
4506 | | /// Emit field annotations for the given field & value. Returns the |
4507 | | /// annotation result. |
4508 | | Address EmitFieldAnnotations(const FieldDecl *D, Address V); |
4509 | | |
4510 | | //===--------------------------------------------------------------------===// |
4511 | | // Internal Helpers |
4512 | | //===--------------------------------------------------------------------===// |
4513 | | |
4514 | | /// ContainsLabel - Return true if the statement contains a label in it. If |
4515 | | /// this statement is not executed normally, it not containing a label means |
4516 | | /// that we can just remove the code. |
4517 | | static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false); |
4518 | | |
4519 | | /// containsBreak - Return true if the statement contains a break out of it. |
4520 | | /// If the statement (recursively) contains a switch or loop with a break |
4521 | | /// inside of it, this is fine. |
4522 | | static bool containsBreak(const Stmt *S); |
4523 | | |
4524 | | /// Determine if the given statement might introduce a declaration into the |
4525 | | /// current scope, by being a (possibly-labelled) DeclStmt. |
4526 | | static bool mightAddDeclToScope(const Stmt *S); |
4527 | | |
4528 | | /// ConstantFoldsToSimpleInteger - If the specified expression does not fold |
4529 | | /// to a constant, or if it does but contains a label, return false. If it |
4530 | | /// constant folds return true and set the boolean result in Result. |
4531 | | bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, |
4532 | | bool AllowLabels = false); |
4533 | | |
4534 | | /// ConstantFoldsToSimpleInteger - If the specified expression does not fold |
4535 | | /// to a constant, or if it does but contains a label, return false. If it |
4536 | | /// constant folds return true and set the folded value. |
4537 | | bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result, |
4538 | | bool AllowLabels = false); |
4539 | | |
4540 | | /// isInstrumentedCondition - Determine whether the given condition is an |
4541 | | /// instrumentable condition (i.e. no "&&" or "||"). |
4542 | | static bool isInstrumentedCondition(const Expr *C); |
4543 | | |
4544 | | /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that |
4545 | | /// increments a profile counter based on the semantics of the given logical |
4546 | | /// operator opcode. This is used to instrument branch condition coverage |
4547 | | /// for logical operators. |
4548 | | void EmitBranchToCounterBlock(const Expr *Cond, BinaryOperator::Opcode LOp, |
4549 | | llvm::BasicBlock *TrueBlock, |
4550 | | llvm::BasicBlock *FalseBlock, |
4551 | | uint64_t TrueCount = 0, |
4552 | | Stmt::Likelihood LH = Stmt::LH_None, |
4553 | | const Expr *CntrIdx = nullptr); |
4554 | | |
4555 | | /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an |
4556 | | /// if statement) to the specified blocks. Based on the condition, this might |
4557 | | /// try to simplify the codegen of the conditional based on the branch. |
4558 | | /// TrueCount should be the number of times we expect the condition to |
4559 | | /// evaluate to true based on PGO data. |
4560 | | void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, |
4561 | | llvm::BasicBlock *FalseBlock, uint64_t TrueCount, |
4562 | | Stmt::Likelihood LH = Stmt::LH_None); |
4563 | | |
4564 | | /// Given an assignment `*LHS = RHS`, emit a test that checks if \p RHS is |
4565 | | /// nonnull, if \p LHS is marked _Nonnull. |
4566 | | void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc); |
4567 | | |
4568 | | /// An enumeration which makes it easier to specify whether or not an |
4569 | | /// operation is a subtraction. |
4570 | | enum { NotSubtraction = false, IsSubtraction = true }; |
4571 | | |
4572 | | /// Same as IRBuilder::CreateInBoundsGEP, but additionally emits a check to |
4573 | | /// detect undefined behavior when the pointer overflow sanitizer is enabled. |
4574 | | /// \p SignedIndices indicates whether any of the GEP indices are signed. |
4575 | | /// \p IsSubtraction indicates whether the expression used to form the GEP |
4576 | | /// is a subtraction. |
4577 | | llvm::Value *EmitCheckedInBoundsGEP(llvm::Type *ElemTy, llvm::Value *Ptr, |
4578 | | ArrayRef<llvm::Value *> IdxList, |
4579 | | bool SignedIndices, |
4580 | | bool IsSubtraction, |
4581 | | SourceLocation Loc, |
4582 | | const Twine &Name = ""); |
4583 | | |
4584 | | /// Specifies which type of sanitizer check to apply when handling a |
4585 | | /// particular builtin. |
4586 | | enum BuiltinCheckKind { |
4587 | | BCK_CTZPassedZero, |
4588 | | BCK_CLZPassedZero, |
4589 | | }; |
4590 | | |
4591 | | /// Emits an argument for a call to a builtin. If the builtin sanitizer is |
4592 | | /// enabled, a runtime check specified by \p Kind is also emitted. |
4593 | | llvm::Value *EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind); |
4594 | | |
4595 | | /// Emit a description of a type in a format suitable for passing to |
4596 | | /// a runtime sanitizer handler. |
4597 | | llvm::Constant *EmitCheckTypeDescriptor(QualType T); |
4598 | | |
4599 | | /// Convert a value into a format suitable for passing to a runtime |
4600 | | /// sanitizer handler. |
4601 | | llvm::Value *EmitCheckValue(llvm::Value *V); |
4602 | | |
4603 | | /// Emit a description of a source location in a format suitable for |
4604 | | /// passing to a runtime sanitizer handler. |
4605 | | llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc); |
4606 | | |
4607 | | /// Create a basic block that will either trap or call a handler function in |
4608 | | /// the UBSan runtime with the provided arguments, and create a conditional |
4609 | | /// branch to it. |
4610 | | void EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked, |
4611 | | SanitizerHandler Check, ArrayRef<llvm::Constant *> StaticArgs, |
4612 | | ArrayRef<llvm::Value *> DynamicArgs); |
4613 | | |
4614 | | /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath |
4615 | | /// if Cond if false. |
4616 | | void EmitCfiSlowPathCheck(SanitizerMask Kind, llvm::Value *Cond, |
4617 | | llvm::ConstantInt *TypeId, llvm::Value *Ptr, |
4618 | | ArrayRef<llvm::Constant *> StaticArgs); |
4619 | | |
4620 | | /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime |
4621 | | /// checking is enabled. Otherwise, just emit an unreachable instruction. |
4622 | | void EmitUnreachable(SourceLocation Loc); |
4623 | | |
4624 | | /// Create a basic block that will call the trap intrinsic, and emit a |
4625 | | /// conditional branch to it, for the -ftrapv checks. |
4626 | | void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID); |
4627 | | |
4628 | | /// Emit a call to trap or debugtrap and attach function attribute |
4629 | | /// "trap-func-name" if specified. |
4630 | | llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID); |
4631 | | |
4632 | | /// Emit a stub for the cross-DSO CFI check function. |
4633 | | void EmitCfiCheckStub(); |
4634 | | |
4635 | | /// Emit a cross-DSO CFI failure handling function. |
4636 | | void EmitCfiCheckFail(); |
4637 | | |
4638 | | /// Create a check for a function parameter that may potentially be |
4639 | | /// declared as non-null. |
4640 | | void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, |
4641 | | AbstractCallee AC, unsigned ParmNum); |
4642 | | |
4643 | | /// EmitCallArg - Emit a single call argument. |
4644 | | void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType); |
4645 | | |
4646 | | /// EmitDelegateCallArg - We are performing a delegate call; that |
4647 | | /// is, the current function is delegating to another one. Produce |
4648 | | /// a r-value suitable for passing the given parameter. |
4649 | | void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, |
4650 | | SourceLocation loc); |
4651 | | |
4652 | | /// SetFPAccuracy - Set the minimum required accuracy of the given floating |
4653 | | /// point operation, expressed as the maximum relative error in ulp. |
4654 | | void SetFPAccuracy(llvm::Value *Val, float Accuracy); |
4655 | | |
4656 | | /// Set the codegen fast-math flags. |
4657 | | void SetFastMathFlags(FPOptions FPFeatures); |
4658 | | |
4659 | | // Truncate or extend a boolean vector to the requested number of elements. |
4660 | | llvm::Value *emitBoolVecConversion(llvm::Value *SrcVec, |
4661 | | unsigned NumElementsDst, |
4662 | | const llvm::Twine &Name = ""); |
4663 | | |
4664 | | private: |
4665 | | llvm::MDNode *getRangeForLoadFromType(QualType Ty); |
4666 | | void EmitReturnOfRValue(RValue RV, QualType Ty); |
4667 | | |
4668 | | void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New); |
4669 | | |
4670 | | llvm::SmallVector<std::pair<llvm::WeakTrackingVH, llvm::Value *>, 4> |
4671 | | DeferredReplacements; |
4672 | | |
4673 | | /// Set the address of a local variable. |
4674 | 793k | void setAddrOfLocalVar(const VarDecl *VD, Address Addr) { |
4675 | 793k | assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!"); |
4676 | 0 | LocalDeclMap.insert({VD, Addr}); |
4677 | 793k | } |
4678 | | |
4679 | | /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty |
4680 | | /// from function arguments into \arg Dst. See ABIArgInfo::Expand. |
4681 | | /// |
4682 | | /// \param AI - The first function argument of the expansion. |
4683 | | void ExpandTypeFromArgs(QualType Ty, LValue Dst, |
4684 | | llvm::Function::arg_iterator &AI); |
4685 | | |
4686 | | /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg |
4687 | | /// Ty, into individual arguments on the provided vector \arg IRCallArgs, |
4688 | | /// starting at index \arg IRCallArgPos. See ABIArgInfo::Expand. |
4689 | | void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy, |
4690 | | SmallVectorImpl<llvm::Value *> &IRCallArgs, |
4691 | | unsigned &IRCallArgPos); |
4692 | | |
4693 | | std::pair<llvm::Value *, llvm::Type *> |
4694 | | EmitAsmInput(const TargetInfo::ConstraintInfo &Info, const Expr *InputExpr, |
4695 | | std::string &ConstraintStr); |
4696 | | |
4697 | | std::pair<llvm::Value *, llvm::Type *> |
4698 | | EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, LValue InputValue, |
4699 | | QualType InputType, std::string &ConstraintStr, |
4700 | | SourceLocation Loc); |
4701 | | |
4702 | | /// Attempts to statically evaluate the object size of E. If that |
4703 | | /// fails, emits code to figure the size of E out for us. This is |
4704 | | /// pass_object_size aware. |
4705 | | /// |
4706 | | /// If EmittedExpr is non-null, this will use that instead of re-emitting E. |
4707 | | llvm::Value *evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type, |
4708 | | llvm::IntegerType *ResType, |
4709 | | llvm::Value *EmittedE, |
4710 | | bool IsDynamic); |
4711 | | |
4712 | | /// Emits the size of E, as required by __builtin_object_size. This |
4713 | | /// function is aware of pass_object_size parameters, and will act accordingly |
4714 | | /// if E is a parameter with the pass_object_size attribute. |
4715 | | llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type, |
4716 | | llvm::IntegerType *ResType, |
4717 | | llvm::Value *EmittedE, |
4718 | | bool IsDynamic); |
4719 | | |
4720 | | void emitZeroOrPatternForAutoVarInit(QualType type, const VarDecl &D, |
4721 | | Address Loc); |
4722 | | |
4723 | | public: |
4724 | | enum class EvaluationOrder { |
4725 | | ///! No language constraints on evaluation order. |
4726 | | Default, |
4727 | | ///! Language semantics require left-to-right evaluation. |
4728 | | ForceLeftToRight, |
4729 | | ///! Language semantics require right-to-left evaluation. |
4730 | | ForceRightToLeft |
4731 | | }; |
4732 | | |
4733 | | // Wrapper for function prototype sources. Wraps either a FunctionProtoType or |
4734 | | // an ObjCMethodDecl. |
4735 | | struct PrototypeWrapper { |
4736 | | llvm::PointerUnion<const FunctionProtoType *, const ObjCMethodDecl *> P; |
4737 | | |
4738 | 304k | PrototypeWrapper(const FunctionProtoType *FT) : P(FT) {} |
4739 | 11.9k | PrototypeWrapper(const ObjCMethodDecl *MD) : P(MD) {} |
4740 | | }; |
4741 | | |
4742 | | void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, |
4743 | | llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange, |
4744 | | AbstractCallee AC = AbstractCallee(), |
4745 | | unsigned ParamsToSkip = 0, |
4746 | | EvaluationOrder Order = EvaluationOrder::Default); |
4747 | | |
4748 | | /// EmitPointerWithAlignment - Given an expression with a pointer type, |
4749 | | /// emit the value and compute our best estimate of the alignment of the |
4750 | | /// pointee. |
4751 | | /// |
4752 | | /// \param BaseInfo - If non-null, this will be initialized with |
4753 | | /// information about the source of the alignment and the may-alias |
4754 | | /// attribute. Note that this function will conservatively fall back on |
4755 | | /// the type when it doesn't recognize the expression and may-alias will |
4756 | | /// be set to false. |
4757 | | /// |
4758 | | /// One reasonable way to use this information is when there's a language |
4759 | | /// guarantee that the pointer must be aligned to some stricter value, and |
4760 | | /// we're simply trying to ensure that sufficiently obvious uses of under- |
4761 | | /// aligned objects don't get miscompiled; for example, a placement new |
4762 | | /// into the address of a local variable. In such a case, it's quite |
4763 | | /// reasonable to just ignore the returned alignment when it isn't from an |
4764 | | /// explicit source. |
4765 | | Address EmitPointerWithAlignment(const Expr *Addr, |
4766 | | LValueBaseInfo *BaseInfo = nullptr, |
4767 | | TBAAAccessInfo *TBAAInfo = nullptr); |
4768 | | |
4769 | | /// If \p E references a parameter with pass_object_size info or a constant |
4770 | | /// array size modifier, emit the object size divided by the size of \p EltTy. |
4771 | | /// Otherwise return null. |
4772 | | llvm::Value *LoadPassedObjectSize(const Expr *E, QualType EltTy); |
4773 | | |
4774 | | void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK); |
4775 | | |
4776 | | struct MultiVersionResolverOption { |
4777 | | llvm::Function *Function; |
4778 | | struct Conds { |
4779 | | StringRef Architecture; |
4780 | | llvm::SmallVector<StringRef, 8> Features; |
4781 | | |
4782 | | Conds(StringRef Arch, ArrayRef<StringRef> Feats) |
4783 | 338 | : Architecture(Arch), Features(Feats.begin(), Feats.end()) {} |
4784 | | } Conditions; |
4785 | | |
4786 | | MultiVersionResolverOption(llvm::Function *F, StringRef Arch, |
4787 | | ArrayRef<StringRef> Feats) |
4788 | 338 | : Function(F), Conditions(Arch, Feats) {} |
4789 | | }; |
4790 | | |
4791 | | // Emits the body of a multiversion function's resolver. Assumes that the |
4792 | | // options are already sorted in the proper order, with the 'default' option |
4793 | | // last (if it exists). |
4794 | | void EmitMultiVersionResolver(llvm::Function *Resolver, |
4795 | | ArrayRef<MultiVersionResolverOption> Options); |
4796 | | |
4797 | | private: |
4798 | | QualType getVarArgType(const Expr *Arg); |
4799 | | |
4800 | | void EmitDeclMetadata(); |
4801 | | |
4802 | | BlockByrefHelpers *buildByrefHelpers(llvm::StructType &byrefType, |
4803 | | const AutoVarEmission &emission); |
4804 | | |
4805 | | void AddObjCARCExceptionMetadata(llvm::Instruction *Inst); |
4806 | | |
4807 | | llvm::Value *GetValueForARMHint(unsigned BuiltinID); |
4808 | | llvm::Value *EmitX86CpuIs(const CallExpr *E); |
4809 | | llvm::Value *EmitX86CpuIs(StringRef CPUStr); |
4810 | | llvm::Value *EmitX86CpuSupports(const CallExpr *E); |
4811 | | llvm::Value *EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs); |
4812 | | llvm::Value *EmitX86CpuSupports(uint64_t Mask); |
4813 | | llvm::Value *EmitX86CpuInit(); |
4814 | | llvm::Value *FormResolverCondition(const MultiVersionResolverOption &RO); |
4815 | | }; |
4816 | | |
4817 | | /// TargetFeatures - This class is used to check whether the builtin function |
4818 | | /// has the required tagert specific features. It is able to support the |
4819 | | /// combination of ','(and), '|'(or), and '()'. By default, the priority of |
4820 | | /// ',' is higher than that of '|' . |
4821 | | /// E.g: |
4822 | | /// A,B|C means the builtin function requires both A and B, or C. |
4823 | | /// If we want the builtin function requires both A and B, or both A and C, |
4824 | | /// there are two ways: A,B|A,C or A,(B|C). |
4825 | | /// The FeaturesList should not contain spaces, and brackets must appear in |
4826 | | /// pairs. |
4827 | | class TargetFeatures { |
4828 | | struct FeatureListStatus { |
4829 | | bool HasFeatures; |
4830 | | StringRef CurFeaturesList; |
4831 | | }; |
4832 | | |
4833 | | const llvm::StringMap<bool> &CallerFeatureMap; |
4834 | | |
4835 | 22.6k | FeatureListStatus getAndFeatures(StringRef FeatureList) { |
4836 | 22.6k | int InParentheses = 0; |
4837 | 22.6k | bool HasFeatures = true; |
4838 | 22.6k | size_t SubexpressionStart = 0; |
4839 | 262k | for (size_t i = 0, e = FeatureList.size(); i < e; ++i239k ) { |
4840 | 246k | char CurrentToken = FeatureList[i]; |
4841 | 246k | switch (CurrentToken) { |
4842 | 218k | default: |
4843 | 218k | break; |
4844 | 218k | case '(': |
4845 | 2.19k | if (InParentheses == 0) |
4846 | 2.19k | SubexpressionStart = i + 1; |
4847 | 2.19k | ++InParentheses; |
4848 | 2.19k | break; |
4849 | 2.19k | case ')': |
4850 | 2.19k | --InParentheses; |
4851 | 2.19k | assert(InParentheses >= 0 && "Parentheses are not in pair"); |
4852 | 2.19k | LLVM_FALLTHROUGH; |
4853 | 22.4k | case '|': |
4854 | 25.4k | case ',': |
4855 | 25.4k | if (InParentheses == 0) { |
4856 | 12.2k | if (HasFeatures && i != SubexpressionStart11.5k ) { |
4857 | 10.7k | StringRef F = FeatureList.slice(SubexpressionStart, i); |
4858 | 10.7k | HasFeatures = CurrentToken == ')' ? hasRequiredFeatures(F)1.86k |
4859 | 10.7k | : CallerFeatureMap.lookup(F)8.91k ; |
4860 | 10.7k | } |
4861 | 12.2k | SubexpressionStart = i + 1; |
4862 | 12.2k | if (CurrentToken == '|') { |
4863 | 7.06k | return {HasFeatures, FeatureList.substr(SubexpressionStart)}; |
4864 | 7.06k | } |
4865 | 12.2k | } |
4866 | 18.4k | break; |
4867 | 246k | } |
4868 | 246k | } |
4869 | 15.5k | assert(InParentheses == 0 && "Parentheses are not in pair"); |
4870 | 15.5k | if (HasFeatures && SubexpressionStart != FeatureList.size()15.1k ) |
4871 | 14.4k | HasFeatures = |
4872 | 14.4k | CallerFeatureMap.lookup(FeatureList.substr(SubexpressionStart)); |
4873 | 15.5k | return {HasFeatures, StringRef()}; |
4874 | 22.6k | } |
4875 | | |
4876 | | public: |
4877 | 17.1k | bool hasRequiredFeatures(StringRef FeatureList) { |
4878 | 17.1k | FeatureListStatus FS = {false, FeatureList}; |
4879 | 39.7k | while (!FS.HasFeatures && !FS.CurFeaturesList.empty()23.5k ) |
4880 | 22.6k | FS = getAndFeatures(FS.CurFeaturesList); |
4881 | 17.1k | return FS.HasFeatures; |
4882 | 17.1k | } |
4883 | | |
4884 | | TargetFeatures(const llvm::StringMap<bool> &CallerFeatureMap) |
4885 | 15.2k | : CallerFeatureMap(CallerFeatureMap) {} |
4886 | | }; |
4887 | | |
4888 | | inline DominatingLLVMValue::saved_type |
4889 | 142 | DominatingLLVMValue::save(CodeGenFunction &CGF, llvm::Value *value) { |
4890 | 142 | if (!needsSaving(value)) return saved_type(value, false)101 ; |
4891 | | |
4892 | | // Otherwise, we need an alloca. |
4893 | 41 | auto align = CharUnits::fromQuantity( |
4894 | 41 | CGF.CGM.getDataLayout().getPrefTypeAlignment(value->getType())); |
4895 | 41 | Address alloca = |
4896 | 41 | CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save"); |
4897 | 41 | CGF.Builder.CreateStore(value, alloca); |
4898 | | |
4899 | 41 | return saved_type(alloca.getPointer(), true); |
4900 | 142 | } |
4901 | | |
4902 | | inline llvm::Value *DominatingLLVMValue::restore(CodeGenFunction &CGF, |
4903 | 147 | saved_type value) { |
4904 | | // If the value says it wasn't saved, trust that it's still dominating. |
4905 | 147 | if (!value.getInt()) return value.getPointer()120 ; |
4906 | | |
4907 | | // Otherwise, it should be an alloca instruction, as set up in save(). |
4908 | 27 | auto alloca = cast<llvm::AllocaInst>(value.getPointer()); |
4909 | 27 | return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca, |
4910 | 27 | alloca->getAlign()); |
4911 | 147 | } |
4912 | | |
4913 | | } // end namespace CodeGen |
4914 | | |
4915 | | // Map the LangOption for floating point exception behavior into |
4916 | | // the corresponding enum in the IR. |
4917 | | llvm::fp::ExceptionBehavior |
4918 | | ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind); |
4919 | | } // end namespace clang |
4920 | | |
4921 | | #endif |