1//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
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 coordinates the per-function state used while generating code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CodeGenFunction.h"
14#include "CGBlocks.h"
15#include "CGCUDARuntime.h"
16#include "CGCXXABI.h"
17#include "CGCleanup.h"
18#include "CGDebugInfo.h"
19#include "CGOpenMPRuntime.h"
20#include "CodeGenModule.h"
21#include "CodeGenPGO.h"
22#include "TargetInfo.h"
23#include "clang/AST/ASTContext.h"
24#include "clang/AST/ASTLambda.h"
25#include "clang/AST/Attr.h"
26#include "clang/AST/Decl.h"
27#include "clang/AST/DeclCXX.h"
28#include "clang/AST/Expr.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/StmtObjC.h"
31#include "clang/Basic/Builtins.h"
32#include "clang/Basic/CodeGenOptions.h"
33#include "clang/Basic/TargetInfo.h"
34#include "clang/CodeGen/CGFunctionInfo.h"
35#include "clang/Frontend/FrontendDiagnostic.h"
36#include "llvm/ADT/ArrayRef.h"
37#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
38#include "llvm/IR/DataLayout.h"
39#include "llvm/IR/Dominators.h"
40#include "llvm/IR/FPEnv.h"
41#include "llvm/IR/IntrinsicInst.h"
42#include "llvm/IR/Intrinsics.h"
43#include "llvm/IR/MDBuilder.h"
44#include "llvm/IR/Operator.h"
45#include "llvm/Support/CRC.h"
46#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
47#include "llvm/Transforms/Utils/PromoteMemToReg.h"
48using namespace clang;
49using namespace CodeGen;
50
51/// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
52/// markers.
53static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
54 const LangOptions &LangOpts) {
55 if (CGOpts.DisableLifetimeMarkers)
56 return false;
57
58 // Sanitizers may use markers.
59 if (CGOpts.SanitizeAddressUseAfterScope ||
60 LangOpts.Sanitize.has(SanitizerKind::HWAddress) ||
61 LangOpts.Sanitize.has(SanitizerKind::Memory))
62 return true;
63
64 // For now, only in optimized builds.
65 return CGOpts.OptimizationLevel != 0;
66}
67
68CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
69 : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
70 Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
71 CGBuilderInserterTy(this)),
72 SanOpts(CGM.getLangOpts().Sanitize), CurFPFeatures(CGM.getLangOpts()),
73 DebugInfo(CGM.getModuleDebugInfo()), PGO(cgm),
74 ShouldEmitLifetimeMarkers(
75 shouldEmitLifetimeMarkers(CGM.getCodeGenOpts(), CGM.getLangOpts())) {
76 if (!suppressNewContext)
77 CGM.getCXXABI().getMangleContext().startNewFunction();
78
79 SetFastMathFlags(CurFPFeatures);
80 SetFPModel();
81}
82
83CodeGenFunction::~CodeGenFunction() {
84 assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
85
86 if (getLangOpts().OpenMP && CurFn)
87 CGM.getOpenMPRuntime().functionFinished(*this);
88
89 // If we have an OpenMPIRBuilder we want to finalize functions (incl.
90 // outlining etc) at some point. Doing it once the function codegen is done
91 // seems to be a reasonable spot. We do it here, as opposed to the deletion
92 // time of the CodeGenModule, because we have to ensure the IR has not yet
93 // been "emitted" to the outside, thus, modifications are still sensible.
94 if (CGM.getLangOpts().OpenMPIRBuilder && CurFn)
95 CGM.getOpenMPRuntime().getOMPBuilder().finalize(CurFn);
96}
97
98// Map the LangOption for exception behavior into
99// the corresponding enum in the IR.
100llvm::fp::ExceptionBehavior
101clang::ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind) {
102
103 switch (Kind) {
104 case LangOptions::FPE_Ignore: return llvm::fp::ebIgnore;
105 case LangOptions::FPE_MayTrap: return llvm::fp::ebMayTrap;
106 case LangOptions::FPE_Strict: return llvm::fp::ebStrict;
107 }
108 llvm_unreachable("Unsupported FP Exception Behavior");
109}
110
111void CodeGenFunction::SetFPModel() {
112 llvm::RoundingMode RM = getLangOpts().getFPRoundingMode();
113 auto fpExceptionBehavior = ToConstrainedExceptMD(
114 getLangOpts().getFPExceptionMode());
115
116 Builder.setDefaultConstrainedRounding(RM);
117 Builder.setDefaultConstrainedExcept(fpExceptionBehavior);
118 Builder.setIsFPConstrained(fpExceptionBehavior != llvm::fp::ebIgnore ||
119 RM != llvm::RoundingMode::NearestTiesToEven);
120}
121
122void CodeGenFunction::SetFastMathFlags(FPOptions FPFeatures) {
123 llvm::FastMathFlags FMF;
124 FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
125 FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
126 FMF.setNoInfs(FPFeatures.getNoHonorInfs());
127 FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
128 FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
129 FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
130 FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
131 Builder.setFastMathFlags(FMF);
132}
133
134CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,
135 const Expr *E)
136 : CGF(CGF) {
137 ConstructorHelper(E->getFPFeaturesInEffect(CGF.getLangOpts()));
138}
139
140CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,
141 FPOptions FPFeatures)
142 : CGF(CGF) {
143 ConstructorHelper(FPFeatures);
144}
145
146void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) {
147 OldFPFeatures = CGF.CurFPFeatures;
148 CGF.CurFPFeatures = FPFeatures;
149
150 OldExcept = CGF.Builder.getDefaultConstrainedExcept();
151 OldRounding = CGF.Builder.getDefaultConstrainedRounding();
152
153 if (OldFPFeatures == FPFeatures)
154 return;
155
156 FMFGuard.emplace(CGF.Builder);
157
158 llvm::RoundingMode NewRoundingBehavior =
159 static_cast<llvm::RoundingMode>(FPFeatures.getRoundingMode());
160 CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
161 auto NewExceptionBehavior =
162 ToConstrainedExceptMD(static_cast<LangOptions::FPExceptionModeKind>(
163 FPFeatures.getFPExceptionMode()));
164 CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
165
166 CGF.SetFastMathFlags(FPFeatures);
167
168 assert((CGF.CurFuncDecl == nullptr || CGF.Builder.getIsFPConstrained() ||
169 isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||
170 isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||
171 (NewExceptionBehavior == llvm::fp::ebIgnore &&
172 NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
173 "FPConstrained should be enabled on entire function");
174
175 auto mergeFnAttrValue = [&](StringRef Name, bool Value) {
176 auto OldValue =
177 CGF.CurFn->getFnAttribute(Name).getValueAsBool();
178 auto NewValue = OldValue & Value;
179 if (OldValue != NewValue)
180 CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
181 };
182 mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs());
183 mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs());
184 mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
185 mergeFnAttrValue("unsafe-fp-math", FPFeatures.getAllowFPReassociate() &&
186 FPFeatures.getAllowReciprocal() &&
187 FPFeatures.getAllowApproxFunc() &&
188 FPFeatures.getNoSignedZero());
189}
190
191CodeGenFunction::CGFPOptionsRAII::~CGFPOptionsRAII() {
192 CGF.CurFPFeatures = OldFPFeatures;
193 CGF.Builder.setDefaultConstrainedExcept(OldExcept);
194 CGF.Builder.setDefaultConstrainedRounding(OldRounding);
195}
196
197LValue CodeGenFunction::MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {
198 LValueBaseInfo BaseInfo;
199 TBAAAccessInfo TBAAInfo;
200 CharUnits Alignment = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo);
201 return LValue::MakeAddr(Address(V, Alignment), T, getContext(), BaseInfo,
202 TBAAInfo);
203}
204
205/// Given a value of type T* that may not be to a complete object,
206/// construct an l-value with the natural pointee alignment of T.
207LValue
208CodeGenFunction::MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T) {
209 LValueBaseInfo BaseInfo;
210 TBAAAccessInfo TBAAInfo;
211 CharUnits Align = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo,
212 /* forPointeeType= */ true);
213 return MakeAddrLValue(Address(V, Align), T, BaseInfo, TBAAInfo);
214}
215
216
217llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
218 return CGM.getTypes().ConvertTypeForMem(T);
219}
220
221llvm::Type *CodeGenFunction::ConvertType(QualType T) {
222 return CGM.getTypes().ConvertType(T);
223}
224
225TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {
226 type = type.getCanonicalType();
227 while (true) {
228 switch (type->getTypeClass()) {
229#define TYPE(name, parent)
230#define ABSTRACT_TYPE(name, parent)
231#define NON_CANONICAL_TYPE(name, parent) case Type::name:
232#define DEPENDENT_TYPE(name, parent) case Type::name:
233#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
234#include "clang/AST/TypeNodes.inc"
235 llvm_unreachable("non-canonical or dependent type in IR-generation");
236
237 case Type::Auto:
238 case Type::DeducedTemplateSpecialization:
239 llvm_unreachable("undeduced type in IR-generation");
240
241 // Various scalar types.
242 case Type::Builtin:
243 case Type::Pointer:
244 case Type::BlockPointer:
245 case Type::LValueReference:
246 case Type::RValueReference:
247 case Type::MemberPointer:
248 case Type::Vector:
249 case Type::ExtVector:
250 case Type::ConstantMatrix:
251 case Type::FunctionProto:
252 case Type::FunctionNoProto:
253 case Type::Enum:
254 case Type::ObjCObjectPointer:
255 case Type::Pipe:
256 case Type::ExtInt:
257 return TEK_Scalar;
258
259 // Complexes.
260 case Type::Complex:
261 return TEK_Complex;
262
263 // Arrays, records, and Objective-C objects.
264 case Type::ConstantArray:
265 case Type::IncompleteArray:
266 case Type::VariableArray:
267 case Type::Record:
268 case Type::ObjCObject:
269 case Type::ObjCInterface:
270 return TEK_Aggregate;
271
272 // We operate on atomic values according to their underlying type.
273 case Type::Atomic:
274 type = cast<AtomicType>(type)->getValueType();
275 continue;
276 }
277 llvm_unreachable("unknown type kind!");
278 }
279}
280
281llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {
282 // For cleanliness, we try to avoid emitting the return block for
283 // simple cases.
284 llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
285
286 if (CurBB) {
287 assert(!CurBB->getTerminator() && "Unexpected terminated block.");
288
289 // We have a valid insert point, reuse it if it is empty or there are no
290 // explicit jumps to the return block.
291 if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
292 ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
293 delete ReturnBlock.getBlock();
294 ReturnBlock = JumpDest();
295 } else
296 EmitBlock(ReturnBlock.getBlock());
297 return llvm::DebugLoc();
298 }
299
300 // Otherwise, if the return block is the target of a single direct
301 // branch then we can just put the code in that block instead. This
302 // cleans up functions which started with a unified return block.
303 if (ReturnBlock.getBlock()->hasOneUse()) {
304 llvm::BranchInst *BI =
305 dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());
306 if (BI && BI->isUnconditional() &&
307 BI->getSuccessor(0) == ReturnBlock.getBlock()) {
308 // Record/return the DebugLoc of the simple 'return' expression to be used
309 // later by the actual 'ret' instruction.
310 llvm::DebugLoc Loc = BI->getDebugLoc();
311 Builder.SetInsertPoint(BI->getParent());
312 BI->eraseFromParent();
313 delete ReturnBlock.getBlock();
314 ReturnBlock = JumpDest();
315 return Loc;
316 }
317 }
318
319 // FIXME: We are at an unreachable point, there is no reason to emit the block
320 // unless it has uses. However, we still need a place to put the debug
321 // region.end for now.
322
323 EmitBlock(ReturnBlock.getBlock());
324 return llvm::DebugLoc();
325}
326
327static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
328 if (!BB) return;
329 if (!BB->use_empty())
330 return CGF.CurFn->getBasicBlockList().push_back(BB);
331 delete BB;
332}
333
334void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
335 assert(BreakContinueStack.empty() &&
336 "mismatched push/pop in break/continue stack!");
337
338 bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
339 && NumSimpleReturnExprs == NumReturnExprs
340 && ReturnBlock.getBlock()->use_empty();
341 // Usually the return expression is evaluated before the cleanup
342 // code. If the function contains only a simple return statement,
343 // such as a constant, the location before the cleanup code becomes
344 // the last useful breakpoint in the function, because the simple
345 // return expression will be evaluated after the cleanup code. To be
346 // safe, set the debug location for cleanup code to the location of
347 // the return statement. Otherwise the cleanup code should be at the
348 // end of the function's lexical scope.
349 //
350 // If there are multiple branches to the return block, the branch
351 // instructions will get the location of the return statements and
352 // all will be fine.
353 if (CGDebugInfo *DI = getDebugInfo()) {
354 if (OnlySimpleReturnStmts)
355 DI->EmitLocation(Builder, LastStopPoint);
356 else
357 DI->EmitLocation(Builder, EndLoc);
358 }
359
360 // Pop any cleanups that might have been associated with the
361 // parameters. Do this in whatever block we're currently in; it's
362 // important to do this before we enter the return block or return
363 // edges will be *really* confused.
364 bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
365 bool HasOnlyLifetimeMarkers =
366 HasCleanups && EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth);
367 bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
368 if (HasCleanups) {
369 // Make sure the line table doesn't jump back into the body for
370 // the ret after it's been at EndLoc.
371 Optional<ApplyDebugLocation> AL;
372 if (CGDebugInfo *DI = getDebugInfo()) {
373 if (OnlySimpleReturnStmts)
374 DI->EmitLocation(Builder, EndLoc);
375 else
376 // We may not have a valid end location. Try to apply it anyway, and
377 // fall back to an artificial location if needed.
378 AL = ApplyDebugLocation::CreateDefaultArtificial(*this, EndLoc);
379 }
380
381 PopCleanupBlocks(PrologueCleanupDepth);
382 }
383
384 // Emit function epilog (to return).
385 llvm::DebugLoc Loc = EmitReturnBlock();
386
387 if (ShouldInstrumentFunction()) {
388 if (CGM.getCodeGenOpts().InstrumentFunctions)
389 CurFn->addFnAttr("instrument-function-exit", "__cyg_profile_func_exit");
390 if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
391 CurFn->addFnAttr("instrument-function-exit-inlined",
392 "__cyg_profile_func_exit");
393 }
394
395 // Emit debug descriptor for function end.
396 if (CGDebugInfo *DI = getDebugInfo())
397 DI->EmitFunctionEnd(Builder, CurFn);
398
399 // Reset the debug location to that of the simple 'return' expression, if any
400 // rather than that of the end of the function's scope '}'.
401 ApplyDebugLocation AL(*this, Loc);
402 EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);
403 EmitEndEHSpec(CurCodeDecl);
404
405 assert(EHStack.empty() &&
406 "did not remove all scopes from cleanup stack!");
407
408 // If someone did an indirect goto, emit the indirect goto block at the end of
409 // the function.
410 if (IndirectBranch) {
411 EmitBlock(IndirectBranch->getParent());
412 Builder.ClearInsertionPoint();
413 }
414
415 // If some of our locals escaped, insert a call to llvm.localescape in the
416 // entry block.
417 if (!EscapedLocals.empty()) {
418 // Invert the map from local to index into a simple vector. There should be
419 // no holes.
420 SmallVector<llvm::Value *, 4> EscapeArgs;
421 EscapeArgs.resize(EscapedLocals.size());
422 for (auto &Pair : EscapedLocals)
423 EscapeArgs[Pair.second] = Pair.first;
424 llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
425 &CGM.getModule(), llvm::Intrinsic::localescape);
426 CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
427 }
428
429 // Remove the AllocaInsertPt instruction, which is just a convenience for us.
430 llvm::Instruction *Ptr = AllocaInsertPt;
431 AllocaInsertPt = nullptr;
432 Ptr->eraseFromParent();
433
434 // If someone took the address of a label but never did an indirect goto, we
435 // made a zero entry PHI node, which is illegal, zap it now.
436 if (IndirectBranch) {
437 llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
438 if (PN->getNumIncomingValues() == 0) {
439 PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
440 PN->eraseFromParent();
441 }
442 }
443
444 EmitIfUsed(*this, EHResumeBlock);
445 EmitIfUsed(*this, TerminateLandingPad);
446 EmitIfUsed(*this, TerminateHandler);
447 EmitIfUsed(*this, UnreachableBlock);
448
449 for (const auto &FuncletAndParent : TerminateFunclets)
450 EmitIfUsed(*this, FuncletAndParent.second);
451
452 if (CGM.getCodeGenOpts().EmitDeclMetadata)
453 EmitDeclMetadata();
454
455 for (const auto &R : DeferredReplacements) {
456 if (llvm::Value *Old = R.first) {
457 Old->replaceAllUsesWith(R.second);
458 cast<llvm::Instruction>(Old)->eraseFromParent();
459 }
460 }
461 DeferredReplacements.clear();
462
463 // Eliminate CleanupDestSlot alloca by replacing it with SSA values and
464 // PHIs if the current function is a coroutine. We don't do it for all
465 // functions as it may result in slight increase in numbers of instructions
466 // if compiled with no optimizations. We do it for coroutine as the lifetime
467 // of CleanupDestSlot alloca make correct coroutine frame building very
468 // difficult.
469 if (NormalCleanupDest.isValid() && isCoroutine()) {
470 llvm::DominatorTree DT(*CurFn);
471 llvm::PromoteMemToReg(
472 cast<llvm::AllocaInst>(NormalCleanupDest.getPointer()), DT);
473 NormalCleanupDest = Address::invalid();
474 }
475
476 // Scan function arguments for vector width.
477 for (llvm::Argument &A : CurFn->args())
478 if (auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
479 LargestVectorWidth =
480 std::max((uint64_t)LargestVectorWidth,
481 VT->getPrimitiveSizeInBits().getKnownMinSize());
482
483 // Update vector width based on return type.
484 if (auto *VT = dyn_cast<llvm::VectorType>(CurFn->getReturnType()))
485 LargestVectorWidth =
486 std::max((uint64_t)LargestVectorWidth,
487 VT->getPrimitiveSizeInBits().getKnownMinSize());
488
489 // Add the required-vector-width attribute. This contains the max width from:
490 // 1. min-vector-width attribute used in the source program.
491 // 2. Any builtins used that have a vector width specified.
492 // 3. Values passed in and out of inline assembly.
493 // 4. Width of vector arguments and return types for this function.
494 // 5. Width of vector aguments and return types for functions called by this
495 // function.
496 CurFn->addFnAttr("min-legal-vector-width", llvm::utostr(LargestVectorWidth));
497
498 // Add vscale attribute if appropriate.
499 if (getLangOpts().ArmSveVectorBits) {
500 unsigned VScale = getLangOpts().ArmSveVectorBits / 128;
501 CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(getLLVMContext(),
502 VScale, VScale));
503 }
504
505 // If we generated an unreachable return block, delete it now.
506 if (ReturnBlock.isValid() && ReturnBlock.getBlock()->use_empty()) {
507 Builder.ClearInsertionPoint();
508 ReturnBlock.getBlock()->eraseFromParent();
509 }
510 if (ReturnValue.isValid()) {
511 auto *RetAlloca = dyn_cast<llvm::AllocaInst>(ReturnValue.getPointer());
512 if (RetAlloca && RetAlloca->use_empty()) {
513 RetAlloca->eraseFromParent();
514 ReturnValue = Address::invalid();
515 }
516 }
517}
518
519/// ShouldInstrumentFunction - Return true if the current function should be
520/// instrumented with __cyg_profile_func_* calls
521bool CodeGenFunction::ShouldInstrumentFunction() {
522 if (!CGM.getCodeGenOpts().InstrumentFunctions &&
523 !CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
524 !CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
525 return false;
526 if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
527 return false;
528 return true;
529}
530
531/// ShouldXRayInstrument - Return true if the current function should be
532/// instrumented with XRay nop sleds.
533bool CodeGenFunction::ShouldXRayInstrumentFunction() const {
534 return CGM.getCodeGenOpts().XRayInstrumentFunctions;
535}
536
537/// AlwaysEmitXRayCustomEvents - Return true if we should emit IR for calls to
538/// the __xray_customevent(...) builtin calls, when doing XRay instrumentation.
539bool CodeGenFunction::AlwaysEmitXRayCustomEvents() const {
540 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
541 (CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
542 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
543 XRayInstrKind::Custom);
544}
545
546bool CodeGenFunction::AlwaysEmitXRayTypedEvents() const {
547 return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
548 (CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||
549 CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
550 XRayInstrKind::Typed);
551}
552
553llvm::Constant *
554CodeGenFunction::EncodeAddrForUseInPrologue(llvm::Function *F,
555 llvm::Constant *Addr) {
556 // Addresses stored in prologue data can't require run-time fixups and must
557 // be PC-relative. Run-time fixups are undesirable because they necessitate
558 // writable text segments, which are unsafe. And absolute addresses are
559 // undesirable because they break PIE mode.
560
561 // Add a layer of indirection through a private global. Taking its address
562 // won't result in a run-time fixup, even if Addr has linkonce_odr linkage.
563 auto *GV = new llvm::GlobalVariable(CGM.getModule(), Addr->getType(),
564 /*isConstant=*/true,
565 llvm::GlobalValue::PrivateLinkage, Addr);
566
567 // Create a PC-relative address.
568 auto *GOTAsInt = llvm::ConstantExpr::getPtrToInt(GV, IntPtrTy);
569 auto *FuncAsInt = llvm::ConstantExpr::getPtrToInt(F, IntPtrTy);
570 auto *PCRelAsInt = llvm::ConstantExpr::getSub(GOTAsInt, FuncAsInt);
571 return (IntPtrTy == Int32Ty)
572 ? PCRelAsInt
573 : llvm::ConstantExpr::getTrunc(PCRelAsInt, Int32Ty);
574}
575
576llvm::Value *
577CodeGenFunction::DecodeAddrUsedInPrologue(llvm::Value *F,
578 llvm::Value *EncodedAddr) {
579 // Reconstruct the address of the global.
580 auto *PCRelAsInt = Builder.CreateSExt(EncodedAddr, IntPtrTy);
581 auto *FuncAsInt = Builder.CreatePtrToInt(F, IntPtrTy, "func_addr.int");
582 auto *GOTAsInt = Builder.CreateAdd(PCRelAsInt, FuncAsInt, "global_addr.int");
583 auto *GOTAddr = Builder.CreateIntToPtr(GOTAsInt, Int8PtrPtrTy, "global_addr");
584
585 // Load the original pointer through the global.
586 return Builder.CreateLoad(Address(GOTAddr, getPointerAlign()),
587 "decoded_addr");
588}
589
590void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
591 llvm::Function *Fn)
592{
593 if (!FD->hasAttr<OpenCLKernelAttr>())
594 return;
595
596 llvm::LLVMContext &Context = getLLVMContext();
597
598 CGM.GenOpenCLArgMetadata(Fn, FD, this);
599
600 if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
601 QualType HintQTy = A->getTypeHint();
602 const ExtVectorType *HintEltQTy = HintQTy->getAs<ExtVectorType>();
603 bool IsSignedInteger =
604 HintQTy->isSignedIntegerType() ||
605 (HintEltQTy && HintEltQTy->getElementType()->isSignedIntegerType());
606 llvm::Metadata *AttrMDArgs[] = {
607 llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
608 CGM.getTypes().ConvertType(A->getTypeHint()))),
609 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
610 llvm::IntegerType::get(Context, 32),
611 llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
612 Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
613 }
614
615 if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
616 llvm::Metadata *AttrMDArgs[] = {
617 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
618 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
619 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
620 Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
621 }
622
623 if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
624 llvm::Metadata *AttrMDArgs[] = {
625 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
626 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
627 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
628 Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
629 }
630
631 if (const OpenCLIntelReqdSubGroupSizeAttr *A =
632 FD->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
633 llvm::Metadata *AttrMDArgs[] = {
634 llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
635 Fn->setMetadata("intel_reqd_sub_group_size",
636 llvm::MDNode::get(Context, AttrMDArgs));
637 }
638}
639
640/// Determine whether the function F ends with a return stmt.
641static bool endsWithReturn(const Decl* F) {
642 const Stmt *Body = nullptr;
643 if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))
644 Body = FD->getBody();
645 else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
646 Body = OMD->getBody();
647
648 if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
649 auto LastStmt = CS->body_rbegin();
650 if (LastStmt != CS->body_rend())
651 return isa<ReturnStmt>(*LastStmt);
652 }
653 return false;
654}
655
656void CodeGenFunction::markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn) {
657 if (SanOpts.has(SanitizerKind::Thread)) {
658 Fn->addFnAttr("sanitize_thread_no_checking_at_run_time");
659 Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
660 }
661}
662
663/// Check if the return value of this function requires sanitization.
664bool CodeGenFunction::requiresReturnValueCheck() const {
665 return requiresReturnValueNullabilityCheck() ||
666 (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) && CurCodeDecl &&
667 CurCodeDecl->getAttr<ReturnsNonNullAttr>());
668}
669
670static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx) {
671 auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
672 if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
673 !MD->getDeclName().getAsIdentifierInfo()->isStr("allocate") ||
674 (MD->getNumParams() != 1 && MD->getNumParams() != 2))
675 return false;
676
677 if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.getSizeType())
678 return false;
679
680 if (MD->getNumParams() == 2) {
681 auto *PT = MD->parameters()[1]->getType()->getAs<PointerType>();
682 if (!PT || !PT->isVoidPointerType() ||
683 !PT->getPointeeType().isConstQualified())
684 return false;
685 }
686
687 return true;
688}
689
690/// Return the UBSan prologue signature for \p FD if one is available.
691static llvm::Constant *getPrologueSignature(CodeGenModule &CGM,
692 const FunctionDecl *FD) {
693 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
694 if (!MD->isStatic())
695 return nullptr;
696 return CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM);
697}
698
699void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
700 llvm::Function *Fn,
701 const CGFunctionInfo &FnInfo,
702 const FunctionArgList &Args,
703 SourceLocation Loc,
704 SourceLocation StartLoc) {
705 assert(!CurFn &&
706 "Do not use a CodeGenFunction object for more than one function");
707
708 const Decl *D = GD.getDecl();
709
710 DidCallStackSave = false;
711 CurCodeDecl = D;
712 if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D))
713 if (FD->usesSEHTry())
714 CurSEHParent = FD;
715 CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
716 FnRetTy = RetTy;
717 CurFn = Fn;
718 CurFnInfo = &FnInfo;
719 assert(CurFn->isDeclaration() && "Function already has body?");
720
721 // If this function is ignored for any of the enabled sanitizers,
722 // disable the sanitizer for the function.
723 do {
724#define SANITIZER(NAME, ID) \
725 if (SanOpts.empty()) \
726 break; \
727 if (SanOpts.has(SanitizerKind::ID)) \
728 if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)) \
729 SanOpts.set(SanitizerKind::ID, false);
730
731#include "clang/Basic/Sanitizers.def"
732#undef SANITIZER
733 } while (0);
734
735 if (D) {
736 // Apply the no_sanitize* attributes to SanOpts.
737 for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) {
738 SanitizerMask mask = Attr->getMask();
739 SanOpts.Mask &= ~mask;
740 if (mask & SanitizerKind::Address)
741 SanOpts.set(SanitizerKind::KernelAddress, false);
742 if (mask & SanitizerKind::KernelAddress)
743 SanOpts.set(SanitizerKind::Address, false);
744 if (mask & SanitizerKind::HWAddress)
745 SanOpts.set(SanitizerKind::KernelHWAddress, false);
746 if (mask & SanitizerKind::KernelHWAddress)
747 SanOpts.set(SanitizerKind::HWAddress, false);
748 }
749 }
750
751 // Apply sanitizer attributes to the function.
752 if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
753 Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
754 if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
755 Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
756 if (SanOpts.has(SanitizerKind::MemTag))
757 Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
758 if (SanOpts.has(SanitizerKind::Thread))
759 Fn->addFnAttr(llvm::Attribute::SanitizeThread);
760 if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
761 Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
762 if (SanOpts.has(SanitizerKind::SafeStack))
763 Fn->addFnAttr(llvm::Attribute::SafeStack);
764 if (SanOpts.has(SanitizerKind::ShadowCallStack))
765 Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
766
767 // Apply fuzzing attribute to the function.
768 if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
769 Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
770
771 // Ignore TSan memory acesses from within ObjC/ObjC++ dealloc, initialize,
772 // .cxx_destruct, __destroy_helper_block_ and all of their calees at run time.
773 if (SanOpts.has(SanitizerKind::Thread)) {
774 if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
775 IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
776 if (OMD->getMethodFamily() == OMF_dealloc ||
777 OMD->getMethodFamily() == OMF_initialize ||
778 (OMD->getSelector().isUnarySelector() && II->isStr(".cxx_destruct"))) {
779 markAsIgnoreThreadCheckingAtRuntime(Fn);
780 }
781 }
782 }
783
784 // Ignore unrelated casts in STL allocate() since the allocator must cast
785 // from void* to T* before object initialization completes. Don't match on the
786 // namespace because not all allocators are in std::
787 if (D && SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
788 if (matchesStlAllocatorFn(D, getContext()))
789 SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;
790 }
791
792 // Ignore null checks in coroutine functions since the coroutines passes
793 // are not aware of how to move the extra UBSan instructions across the split
794 // coroutine boundaries.
795 if (D && SanOpts.has(SanitizerKind::Null))
796 if (const auto *FD = dyn_cast<FunctionDecl>(D))
797 if (FD->getBody() &&
798 FD->getBody()->getStmtClass() == Stmt::CoroutineBodyStmtClass)
799 SanOpts.Mask &= ~SanitizerKind::Null;
800
801 // Apply xray attributes to the function (as a string, for now)
802 bool AlwaysXRayAttr = false;
803 if (const auto *XRayAttr = D ? D->getAttr<XRayInstrumentAttr>() : nullptr) {
804 if (CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
805 XRayInstrKind::FunctionEntry) ||
806 CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
807 XRayInstrKind::FunctionExit)) {
808 if (XRayAttr->alwaysXRayInstrument() && ShouldXRayInstrumentFunction()) {
809 Fn->addFnAttr("function-instrument", "xray-always");
810 AlwaysXRayAttr = true;
811 }
812 if (XRayAttr->neverXRayInstrument())
813 Fn->addFnAttr("function-instrument", "xray-never");
814 if (const auto *LogArgs = D->getAttr<XRayLogArgsAttr>())
815 if (ShouldXRayInstrumentFunction())
816 Fn->addFnAttr("xray-log-args",
817 llvm::utostr(LogArgs->getArgumentCount()));
818 }
819 } else {
820 if (ShouldXRayInstrumentFunction() && !CGM.imbueXRayAttrs(Fn, Loc))
821 Fn->addFnAttr(
822 "xray-instruction-threshold",
823 llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));
824 }
825
826 if (ShouldXRayInstrumentFunction()) {
827 if (CGM.getCodeGenOpts().XRayIgnoreLoops)
828 Fn->addFnAttr("xray-ignore-loops");
829
830 if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
831 XRayInstrKind::FunctionExit))
832 Fn->addFnAttr("xray-skip-exit");
833
834 if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
835 XRayInstrKind::FunctionEntry))
836 Fn->addFnAttr("xray-skip-entry");
837
838 auto FuncGroups = CGM.getCodeGenOpts().XRayTotalFunctionGroups;
839 if (FuncGroups > 1) {
840 auto FuncName = llvm::makeArrayRef<uint8_t>(
841 CurFn->getName().bytes_begin(), CurFn->getName().bytes_end());
842 auto Group = crc32(FuncName) % FuncGroups;
843 if (Group != CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&
844 !AlwaysXRayAttr)
845 Fn->addFnAttr("function-instrument", "xray-never");
846 }
847 }
848
849 if (CGM.getCodeGenOpts().getProfileInstr() != CodeGenOptions::ProfileNone)
850 if (CGM.isProfileInstrExcluded(Fn, Loc))
851 Fn->addFnAttr(llvm::Attribute::NoProfile);
852
853 unsigned Count, Offset;
854 if (const auto *Attr =
855 D ? D->getAttr<PatchableFunctionEntryAttr>() : nullptr) {
856 Count = Attr->getCount();
857 Offset = Attr->getOffset();
858 } else {
859 Count = CGM.getCodeGenOpts().PatchableFunctionEntryCount;
860 Offset = CGM.getCodeGenOpts().PatchableFunctionEntryOffset;
861 }
862 if (Count && Offset <= Count) {
863 Fn->addFnAttr("patchable-function-entry", std::to_string(Count - Offset));
864 if (Offset)
865 Fn->addFnAttr("patchable-function-prefix", std::to_string(Offset));
866 }
867
868 // Add no-jump-tables value.
869 if (CGM.getCodeGenOpts().NoUseJumpTables)
870 Fn->addFnAttr("no-jump-tables", "true");
871
872 // Add no-inline-line-tables value.
873 if (CGM.getCodeGenOpts().NoInlineLineTables)
874 Fn->addFnAttr("no-inline-line-tables");
875
876 // Add profile-sample-accurate value.
877 if (CGM.getCodeGenOpts().ProfileSampleAccurate)
878 Fn->addFnAttr("profile-sample-accurate");
879
880 if (!CGM.getCodeGenOpts().SampleProfileFile.empty())
881 Fn->addFnAttr("use-sample-profile");
882
883 if (D && D->hasAttr<CFICanonicalJumpTableAttr>())
884 Fn->addFnAttr("cfi-canonical-jump-table");
885
886 if (getLangOpts().OpenCL) {
887 // Add metadata for a kernel function.
888 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
889 EmitOpenCLKernelMetadata(FD, Fn);
890 }
891
892 // If we are checking function types, emit a function type signature as
893 // prologue data.
894 if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function)) {
895 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
896 if (llvm::Constant *PrologueSig = getPrologueSignature(CGM, FD)) {
897 // Remove any (C++17) exception specifications, to allow calling e.g. a
898 // noexcept function through a non-noexcept pointer.
899 auto ProtoTy =
900 getContext().getFunctionTypeWithExceptionSpec(FD->getType(),
901 EST_None);
902 llvm::Constant *FTRTTIConst =
903 CGM.GetAddrOfRTTIDescriptor(ProtoTy, /*ForEH=*/true);
904 llvm::Constant *FTRTTIConstEncoded =
905 EncodeAddrForUseInPrologue(Fn, FTRTTIConst);
906 llvm::Constant *PrologueStructElems[] = {PrologueSig,
907 FTRTTIConstEncoded};
908 llvm::Constant *PrologueStructConst =
909 llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);
910 Fn->setPrologueData(PrologueStructConst);
911 }
912 }
913 }
914
915 // If we're checking nullability, we need to know whether we can check the
916 // return value. Initialize the flag to 'true' and refine it in EmitParmDecl.
917 if (SanOpts.has(SanitizerKind::NullabilityReturn)) {
918 auto Nullability = FnRetTy->getNullability(getContext());
919 if (Nullability && *Nullability == NullabilityKind::NonNull) {
920 if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
921 CurCodeDecl && CurCodeDecl->getAttr<ReturnsNonNullAttr>()))
922 RetValNullabilityPrecondition =
923 llvm::ConstantInt::getTrue(getLLVMContext());
924 }
925 }
926
927 // If we're in C++ mode and the function name is "main", it is guaranteed
928 // to be norecurse by the standard (3.6.1.3 "The function main shall not be
929 // used within a program").
930 //
931 // OpenCL C 2.0 v2.2-11 s6.9.i:
932 // Recursion is not supported.
933 //
934 // SYCL v1.2.1 s3.10:
935 // kernels cannot include RTTI information, exception classes,
936 // recursive code, virtual functions or make use of C++ libraries that
937 // are not compiled for the device.
938 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
939 if ((getLangOpts().CPlusPlus && FD->isMain()) || getLangOpts().OpenCL ||
940 getLangOpts().SYCLIsDevice ||
941 (getLangOpts().CUDA && FD->hasAttr<CUDAGlobalAttr>()))
942 Fn->addFnAttr(llvm::Attribute::NoRecurse);
943 }
944
945 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
946 Builder.setIsFPConstrained(FD->hasAttr<StrictFPAttr>());
947 if (FD->hasAttr<StrictFPAttr>())
948 Fn->addFnAttr(llvm::Attribute::StrictFP);
949 }
950
951 // If a custom alignment is used, force realigning to this alignment on
952 // any main function which certainly will need it.
953 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
954 if ((FD->isMain() || FD->isMSVCRTEntryPoint()) &&
955 CGM.getCodeGenOpts().StackAlignment)
956 Fn->addFnAttr("stackrealign");
957
958 llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
959
960 // Create a marker to make it easy to insert allocas into the entryblock
961 // later. Don't create this with the builder, because we don't want it
962 // folded.
963 llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
964 AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "allocapt", EntryBB);
965
966 ReturnBlock = getJumpDestInCurrentScope("return");
967
968 Builder.SetInsertPoint(EntryBB);
969
970 // If we're checking the return value, allocate space for a pointer to a
971 // precise source location of the checked return statement.
972 if (requiresReturnValueCheck()) {
973 ReturnLocation = CreateDefaultAlignTempAlloca(Int8PtrTy, "return.sloc.ptr");
974 InitTempAlloca(ReturnLocation, llvm::ConstantPointerNull::get(Int8PtrTy));
975 }
976
977 // Emit subprogram debug descriptor.
978 if (CGDebugInfo *DI = getDebugInfo()) {
979 // Reconstruct the type from the argument list so that implicit parameters,
980 // such as 'this' and 'vtt', show up in the debug info. Preserve the calling
981 // convention.
982 CallingConv CC = CallingConv::CC_C;
983 if (auto *FD = dyn_cast_or_null<FunctionDecl>(D))
984 if (const auto *SrcFnTy = FD->getType()->getAs<FunctionType>())
985 CC = SrcFnTy->getCallConv();
986 SmallVector<QualType, 16> ArgTypes;
987 for (const VarDecl *VD : Args)
988 ArgTypes.push_back(VD->getType());
989 QualType FnType = getContext().getFunctionType(
990 RetTy, ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
991 DI->emitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, CurFuncIsThunk);
992 }
993
994 if (ShouldInstrumentFunction()) {
995 if (CGM.getCodeGenOpts().InstrumentFunctions)
996 CurFn->addFnAttr("instrument-function-entry", "__cyg_profile_func_enter");
997 if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
998 CurFn->addFnAttr("instrument-function-entry-inlined",
999 "__cyg_profile_func_enter");
1000 if (CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
1001 CurFn->addFnAttr("instrument-function-entry-inlined",
1002 "__cyg_profile_func_enter_bare");
1003 }
1004
1005 // Since emitting the mcount call here impacts optimizations such as function
1006 // inlining, we just add an attribute to insert a mcount call in backend.
1007 // The attribute "counting-function" is set to mcount function name which is
1008 // architecture dependent.
1009 if (CGM.getCodeGenOpts().InstrumentForProfiling) {
1010 // Calls to fentry/mcount should not be generated if function has
1011 // the no_instrument_function attribute.
1012 if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {
1013 if (CGM.getCodeGenOpts().CallFEntry)
1014 Fn->addFnAttr("fentry-call", "true");
1015 else {
1016 Fn->addFnAttr("instrument-function-entry-inlined",
1017 getTarget().getMCountName());
1018 }
1019 if (CGM.getCodeGenOpts().MNopMCount) {
1020 if (!CGM.getCodeGenOpts().CallFEntry)
1021 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1022 << "-mnop-mcount" << "-mfentry";
1023 Fn->addFnAttr("mnop-mcount");
1024 }
1025
1026 if (CGM.getCodeGenOpts().RecordMCount) {
1027 if (!CGM.getCodeGenOpts().CallFEntry)
1028 CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1029 << "-mrecord-mcount" << "-mfentry";
1030 Fn->addFnAttr("mrecord-mcount");
1031 }
1032 }
1033 }
1034
1035 if (CGM.getCodeGenOpts().PackedStack) {
1036 if (getContext().getTargetInfo().getTriple().getArch() !=
1037 llvm::Triple::systemz)
1038 CGM.getDiags().Report(diag::err_opt_not_valid_on_target)
1039 << "-mpacked-stack";
1040 Fn->addFnAttr("packed-stack");
1041 }
1042
1043 if (RetTy->isVoidType()) {
1044 // Void type; nothing to return.
1045 ReturnValue = Address::invalid();
1046
1047 // Count the implicit return.
1048 if (!endsWithReturn(D))
1049 ++NumReturnExprs;
1050 } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect) {
1051 // Indirect return; emit returned value directly into sret slot.
1052 // This reduces code size, and affects correctness in C++.
1053 auto AI = CurFn->arg_begin();
1054 if (CurFnInfo->getReturnInfo().isSRetAfterThis())
1055 ++AI;
1056 ReturnValue = Address(&*AI, CurFnInfo->getReturnInfo().getIndirectAlign());
1057 if (!CurFnInfo->getReturnInfo().getIndirectByVal()) {
1058 ReturnValuePointer =
1059 CreateDefaultAlignTempAlloca(Int8PtrTy, "result.ptr");
1060 Builder.CreateStore(Builder.CreatePointerBitCastOrAddrSpaceCast(
1061 ReturnValue.getPointer(), Int8PtrTy),
1062 ReturnValuePointer);
1063 }
1064 } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::InAlloca &&
1065 !hasScalarEvaluationKind(CurFnInfo->getReturnType())) {
1066 // Load the sret pointer from the argument struct and return into that.
1067 unsigned Idx = CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
1068 llvm::Function::arg_iterator EI = CurFn->arg_end();
1069 --EI;
1070 llvm::Value *Addr = Builder.CreateStructGEP(nullptr, &*EI, Idx);
1071 llvm::Type *Ty =
1072 cast<llvm::GetElementPtrInst>(Addr)->getResultElementType();
1073 ReturnValuePointer = Address(Addr, getPointerAlign());
1074 Addr = Builder.CreateAlignedLoad(Ty, Addr, getPointerAlign(), "agg.result");
1075 ReturnValue = Address(Addr, CGM.getNaturalTypeAlignment(RetTy));
1076 } else {
1077 ReturnValue = CreateIRTemp(RetTy, "retval");
1078
1079 // Tell the epilog emitter to autorelease the result. We do this
1080 // now so that various specialized functions can suppress it
1081 // during their IR-generation.
1082 if (getLangOpts().ObjCAutoRefCount &&
1083 !CurFnInfo->isReturnsRetained() &&
1084 RetTy->isObjCRetainableType())
1085 AutoreleaseResult = true;
1086 }
1087
1088 EmitStartEHSpec(CurCodeDecl);
1089
1090 PrologueCleanupDepth = EHStack.stable_begin();
1091
1092 // Emit OpenMP specific initialization of the device functions.
1093 if (getLangOpts().OpenMP && CurCodeDecl)
1094 CGM.getOpenMPRuntime().emitFunctionProlog(*this, CurCodeDecl);
1095
1096 EmitFunctionProlog(*CurFnInfo, CurFn, Args);
1097
1098 if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
1099 CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
1100 const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
1101 if (MD->getParent()->isLambda() &&
1102 MD->getOverloadedOperator() == OO_Call) {
1103 // We're in a lambda; figure out the captures.
1104 MD->getParent()->getCaptureFields(LambdaCaptureFields,
1105 LambdaThisCaptureField);
1106 if (LambdaThisCaptureField) {
1107 // If the lambda captures the object referred to by '*this' - either by
1108 // value or by reference, make sure CXXThisValue points to the correct
1109 // object.
1110
1111 // Get the lvalue for the field (which is a copy of the enclosing object
1112 // or contains the address of the enclosing object).
1113 LValue ThisFieldLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
1114 if (!LambdaThisCaptureField->getType()->isPointerType()) {
1115 // If the enclosing object was captured by value, just use its address.
1116 CXXThisValue = ThisFieldLValue.getAddress(*this).getPointer();
1117 } else {
1118 // Load the lvalue pointed to by the field, since '*this' was captured
1119 // by reference.
1120 CXXThisValue =
1121 EmitLoadOfLValue(ThisFieldLValue, SourceLocation()).getScalarVal();
1122 }
1123 }
1124 for (auto *FD : MD->getParent()->fields()) {
1125 if (FD->hasCapturedVLAType()) {
1126 auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
1127 SourceLocation()).getScalarVal();
1128 auto VAT = FD->getCapturedVLAType();
1129 VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1130 }
1131 }
1132 } else {
1133 // Not in a lambda; just use 'this' from the method.
1134 // FIXME: Should we generate a new load for each use of 'this'? The
1135 // fast register allocator would be happier...
1136 CXXThisValue = CXXABIThisValue;
1137 }
1138
1139 // Check the 'this' pointer once per function, if it's available.
1140 if (CXXABIThisValue) {
1141 SanitizerSet SkippedChecks;
1142 SkippedChecks.set(SanitizerKind::ObjectSize, true);
1143 QualType ThisTy = MD->getThisType();
1144
1145 // If this is the call operator of a lambda with no capture-default, it
1146 // may have a static invoker function, which may call this operator with
1147 // a null 'this' pointer.
1148 if (isLambdaCallOperator(MD) &&
1149 MD->getParent()->getLambdaCaptureDefault() == LCD_None)
1150 SkippedChecks.set(SanitizerKind::Null, true);
1151
1152 EmitTypeCheck(
1153 isa<CXXConstructorDecl>(MD) ? TCK_ConstructorCall : TCK_MemberCall,
1154 Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1155 }
1156 }
1157
1158 // If any of the arguments have a variably modified type, make sure to
1159 // emit the type size.
1160 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1161 i != e; ++i) {
1162 const VarDecl *VD = *i;
1163
1164 // Dig out the type as written from ParmVarDecls; it's unclear whether
1165 // the standard (C99 6.9.1p10) requires this, but we're following the
1166 // precedent set by gcc.
1167 QualType Ty;
1168 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1169 Ty = PVD->getOriginalType();
1170 else
1171 Ty = VD->getType();
1172
1173 if (Ty->isVariablyModifiedType())
1174 EmitVariablyModifiedType(Ty);
1175 }
1176 // Emit a location at the end of the prologue.
1177 if (CGDebugInfo *DI = getDebugInfo())
1178 DI->EmitLocation(Builder, StartLoc);
1179
1180 // TODO: Do we need to handle this in two places like we do with
1181 // target-features/target-cpu?
1182 if (CurFuncDecl)
1183 if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
1184 LargestVectorWidth = VecWidth->getVectorWidth();
1185}
1186
1187void CodeGenFunction::EmitFunctionBody(const Stmt *Body) {
1188 incrementProfileCounter(Body);
1189 if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1190 EmitCompoundStmtWithoutScope(*S);
1191 else
1192 EmitStmt(Body);
1193
1194 // This is checked after emitting the function body so we know if there
1195 // are any permitted infinite loops.
1196 if (checkIfFunctionMustProgress())
1197 CurFn->addFnAttr(llvm::Attribute::MustProgress);
1198}
1199
1200/// When instrumenting to collect profile data, the counts for some blocks
1201/// such as switch cases need to not include the fall-through counts, so
1202/// emit a branch around the instrumentation code. When not instrumenting,
1203/// this just calls EmitBlock().
1204void CodeGenFunction::EmitBlockWithFallThrough(llvm::BasicBlock *BB,
1205 const Stmt *S) {
1206 llvm::BasicBlock *SkipCountBB = nullptr;
1207 if (HaveInsertPoint() && CGM.getCodeGenOpts().hasProfileClangInstr()) {
1208 // When instrumenting for profiling, the fallthrough to certain
1209 // statements needs to skip over the instrumentation code so that we
1210 // get an accurate count.
1211 SkipCountBB = createBasicBlock("skipcount");
1212 EmitBranch(SkipCountBB);
1213 }
1214 EmitBlock(BB);
1215 uint64_t CurrentCount = getCurrentProfileCount();
1216 incrementProfileCounter(S);
1217 setCurrentProfileCount(getCurrentProfileCount() + CurrentCount);
1218 if (SkipCountBB)
1219 EmitBlock(SkipCountBB);
1220}
1221
1222/// Tries to mark the given function nounwind based on the
1223/// non-existence of any throwing calls within it. We believe this is
1224/// lightweight enough to do at -O0.
1225static void TryMarkNoThrow(llvm::Function *F) {
1226 // LLVM treats 'nounwind' on a function as part of the type, so we
1227 // can't do this on functions that can be overwritten.
1228 if (F->isInterposable()) return;
1229
1230 for (llvm::BasicBlock &BB : *F)
1231 for (llvm::Instruction &I : BB)
1232 if (I.mayThrow())
1233 return;
1234
1235 F->setDoesNotThrow();
1236}
1237
1238QualType CodeGenFunction::BuildFunctionArgList(GlobalDecl GD,
1239 FunctionArgList &Args) {
1240 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1241 QualType ResTy = FD->getReturnType();
1242
1243 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
1244 if (MD && MD->isInstance()) {
1245 if (CGM.getCXXABI().HasThisReturn(GD))
1246 ResTy = MD->getThisType();
1247 else if (CGM.getCXXABI().hasMostDerivedReturn(GD))
1248 ResTy = CGM.getContext().VoidPtrTy;
1249 CGM.getCXXABI().buildThisParam(*this, Args);
1250 }
1251
1252 // The base version of an inheriting constructor whose constructed base is a
1253 // virtual base is not passed any arguments (because it doesn't actually call
1254 // the inherited constructor).
1255 bool PassedParams = true;
1256 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
1257 if (auto Inherited = CD->getInheritedConstructor())
1258 PassedParams =
1259 getTypes().inheritingCtorHasParams(Inherited, GD.getCtorType());
1260
1261 if (PassedParams) {
1262 for (auto *Param : FD->parameters()) {
1263 Args.push_back(Param);
1264 if (!Param->hasAttr<PassObjectSizeAttr>())
1265 continue;
1266
1267 auto *Implicit = ImplicitParamDecl::Create(
1268 getContext(), Param->getDeclContext(), Param->getLocation(),
1269 /*Id=*/nullptr, getContext().getSizeType(), ImplicitParamDecl::Other);
1270 SizeArguments[Param] = Implicit;
1271 Args.push_back(Implicit);
1272 }
1273 }
1274
1275 if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
1276 CGM.getCXXABI().addImplicitStructorParams(*this, ResTy, Args);
1277
1278 return ResTy;
1279}
1280
1281void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1282 const CGFunctionInfo &FnInfo) {
1283 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1284 CurGD = GD;
1285
1286 FunctionArgList Args;
1287 QualType ResTy = BuildFunctionArgList(GD, Args);
1288
1289 // Check if we should generate debug info for this function.
1290 if (FD->hasAttr<NoDebugAttr>())
1291 DebugInfo = nullptr; // disable debug info indefinitely for this function
1292
1293 // The function might not have a body if we're generating thunks for a
1294 // function declaration.
1295 SourceRange BodyRange;
1296 if (Stmt *Body = FD->getBody())
1297 BodyRange = Body->getSourceRange();
1298 else
1299 BodyRange = FD->getLocation();
1300 CurEHLocation = BodyRange.getEnd();
1301
1302 // Use the location of the start of the function to determine where
1303 // the function definition is located. By default use the location
1304 // of the declaration as the location for the subprogram. A function
1305 // may lack a declaration in the source code if it is created by code
1306 // gen. (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk).
1307 SourceLocation Loc = FD->getLocation();
1308
1309 // If this is a function specialization then use the pattern body
1310 // as the location for the function.
1311 if (const FunctionDecl *SpecDecl = FD->getTemplateInstantiationPattern())
1312 if (SpecDecl->hasBody(SpecDecl))
1313 Loc = SpecDecl->getLocation();
1314
1315 Stmt *Body = FD->getBody();
1316
1317 if (Body) {
1318 // Coroutines always emit lifetime markers.
1319 if (isa<CoroutineBodyStmt>(Body))
1320 ShouldEmitLifetimeMarkers = true;
1321
1322 // Initialize helper which will detect jumps which can cause invalid
1323 // lifetime markers.
1324 if (ShouldEmitLifetimeMarkers)
1325 Bypasses.Init(Body);
1326 }
1327
1328 // Emit the standard function prologue.
1329 StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1330
1331 // Save parameters for coroutine function.
1332 if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1333 for (const auto *ParamDecl : FD->parameters())
1334 FnArgs.push_back(ParamDecl);
1335
1336 // Generate the body of the function.
1337 PGO.assignRegionCounters(GD, CurFn);
1338 if (isa<CXXDestructorDecl>(FD))
1339 EmitDestructorBody(Args);
1340 else if (isa<CXXConstructorDecl>(FD))
1341 EmitConstructorBody(Args);
1342 else if (getLangOpts().CUDA &&
1343 !getLangOpts().CUDAIsDevice &&
1344 FD->hasAttr<CUDAGlobalAttr>())
1345 CGM.getCUDARuntime().emitDeviceStub(*this, Args);
1346 else if (isa<CXXMethodDecl>(FD) &&
1347 cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
1348 // The lambda static invoker function is special, because it forwards or
1349 // clones the body of the function call operator (but is actually static).
1350 EmitLambdaStaticInvokeBody(cast<CXXMethodDecl>(FD));
1351 } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
1352 (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
1353 cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
1354 // Implicit copy-assignment gets the same special treatment as implicit
1355 // copy-constructors.
1356 emitImplicitAssignmentOperatorBody(Args);
1357 } else if (Body) {
1358 EmitFunctionBody(Body);
1359 } else
1360 llvm_unreachable("no definition for emitted function");
1361
1362 // C++11 [stmt.return]p2:
1363 // Flowing off the end of a function [...] results in undefined behavior in
1364 // a value-returning function.
1365 // C11 6.9.1p12:
1366 // If the '}' that terminates a function is reached, and the value of the
1367 // function call is used by the caller, the behavior is undefined.
1368 if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && !SawAsmBlock &&
1369 !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1370 bool ShouldEmitUnreachable =
1371 CGM.getCodeGenOpts().StrictReturn ||
1372 !CGM.MayDropFunctionReturn(FD->getASTContext(), FD->getReturnType());
1373 if (SanOpts.has(SanitizerKind::Return)) {
1374 SanitizerScope SanScope(this);
1375 llvm::Value *IsFalse = Builder.getFalse();
1376 EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1377 SanitizerHandler::MissingReturn,
1378 EmitCheckSourceLocation(FD->getLocation()), None);
1379 } else if (ShouldEmitUnreachable) {
1380 if (CGM.getCodeGenOpts().OptimizationLevel == 0)
1381 EmitTrapCall(llvm::Intrinsic::trap);
1382 }
1383 if (SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1384 Builder.CreateUnreachable();
1385 Builder.ClearInsertionPoint();
1386 }
1387 }
1388
1389 // Emit the standard function epilogue.
1390 FinishFunction(BodyRange.getEnd());
1391
1392 // If we haven't marked the function nothrow through other means, do
1393 // a quick pass now to see if we can.
1394 if (!CurFn->doesNotThrow())
1395 TryMarkNoThrow(CurFn);
1396}
1397
1398/// ContainsLabel - Return true if the statement contains a label in it. If
1399/// this statement is not executed normally, it not containing a label means
1400/// that we can just remove the code.
1401bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1402 // Null statement, not a label!
1403 if (!S) return false;
1404
1405 // If this is a label, we have to emit the code, consider something like:
1406 // if (0) { ... foo: bar(); } goto foo;
1407 //
1408 // TODO: If anyone cared, we could track __label__'s, since we know that you
1409 // can't jump to one from outside their declared region.
1410 if (isa<LabelStmt>(S))
1411 return true;
1412
1413 // If this is a case/default statement, and we haven't seen a switch, we have
1414 // to emit the code.
1415 if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1416 return true;
1417
1418 // If this is a switch statement, we want to ignore cases below it.
1419 if (isa<SwitchStmt>(S))
1420 IgnoreCaseStmts = true;
1421
1422 // Scan subexpressions for verboten labels.
1423 for (const Stmt *SubStmt : S->children())
1424 if (ContainsLabel(SubStmt, IgnoreCaseStmts))
1425 return true;
1426
1427 return false;
1428}
1429
1430/// containsBreak - Return true if the statement contains a break out of it.
1431/// If the statement (recursively) contains a switch or loop with a break
1432/// inside of it, this is fine.
1433bool CodeGenFunction::containsBreak(const Stmt *S) {
1434 // Null statement, not a label!
1435 if (!S) return false;
1436
1437 // If this is a switch or loop that defines its own break scope, then we can
1438 // include it and anything inside of it.
1439 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1440 isa<ForStmt>(S))
1441 return false;
1442
1443 if (isa<BreakStmt>(S))
1444 return true;
1445
1446 // Scan subexpressions for verboten breaks.
1447 for (const Stmt *SubStmt : S->children())
1448 if (containsBreak(SubStmt))
1449 return true;
1450
1451 return false;
1452}
1453
1454bool CodeGenFunction::mightAddDeclToScope(const Stmt *S) {
1455 if (!S) return false;
1456
1457 // Some statement kinds add a scope and thus never add a decl to the current
1458 // scope. Note, this list is longer than the list of statements that might
1459 // have an unscoped decl nested within them, but this way is conservatively
1460 // correct even if more statement kinds are added.
1461 if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
1462 isa<DoStmt>(S) || isa<ForStmt>(S) || isa<CompoundStmt>(S) ||
1463 isa<CXXForRangeStmt>(S) || isa<CXXTryStmt>(S) ||
1464 isa<ObjCForCollectionStmt>(S) || isa<ObjCAtTryStmt>(S))
1465 return false;
1466
1467 if (isa<DeclStmt>(S))
1468 return true;
1469
1470 for (const Stmt *SubStmt : S->children())
1471 if (mightAddDeclToScope(SubStmt))
1472 return true;
1473
1474 return false;
1475}
1476
1477/// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1478/// to a constant, or if it does but contains a label, return false. If it
1479/// constant folds return true and set the boolean result in Result.
1480bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1481 bool &ResultBool,
1482 bool AllowLabels) {
1483 llvm::APSInt ResultInt;
1484 if (!ConstantFoldsToSimpleInteger(Cond, ResultInt, AllowLabels))
1485 return false;
1486
1487 ResultBool = ResultInt.getBoolValue();
1488 return true;
1489}
1490
1491/// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1492/// to a constant, or if it does but contains a label, return false. If it
1493/// constant folds return true and set the folded value.
1494bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1495 llvm::APSInt &ResultInt,
1496 bool AllowLabels) {
1497 // FIXME: Rename and handle conversion of other evaluatable things
1498 // to bool.
1499 Expr::EvalResult Result;
1500 if (!Cond->EvaluateAsInt(Result, getContext()))
1501 return false; // Not foldable, not integer or not fully evaluatable.
1502
1503 llvm::APSInt Int = Result.Val.getInt();
1504 if (!AllowLabels && CodeGenFunction::ContainsLabel(Cond))
1505 return false; // Contains a label.
1506
1507 ResultInt = Int;
1508 return true;
1509}
1510
1511/// Determine whether the given condition is an instrumentable condition
1512/// (i.e. no "&&" or "||").
1513bool CodeGenFunction::isInstrumentedCondition(const Expr *C) {
1514 // Bypass simplistic logical-NOT operator before determining whether the
1515 // condition contains any other logical operator.
1516 if (const UnaryOperator *UnOp = dyn_cast<UnaryOperator>(C->IgnoreParens()))
1517 if (UnOp->getOpcode() == UO_LNot)
1518 C = UnOp->getSubExpr();
1519
1520 const BinaryOperator *BOp = dyn_cast<BinaryOperator>(C->IgnoreParens());
1521 return (!BOp || !BOp->isLogicalOp());
1522}
1523
1524/// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
1525/// increments a profile counter based on the semantics of the given logical
1526/// operator opcode. This is used to instrument branch condition coverage for
1527/// logical operators.
1528void CodeGenFunction::EmitBranchToCounterBlock(
1529 const Expr *Cond, BinaryOperator::Opcode LOp, llvm::BasicBlock *TrueBlock,
1530 llvm::BasicBlock *FalseBlock, uint64_t TrueCount /* = 0 */,
1531 Stmt::Likelihood LH /* =None */, const Expr *CntrIdx /* = nullptr */) {
1532 // If not instrumenting, just emit a branch.
1533 bool InstrumentRegions = CGM.getCodeGenOpts().hasProfileClangInstr();
1534 if (!InstrumentRegions || !isInstrumentedCondition(Cond))
1535 return EmitBranchOnBoolExpr(Cond, TrueBlock, FalseBlock, TrueCount, LH);
1536
1537 llvm::BasicBlock *ThenBlock = NULL;
1538 llvm::BasicBlock *ElseBlock = NULL;
1539 llvm::BasicBlock *NextBlock = NULL;
1540
1541 // Create the block we'll use to increment the appropriate counter.
1542 llvm::BasicBlock *CounterIncrBlock = createBasicBlock("lop.rhscnt");
1543
1544 // Set block pointers according to Logical-AND (BO_LAnd) semantics. This
1545 // means we need to evaluate the condition and increment the counter on TRUE:
1546 //
1547 // if (Cond)
1548 // goto CounterIncrBlock;
1549 // else
1550 // goto FalseBlock;
1551 //
1552 // CounterIncrBlock:
1553 // Counter++;
1554 // goto TrueBlock;
1555
1556 if (LOp == BO_LAnd) {
1557 ThenBlock = CounterIncrBlock;
1558 ElseBlock = FalseBlock;
1559 NextBlock = TrueBlock;
1560 }
1561
1562 // Set block pointers according to Logical-OR (BO_LOr) semantics. This means
1563 // we need to evaluate the condition and increment the counter on FALSE:
1564 //
1565 // if (Cond)
1566 // goto TrueBlock;
1567 // else
1568 // goto CounterIncrBlock;
1569 //
1570 // CounterIncrBlock:
1571 // Counter++;
1572 // goto FalseBlock;
1573
1574 else if (LOp == BO_LOr) {
1575 ThenBlock = TrueBlock;
1576 ElseBlock = CounterIncrBlock;
1577 NextBlock = FalseBlock;
1578 } else {
1579 llvm_unreachable("Expected Opcode must be that of a Logical Operator");
1580 }
1581
1582 // Emit Branch based on condition.
1583 EmitBranchOnBoolExpr(Cond, ThenBlock, ElseBlock, TrueCount, LH);
1584
1585 // Emit the block containing the counter increment(s).
1586 EmitBlock(CounterIncrBlock);
1587
1588 // Increment corresponding counter; if index not provided, use Cond as index.
1589 incrementProfileCounter(CntrIdx ? CntrIdx : Cond);
1590
1591 // Go to the next block.
1592 EmitBranch(NextBlock);
1593}
1594
1595/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
1596/// statement) to the specified blocks. Based on the condition, this might try
1597/// to simplify the codegen of the conditional based on the branch.
1598/// \param LH The value of the likelihood attribute on the True branch.
1599void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
1600 llvm::BasicBlock *TrueBlock,
1601 llvm::BasicBlock *FalseBlock,
1602 uint64_t TrueCount,
1603 Stmt::Likelihood LH) {
1604 Cond = Cond->IgnoreParens();
1605
1606 if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1607
1608 // Handle X && Y in a condition.
1609 if (CondBOp->getOpcode() == BO_LAnd) {
1610 // If we have "1 && X", simplify the code. "0 && X" would have constant
1611 // folded if the case was simple enough.
1612 bool ConstantBool = false;
1613 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1614 ConstantBool) {
1615 // br(1 && X) -> br(X).
1616 incrementProfileCounter(CondBOp);
1617 return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
1618 FalseBlock, TrueCount, LH);
1619 }
1620
1621 // If we have "X && 1", simplify the code to use an uncond branch.
1622 // "X && 0" would have been constant folded to 0.
1623 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1624 ConstantBool) {
1625 // br(X && 1) -> br(X).
1626 return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LAnd, TrueBlock,
1627 FalseBlock, TrueCount, LH, CondBOp);
1628 }
1629
1630 // Emit the LHS as a conditional. If the LHS conditional is false, we
1631 // want to jump to the FalseBlock.
1632 llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
1633 // The counter tells us how often we evaluate RHS, and all of TrueCount
1634 // can be propagated to that branch.
1635 uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
1636
1637 ConditionalEvaluation eval(*this);
1638 {
1639 ApplyDebugLocation DL(*this, Cond);
1640 // Propagate the likelihood attribute like __builtin_expect
1641 // __builtin_expect(X && Y, 1) -> X and Y are likely
1642 // __builtin_expect(X && Y, 0) -> only Y is unlikely
1643 EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount,
1644 LH == Stmt::LH_Unlikely ? Stmt::LH_None : LH);
1645 EmitBlock(LHSTrue);
1646 }
1647
1648 incrementProfileCounter(CondBOp);
1649 setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1650
1651 // Any temporaries created here are conditional.
1652 eval.begin(*this);
1653 EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
1654 FalseBlock, TrueCount, LH);
1655 eval.end(*this);
1656
1657 return;
1658 }
1659
1660 if (CondBOp->getOpcode() == BO_LOr) {
1661 // If we have "0 || X", simplify the code. "1 || X" would have constant
1662 // folded if the case was simple enough.
1663 bool ConstantBool = false;
1664 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1665 !ConstantBool) {
1666 // br(0 || X) -> br(X).
1667 incrementProfileCounter(CondBOp);
1668 return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock,
1669 FalseBlock, TrueCount, LH);
1670 }
1671
1672 // If we have "X || 0", simplify the code to use an uncond branch.
1673 // "X || 1" would have been constant folded to 1.
1674 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1675 !ConstantBool) {
1676 // br(X || 0) -> br(X).
1677 return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LOr, TrueBlock,
1678 FalseBlock, TrueCount, LH, CondBOp);
1679 }
1680
1681 // Emit the LHS as a conditional. If the LHS conditional is true, we
1682 // want to jump to the TrueBlock.
1683 llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
1684 // We have the count for entry to the RHS and for the whole expression
1685 // being true, so we can divy up True count between the short circuit and
1686 // the RHS.
1687 uint64_t LHSCount =
1688 getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
1689 uint64_t RHSCount = TrueCount - LHSCount;
1690
1691 ConditionalEvaluation eval(*this);
1692 {
1693 // Propagate the likelihood attribute like __builtin_expect
1694 // __builtin_expect(X || Y, 1) -> only Y is likely
1695 // __builtin_expect(X || Y, 0) -> both X and Y are unlikely
1696 ApplyDebugLocation DL(*this, Cond);
1697 EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount,
1698 LH == Stmt::LH_Likely ? Stmt::LH_None : LH);
1699 EmitBlock(LHSFalse);
1700 }
1701
1702 incrementProfileCounter(CondBOp);
1703 setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1704
1705 // Any temporaries created here are conditional.
1706 eval.begin(*this);
1707 EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock, FalseBlock,
1708 RHSCount, LH);
1709
1710 eval.end(*this);
1711
1712 return;
1713 }
1714 }
1715
1716 if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1717 // br(!x, t, f) -> br(x, f, t)
1718 if (CondUOp->getOpcode() == UO_LNot) {
1719 // Negate the count.
1720 uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
1721 // The values of the enum are chosen to make this negation possible.
1722 LH = static_cast<Stmt::Likelihood>(-LH);
1723 // Negate the condition and swap the destination blocks.
1724 return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
1725 FalseCount, LH);
1726 }
1727 }
1728
1729 if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
1730 // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
1731 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1732 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1733
1734 // The ConditionalOperator itself has no likelihood information for its
1735 // true and false branches. This matches the behavior of __builtin_expect.
1736 ConditionalEvaluation cond(*this);
1737 EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
1738 getProfileCount(CondOp), Stmt::LH_None);
1739
1740 // When computing PGO branch weights, we only know the overall count for
1741 // the true block. This code is essentially doing tail duplication of the
1742 // naive code-gen, introducing new edges for which counts are not
1743 // available. Divide the counts proportionally between the LHS and RHS of
1744 // the conditional operator.
1745 uint64_t LHSScaledTrueCount = 0;
1746 if (TrueCount) {
1747 double LHSRatio =
1748 getProfileCount(CondOp) / (double)getCurrentProfileCount();
1749 LHSScaledTrueCount = TrueCount * LHSRatio;
1750 }
1751
1752 cond.begin(*this);
1753 EmitBlock(LHSBlock);
1754 incrementProfileCounter(CondOp);
1755 {
1756 ApplyDebugLocation DL(*this, Cond);
1757 EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
1758 LHSScaledTrueCount, LH);
1759 }
1760 cond.end(*this);
1761
1762 cond.begin(*this);
1763 EmitBlock(RHSBlock);
1764 EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
1765 TrueCount - LHSScaledTrueCount, LH);
1766 cond.end(*this);
1767
1768 return;
1769 }
1770
1771 if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1772 // Conditional operator handling can give us a throw expression as a
1773 // condition for a case like:
1774 // br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
1775 // Fold this to:
1776 // br(c, throw x, br(y, t, f))
1777 EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
1778 return;
1779 }
1780
1781 // Emit the code with the fully general case.
1782 llvm::Value *CondV;
1783 {
1784 ApplyDebugLocation DL(*this, Cond);
1785 CondV = EvaluateExprAsBool(Cond);
1786 }
1787
1788 llvm::MDNode *Weights = nullptr;
1789 llvm::MDNode *Unpredictable = nullptr;
1790
1791 // If the branch has a condition wrapped by __builtin_unpredictable,
1792 // create metadata that specifies that the branch is unpredictable.
1793 // Don't bother if not optimizing because that metadata would not be used.
1794 auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts());
1795 if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) {
1796 auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1797 if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1798 llvm::MDBuilder MDHelper(getLLVMContext());
1799 Unpredictable = MDHelper.createUnpredictable();
1800 }
1801 }
1802
1803 // If there is a Likelihood knowledge for the cond, lower it.
1804 // Note that if not optimizing this won't emit anything.
1805 llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
1806 if (CondV != NewCondV)
1807 CondV = NewCondV;
1808 else {
1809 // Otherwise, lower profile counts. Note that we do this even at -O0.
1810 uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
1811 Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
1812 }
1813
1814 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1815}
1816
1817/// ErrorUnsupported - Print out an error that codegen doesn't support the
1818/// specified stmt yet.
1819void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
1820 CGM.ErrorUnsupported(S, Type);
1821}
1822
1823/// emitNonZeroVLAInit - Emit the "zero" initialization of a
1824/// variable-length array whose elements have a non-zero bit-pattern.
1825///
1826/// \param baseType the inner-most element type of the array
1827/// \param src - a char* pointing to the bit-pattern for a single
1828/// base element of the array
1829/// \param sizeInChars - the total size of the VLA, in chars
1830static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
1831 Address dest, Address src,
1832 llvm::Value *sizeInChars) {
1833 CGBuilderTy &Builder = CGF.Builder;
1834
1835 CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1836 llvm::Value *baseSizeInChars
1837 = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1838
1839 Address begin =
1840 Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin");
1841 llvm::Value *end = Builder.CreateInBoundsGEP(
1842 begin.getElementType(), begin.getPointer(), sizeInChars, "vla.end");
1843
1844 llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1845 llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
1846 llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
1847
1848 // Make a loop over the VLA. C99 guarantees that the VLA element
1849 // count must be nonzero.
1850 CGF.EmitBlock(loopBB);
1851
1852 llvm::PHINode *cur = Builder.CreatePHI(begin.getType(), 2, "vla.cur");
1853 cur->addIncoming(begin.getPointer(), originBB);
1854
1855 CharUnits curAlign =
1856 dest.getAlignment().alignmentOfArrayElement(baseSize);
1857
1858 // memcpy the individual element bit-pattern.
1859 Builder.CreateMemCpy(Address(cur, curAlign), src, baseSizeInChars,
1860 /*volatile*/ false);
1861
1862 // Go to the next element.
1863 llvm::Value *next =
1864 Builder.CreateInBoundsGEP(CGF.Int8Ty, cur, baseSizeInChars, "vla.next");
1865
1866 // Leave if that's the end of the VLA.
1867 llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1868 Builder.CreateCondBr(done, contBB, loopBB);
1869 cur->addIncoming(next, loopBB);
1870
1871 CGF.EmitBlock(contBB);
1872}
1873
1874void
1875CodeGenFunction::EmitNullInitialization(Address DestPtr, QualType Ty) {
1876 // Ignore empty classes in C++.
1877 if (getLangOpts().CPlusPlus) {
1878 if (const RecordType *RT = Ty->getAs<RecordType>()) {
1879 if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1880 return;
1881 }
1882 }
1883
1884 // Cast the dest ptr to the appropriate i8 pointer type.
1885 if (DestPtr.getElementType() != Int8Ty)
1886 DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1887
1888 // Get size and alignment info for this aggregate.
1889 CharUnits size = getContext().getTypeSizeInChars(Ty);
1890
1891 llvm::Value *SizeVal;
1892 const VariableArrayType *vla;
1893
1894 // Don't bother emitting a zero-byte memset.
1895 if (size.isZero()) {
1896 // But note that getTypeInfo returns 0 for a VLA.
1897 if (const VariableArrayType *vlaType =
1898 dyn_cast_or_null<VariableArrayType>(
1899 getContext().getAsArrayType(Ty))) {
1900 auto VlaSize = getVLASize(vlaType);
1901 SizeVal = VlaSize.NumElts;
1902 CharUnits eltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1903 if (!eltSize.isOne())
1904 SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1905 vla = vlaType;
1906 } else {
1907 return;
1908 }
1909 } else {
1910 SizeVal = CGM.getSize(size);
1911 vla = nullptr;
1912 }
1913
1914 // If the type contains a pointer to data member we can't memset it to zero.
1915 // Instead, create a null constant and copy it to the destination.
1916 // TODO: there are other patterns besides zero that we can usefully memset,
1917 // like -1, which happens to be the pattern used by member-pointers.
1918 if (!CGM.getTypes().isZeroInitializable(Ty)) {
1919 // For a VLA, emit a single element, then splat that over the VLA.
1920 if (vla) Ty = getContext().getBaseElementType(vla);
1921
1922 llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1923
1924 llvm::GlobalVariable *NullVariable =
1925 new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1926 /*isConstant=*/true,
1927 llvm::GlobalVariable::PrivateLinkage,
1928 NullConstant, Twine());
1929 CharUnits NullAlign = DestPtr.getAlignment();
1930 NullVariable->setAlignment(NullAlign.getAsAlign());
1931 Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1932 NullAlign);
1933
1934 if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1935
1936 // Get and call the appropriate llvm.memcpy overload.
1937 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1938 return;
1939 }
1940
1941 // Otherwise, just memset the whole thing to zero. This is legal
1942 // because in LLVM, all default initializers (other than the ones we just
1943 // handled above) are guaranteed to have a bit pattern of all zeros.
1944 Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1945}
1946
1947llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1948 // Make sure that there is a block for the indirect goto.
1949 if (!IndirectBranch)
1950 GetIndirectGotoBlock();
1951
1952 llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1953
1954 // Make sure the indirect branch includes all of the address-taken blocks.
1955 IndirectBranch->addDestination(BB);
1956 return llvm::BlockAddress::get(CurFn, BB);
1957}
1958
1959llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
1960 // If we already made the indirect branch for indirect goto, return its block.
1961 if (IndirectBranch) return IndirectBranch->getParent();
1962
1963 CGBuilderTy TmpBuilder(*this, createBasicBlock("indirectgoto"));
1964
1965 // Create the PHI node that indirect gotos will add entries to.
1966 llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1967 "indirect.goto.dest");
1968
1969 // Create the indirect branch instruction.
1970 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1971 return IndirectBranch->getParent();
1972}
1973
1974/// Computes the length of an array in elements, as well as the base
1975/// element type and a properly-typed first element pointer.
1976llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType,
1977 QualType &baseType,
1978 Address &addr) {
1979 const ArrayType *arrayType = origArrayType;
1980
1981 // If it's a VLA, we have to load the stored size. Note that
1982 // this is the size of the VLA in bytes, not its size in elements.
1983 llvm::Value *numVLAElements = nullptr;
1984 if (isa<VariableArrayType>(arrayType)) {
1985 numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).NumElts;
1986
1987 // Walk into all VLAs. This doesn't require changes to addr,
1988 // which has type T* where T is the first non-VLA element type.
1989 do {
1990 QualType elementType = arrayType->getElementType();
1991 arrayType = getContext().getAsArrayType(elementType);
1992
1993 // If we only have VLA components, 'addr' requires no adjustment.
1994 if (!arrayType) {
1995 baseType = elementType;
1996 return numVLAElements;
1997 }
1998 } while (isa<VariableArrayType>(arrayType));
1999
2000 // We get out here only if we find a constant array type
2001 // inside the VLA.
2002 }
2003
2004 // We have some number of constant-length arrays, so addr should
2005 // have LLVM type [M x [N x [...]]]*. Build a GEP that walks
2006 // down to the first element of addr.
2007 SmallVector<llvm::Value*, 8> gepIndices;
2008
2009 // GEP down to the array type.
2010 llvm::ConstantInt *zero = Builder.getInt32(0);
2011 gepIndices.push_back(zero);
2012
2013 uint64_t countFromCLAs = 1;
2014 QualType eltType;
2015
2016 llvm::ArrayType *llvmArrayType =
2017 dyn_cast<llvm::ArrayType>(addr.getElementType());
2018 while (llvmArrayType) {
2019 assert(isa<ConstantArrayType>(arrayType));
2020 assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
2021 == llvmArrayType->getNumElements());
2022
2023 gepIndices.push_back(zero);
2024 countFromCLAs *= llvmArrayType->getNumElements();
2025 eltType = arrayType->getElementType();
2026
2027 llvmArrayType =
2028 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2029 arrayType = getContext().getAsArrayType(arrayType->getElementType());
2030 assert((!llvmArrayType || arrayType) &&
2031 "LLVM and Clang types are out-of-synch");
2032 }
2033
2034 if (arrayType) {
2035 // From this point onwards, the Clang array type has been emitted
2036 // as some other type (probably a packed struct). Compute the array
2037 // size, and just emit the 'begin' expression as a bitcast.
2038 while (arrayType) {
2039 countFromCLAs *=
2040 cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
2041 eltType = arrayType->getElementType();
2042 arrayType = getContext().getAsArrayType(eltType);
2043 }
2044
2045 llvm::Type *baseType = ConvertType(eltType);
2046 addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
2047 } else {
2048 // Create the actual GEP.
2049 addr = Address(Builder.CreateInBoundsGEP(
2050 addr.getElementType(), addr.getPointer(), gepIndices, "array.begin"),
2051 addr.getAlignment());
2052 }
2053
2054 baseType = eltType;
2055
2056 llvm::Value *numElements
2057 = llvm::ConstantInt::get(SizeTy, countFromCLAs);
2058
2059 // If we had any VLA dimensions, factor them in.
2060 if (numVLAElements)
2061 numElements = Builder.CreateNUWMul(numVLAElements, numElements);
2062
2063 return numElements;
2064}
2065
2066CodeGenFunction::VlaSizePair CodeGenFunction::getVLASize(QualType type) {
2067 const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
2068 assert(vla && "type was not a variable array type!");
2069 return getVLASize(vla);
2070}
2071
2072CodeGenFunction::VlaSizePair
2073CodeGenFunction::getVLASize(const VariableArrayType *type) {
2074 // The number of elements so far; always size_t.
2075 llvm::Value *numElements = nullptr;
2076
2077 QualType elementType;
2078 do {
2079 elementType = type->getElementType();
2080 llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
2081 assert(vlaSize && "no size for VLA!");
2082 assert(vlaSize->getType() == SizeTy);
2083
2084 if (!numElements) {
2085 numElements = vlaSize;
2086 } else {
2087 // It's undefined behavior if this wraps around, so mark it that way.
2088 // FIXME: Teach -fsanitize=undefined to trap this.
2089 numElements = Builder.CreateNUWMul(numElements, vlaSize);
2090 }
2091 } while ((type = getContext().getAsVariableArrayType(elementType)));
2092
2093 return { numElements, elementType };
2094}
2095
2096CodeGenFunction::VlaSizePair
2097CodeGenFunction::getVLAElements1D(QualType type) {
2098 const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
2099 assert(vla && "type was not a variable array type!");
2100 return getVLAElements1D(vla);
2101}
2102
2103CodeGenFunction::VlaSizePair
2104CodeGenFunction::getVLAElements1D(const VariableArrayType *Vla) {
2105 llvm::Value *VlaSize = VLASizeMap[Vla->getSizeExpr()];
2106 assert(VlaSize && "no size for VLA!");
2107 assert(VlaSize->getType() == SizeTy);
2108 return { VlaSize, Vla->getElementType() };
2109}
2110
2111void CodeGenFunction::EmitVariablyModifiedType(QualType type) {
2112 assert(type->isVariablyModifiedType() &&
2113 "Must pass variably modified type to EmitVLASizes!");
2114
2115 EnsureInsertPoint();
2116
2117 // We're going to walk down into the type and look for VLA
2118 // expressions.
2119 do {
2120 assert(type->isVariablyModifiedType());
2121
2122 const Type *ty = type.getTypePtr();
2123 switch (ty->getTypeClass()) {
2124
2125#define TYPE(Class, Base)
2126#define ABSTRACT_TYPE(Class, Base)
2127#define NON_CANONICAL_TYPE(Class, Base)
2128#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2129#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2130#include "clang/AST/TypeNodes.inc"
2131 llvm_unreachable("unexpected dependent type!");
2132
2133 // These types are never variably-modified.
2134 case Type::Builtin:
2135 case Type::Complex:
2136 case Type::Vector:
2137 case Type::ExtVector:
2138 case Type::ConstantMatrix:
2139 case Type::Record:
2140 case Type::Enum:
2141 case Type::Elaborated:
2142 case Type::TemplateSpecialization:
2143 case Type::ObjCTypeParam:
2144 case Type::ObjCObject:
2145 case Type::ObjCInterface:
2146 case Type::ObjCObjectPointer:
2147 case Type::ExtInt:
2148 llvm_unreachable("type class is never variably-modified!");
2149
2150 case Type::Adjusted:
2151 type = cast<AdjustedType>(ty)->getAdjustedType();
2152 break;
2153
2154 case Type::Decayed:
2155 type = cast<DecayedType>(ty)->getPointeeType();
2156 break;
2157
2158 case Type::Pointer:
2159 type = cast<PointerType>(ty)->getPointeeType();
2160 break;
2161
2162 case Type::BlockPointer:
2163 type = cast<BlockPointerType>(ty)->getPointeeType();
2164 break;
2165
2166 case Type::LValueReference:
2167 case Type::RValueReference:
2168 type = cast<ReferenceType>(ty)->getPointeeType();
2169 break;
2170
2171 case Type::MemberPointer:
2172 type = cast<MemberPointerType>(ty)->getPointeeType();
2173 break;
2174
2175 case Type::ConstantArray:
2176 case Type::IncompleteArray:
2177 // Losing element qualification here is fine.
2178 type = cast<ArrayType>(ty)->getElementType();
2179 break;
2180
2181 case Type::VariableArray: {
2182 // Losing element qualification here is fine.
2183 const VariableArrayType *vat = cast<VariableArrayType>(ty);
2184
2185 // Unknown size indication requires no size computation.
2186 // Otherwise, evaluate and record it.
2187 if (const Expr *size = vat->getSizeExpr()) {
2188 // It's possible that we might have emitted this already,
2189 // e.g. with a typedef and a pointer to it.
2190 llvm::Value *&entry = VLASizeMap[size];
2191 if (!entry) {
2192 llvm::Value *Size = EmitScalarExpr(size);
2193
2194 // C11 6.7.6.2p5:
2195 // If the size is an expression that is not an integer constant
2196 // expression [...] each time it is evaluated it shall have a value
2197 // greater than zero.
2198 if (SanOpts.has(SanitizerKind::VLABound) &&
2199 size->getType()->isSignedIntegerType()) {
2200 SanitizerScope SanScope(this);
2201 llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
2202 llvm::Constant *StaticArgs[] = {
2203 EmitCheckSourceLocation(size->getBeginLoc()),
2204 EmitCheckTypeDescriptor(size->getType())};
2205 EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
2206 SanitizerKind::VLABound),
2207 SanitizerHandler::VLABoundNotPositive, StaticArgs, Size);
2208 }
2209
2210 // Always zexting here would be wrong if it weren't
2211 // undefined behavior to have a negative bound.
2212 entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
2213 }
2214 }
2215 type = vat->getElementType();
2216 break;
2217 }
2218
2219 case Type::FunctionProto:
2220 case Type::FunctionNoProto:
2221 type = cast<FunctionType>(ty)->getReturnType();
2222 break;
2223
2224 case Type::Paren:
2225 case Type::TypeOf:
2226 case Type::UnaryTransform:
2227 case Type::Attributed:
2228 case Type::SubstTemplateTypeParm:
2229 case Type::MacroQualified:
2230 // Keep walking after single level desugaring.
2231 type = type.getSingleStepDesugaredType(getContext());
2232 break;
2233
2234 case Type::Typedef:
2235 case Type::Decltype:
2236 case Type::Auto:
2237 case Type::DeducedTemplateSpecialization:
2238 // Stop walking: nothing to do.
2239 return;
2240
2241 case Type::TypeOfExpr:
2242 // Stop walking: emit typeof expression.
2243 EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
2244 return;
2245
2246 case Type::Atomic:
2247 type = cast<AtomicType>(ty)->getValueType();
2248 break;
2249
2250 case Type::Pipe:
2251 type = cast<PipeType>(ty)->getElementType();
2252 break;
2253 }