//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This coordinates the per-function state used while generating code.

//

//===----------------------------------------------------------------------===//

#include "CodeGenFunction.h"

#include "CGBlocks.h"

#include "CGCUDARuntime.h"

#include "CGCXXABI.h"

#include "CGCleanup.h"

#include "CGDebugInfo.h"

#include "CGOpenMPRuntime.h"

#include "CodeGenModule.h"

#include "CodeGenPGO.h"

#include "TargetInfo.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/Attr.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/Expr.h"

#include "clang/AST/StmtCXX.h"

#include "clang/AST/StmtObjC.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/CodeGen/CGFunctionInfo.h"

#include "clang/Frontend/FrontendDiagnostic.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/Dominators.h"

#include "llvm/IR/FPEnv.h"

#include "llvm/IR/IntrinsicInst.h"

#include "llvm/IR/Intrinsics.h"

#include "llvm/IR/MDBuilder.h"

#include "llvm/IR/Operator.h"

#include "llvm/Support/CRC.h"

#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"

#include "llvm/Transforms/Utils/PromoteMemToReg.h"

using namespace clang;

using namespace CodeGen;

/// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time

/// markers.

static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,

                                      const LangOptions &LangOpts) {

  if (CGOpts.DisableLifetimeMarkers)

    return false;

  // Sanitizers may use markers.

  if (CGOpts.SanitizeAddressUseAfterScope ||

      
LangOpts.Sanitize.has(SanitizerKind::HWAddress)315k
 ||

      
LangOpts.Sanitize.has(SanitizerKind::Memory)315k
)

    return true;

  // For now, only in optimized builds.

  return CGOpts.OptimizationLevel != 0;

}

CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)

    : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),

      Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),

              CGBuilderInserterTy(this)),

      SanOpts(CGM.getLangOpts().Sanitize), CurFPFeatures(CGM.getLangOpts()),

      DebugInfo(CGM.getModuleDebugInfo()), PGO(cgm),

      ShouldEmitLifetimeMarkers(

          shouldEmitLifetimeMarkers(CGM.getCodeGenOpts(), CGM.getLangOpts())) {

  if (!suppressNewContext)

    CGM.getCXXABI().getMangleContext().startNewFunction();

  EHStack.setCGF(this);

  SetFastMathFlags(CurFPFeatures);

}

CodeGenFunction::~CodeGenFunction() {

  assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");

  if (getLangOpts().OpenMP && 
CurFn70.3k
)

    CGM.getOpenMPRuntime().functionFinished(*this);

  // If we have an OpenMPIRBuilder we want to finalize functions (incl.

  // outlining etc) at some point. Doing it once the function codegen is done

  // seems to be a reasonable spot. We do it here, as opposed to the deletion

  // time of the CodeGenModule, because we have to ensure the IR has not yet

  // been "emitted" to the outside, thus, modifications are still sensible.

  if (CGM.getLangOpts().OpenMPIRBuilder && 
CurFn456
)

    CGM.getOpenMPRuntime().getOMPBuilder().finalize(CurFn);

}

// Map the LangOption for exception behavior into

// the corresponding enum in the IR.

llvm::fp::ExceptionBehavior

clang::ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind) {

  switch (Kind) {

  case LangOptions::FPE_Ignore:  return llvm::fp::ebIgnore;

  case LangOptions::FPE_MayTrap: return llvm::fp::ebMayTrap;

  case LangOptions::FPE_Strict:  return llvm::fp::ebStrict;

  }

  llvm_unreachable("Unsupported FP Exception Behavior");

}

void CodeGenFunction::SetFastMathFlags(FPOptions FPFeatures) {

  llvm::FastMathFlags FMF;

  FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());

  FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());

  FMF.setNoInfs(FPFeatures.getNoHonorInfs());

  FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());

  FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());

  FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());

  FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());

  Builder.setFastMathFlags(FMF);

}

CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,

                                                  const Expr *E)

    : CGF(CGF) {

  ConstructorHelper(E->getFPFeaturesInEffect(CGF.getLangOpts()));

}

CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,

                                                  FPOptions FPFeatures)

    : CGF(CGF) {

  ConstructorHelper(FPFeatures);

}

void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) {

  OldFPFeatures = CGF.CurFPFeatures;

  CGF.CurFPFeatures = FPFeatures;

  OldExcept = CGF.Builder.getDefaultConstrainedExcept();

  OldRounding = CGF.Builder.getDefaultConstrainedRounding();

  if (OldFPFeatures == FPFeatures)

    return;

  FMFGuard.emplace(CGF.Builder);

  llvm::RoundingMode NewRoundingBehavior =

      static_cast<llvm::RoundingMode>(FPFeatures.getRoundingMode());

  CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);

  auto NewExceptionBehavior =

      ToConstrainedExceptMD(static_cast<LangOptions::FPExceptionModeKind>(

          FPFeatures.getFPExceptionMode()));

  CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);

  CGF.SetFastMathFlags(FPFeatures);

  assert((CGF.CurFuncDecl == nullptr || CGF.Builder.getIsFPConstrained() ||

          isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||

          isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||

          (NewExceptionBehavior == llvm::fp::ebIgnore &&

           NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&

         "FPConstrained should be enabled on entire function");

  auto mergeFnAttrValue = [&](StringRef Name, bool Value) {

    auto OldValue =

        CGF.CurFn->getFnAttribute(Name).getValueAsBool();

    auto NewValue = OldValue & Value;

    if (OldValue != NewValue)

      CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));

  };

  mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs());

  mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs());

  mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());

  mergeFnAttrValue("unsafe-fp-math", FPFeatures.getAllowFPReassociate() &&

                                         
FPFeatures.getAllowReciprocal()220
 &&

                                         
FPFeatures.getAllowApproxFunc()172
 &&

                                         
FPFeatures.getNoSignedZero()172
);

}

CodeGenFunction::CGFPOptionsRAII::~CGFPOptionsRAII() {

  CGF.CurFPFeatures = OldFPFeatures;

  CGF.Builder.setDefaultConstrainedExcept(OldExcept);

  CGF.Builder.setDefaultConstrainedRounding(OldRounding);

}

LValue CodeGenFunction::MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {

  LValueBaseInfo BaseInfo;

  TBAAAccessInfo TBAAInfo;

  CharUnits Alignment = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo);

  Address Addr(V, ConvertTypeForMem(T), Alignment);

  return LValue::MakeAddr(Addr, T, getContext(), BaseInfo, TBAAInfo);

}

/// Given a value of type T* that may not be to a complete object,

/// construct an l-value with the natural pointee alignment of T.

LValue

CodeGenFunction::MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T) {

  LValueBaseInfo BaseInfo;

  TBAAAccessInfo TBAAInfo;

  CharUnits Align = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo,

                                                /* forPointeeType= */ true);

  Address Addr(V, ConvertTypeForMem(T), Align);

  return MakeAddrLValue(Addr, T, BaseInfo, TBAAInfo);

}

llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {

  return CGM.getTypes().ConvertTypeForMem(T);

}

llvm::Type *CodeGenFunction::ConvertType(QualType T) {

  return CGM.getTypes().ConvertType(T);

}

TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {

  type = type.getCanonicalType();

  while (true) {

    switch (type->getTypeClass()) {

#define TYPE(name, parent)

#define ABSTRACT_TYPE(name, parent)

#define NON_CANONICAL_TYPE(name, parent) case Type::name:

#define DEPENDENT_TYPE(name, parent) case Type::name:

#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:

#include "clang/AST/TypeNodes.inc"

      llvm_unreachable("non-canonical or dependent type in IR-generation");

    case Type::Auto:

    case Type::DeducedTemplateSpecialization:

      llvm_unreachable("undeduced type in IR-generation");

    // Various scalar types.

    case Type::Builtin:

    case Type::Pointer:

    case Type::BlockPointer:

    case Type::LValueReference:

    case Type::RValueReference:

    case Type::MemberPointer:

    case Type::Vector:

    case Type::ExtVector:

    case Type::ConstantMatrix:

    case Type::FunctionProto:

    case Type::FunctionNoProto:

    case Type::Enum:

    case Type::ObjCObjectPointer:

    case Type::Pipe:

    case Type::BitInt:

      return TEK_Scalar;

    // Complexes.

    case Type::Complex:

      return TEK_Complex;

    // Arrays, records, and Objective-C objects.

    case Type::ConstantArray:

    case Type::IncompleteArray:

    case Type::VariableArray:

    case Type::Record:

    case Type::ObjCObject:

    case Type::ObjCInterface:

      return TEK_Aggregate;

    // We operate on atomic values according to their underlying type.

    case Type::Atomic:

      type = cast<AtomicType>(type)->getValueType();

      continue;

    }

    llvm_unreachable("unknown type kind!");

  }

}

llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {

  // For cleanliness, we try to avoid emitting the return block for

  // simple cases.

  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();

  if (CurBB) {

    assert(!CurBB->getTerminator() && "Unexpected terminated block.");

    // We have a valid insert point, reuse it if it is empty or there are no

    // explicit jumps to the return block.

    if (CurBB->empty() || 
ReturnBlock.getBlock()->use_empty()132k
) {

      ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);

      delete ReturnBlock.getBlock();

      ReturnBlock = JumpDest();

    } else

      EmitBlock(ReturnBlock.getBlock());

    return llvm::DebugLoc();

  }

  // Otherwise, if the return block is the target of a single direct

  // branch then we can just put the code in that block instead. This

  // cleans up functions which started with a unified return block.

  if (ReturnBlock.getBlock()->hasOneUse()) {

    llvm::BranchInst *BI =

      dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());

    if (BI && 
BI->isUnconditional()151k
 &&

        
BI->getSuccessor(0) == ReturnBlock.getBlock()151k
) {

      // Record/return the DebugLoc of the simple 'return' expression to be used

      // later by the actual 'ret' instruction.

      llvm::DebugLoc Loc = BI->getDebugLoc();

      Builder.SetInsertPoint(BI->getParent());

      BI->eraseFromParent();

      delete ReturnBlock.getBlock();

      ReturnBlock = JumpDest();

      return Loc;

    }

  }

  // FIXME: We are at an unreachable point, there is no reason to emit the block

  // unless it has uses. However, we still need a place to put the debug

  // region.end for now.

  EmitBlock(ReturnBlock.getBlock());

  return llvm::DebugLoc();

}

static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {

  if (!BB) 
return1.25M
;

  if (!BB->use_empty())

    return CGF.CurFn->getBasicBlockList().push_back(BB);

  delete BB;

}

void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {

  assert(BreakContinueStack.empty() &&

         "mismatched push/pop in break/continue stack!");

  bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0

    && 
NumSimpleReturnExprs == NumReturnExprs15.0k

    && 
ReturnBlock.getBlock()->use_empty()13.7k
;

  // Usually the return expression is evaluated before the cleanup

  // code.  If the function contains only a simple return statement,

  // such as a constant, the location before the cleanup code becomes

  // the last useful breakpoint in the function, because the simple

  // return expression will be evaluated after the cleanup code. To be

  // safe, set the debug location for cleanup code to the location of

  // the return statement.  Otherwise the cleanup code should be at the

  // end of the function's lexical scope.

  //

  // If there are multiple branches to the return block, the branch

  // instructions will get the location of the return statements and

  // all will be fine.

  if (CGDebugInfo *DI = getDebugInfo()) {

    if (OnlySimpleReturnStmts)

      DI->EmitLocation(Builder, LastStopPoint);

    else

      DI->EmitLocation(Builder, EndLoc);

  }

  // Pop any cleanups that might have been associated with the

  // parameters.  Do this in whatever block we're currently in; it's

  // important to do this before we enter the return block or return

  // edges will be *really* confused.

  bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;

  bool HasOnlyLifetimeMarkers =

      HasCleanups && 
EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth)6.96k
;

  bool EmitRetDbgLoc = !HasCleanups || 
HasOnlyLifetimeMarkers6.96k
;

  if (HasCleanups) {

    // Make sure the line table doesn't jump back into the body for

    // the ret after it's been at EndLoc.

    Optional<ApplyDebugLocation> AL;

    if (CGDebugInfo *DI = getDebugInfo()) {

      if (OnlySimpleReturnStmts)

        DI->EmitLocation(Builder, EndLoc);

      else

        // We may not have a valid end location. Try to apply it anyway, and

        // fall back to an artificial location if needed.

        AL = ApplyDebugLocation::CreateDefaultArtificial(*this, EndLoc);

    }

    PopCleanupBlocks(PrologueCleanupDepth);

  }

  // Emit function epilog (to return).

  llvm::DebugLoc Loc = EmitReturnBlock();

  if (ShouldInstrumentFunction()) {

    if (CGM.getCodeGenOpts().InstrumentFunctions)

      CurFn->addFnAttr("instrument-function-exit", "__cyg_profile_func_exit");

    if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)

      CurFn->addFnAttr("instrument-function-exit-inlined",

                       "__cyg_profile_func_exit");

  }

  // Emit debug descriptor for function end.

  if (CGDebugInfo *DI = getDebugInfo())

    DI->EmitFunctionEnd(Builder, CurFn);

  // Reset the debug location to that of the simple 'return' expression, if any

  // rather than that of the end of the function's scope '}'.

  ApplyDebugLocation AL(*this, Loc);

  EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);

  EmitEndEHSpec(CurCodeDecl);

  assert(EHStack.empty() &&

         "did not remove all scopes from cleanup stack!");

  // If someone did an indirect goto, emit the indirect goto block at the end of

  // the function.

  if (IndirectBranch) {

    EmitBlock(IndirectBranch->getParent());

    Builder.ClearInsertionPoint();

  }

  // If some of our locals escaped, insert a call to llvm.localescape in the

  // entry block.

  if (!EscapedLocals.empty()) {

    // Invert the map from local to index into a simple vector. There should be

    // no holes.

    SmallVector<llvm::Value *, 4> EscapeArgs;

    EscapeArgs.resize(EscapedLocals.size());

    for (auto &Pair : EscapedLocals)

      EscapeArgs[Pair.second] = Pair.first;

    llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(

        &CGM.getModule(), llvm::Intrinsic::localescape);

    CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);

  }

  // Remove the AllocaInsertPt instruction, which is just a convenience for us.

  llvm::Instruction *Ptr = AllocaInsertPt;

  AllocaInsertPt = nullptr;

  Ptr->eraseFromParent();

  // PostAllocaInsertPt, if created, was lazily created when it was required,

  // remove it now since it was just created for our own convenience.

  if (PostAllocaInsertPt) {

    llvm::Instruction *PostPtr = PostAllocaInsertPt;

    PostAllocaInsertPt = nullptr;

    PostPtr->eraseFromParent();

  }

  // If someone took the address of a label but never did an indirect goto, we

  // made a zero entry PHI node, which is illegal, zap it now.

  if (IndirectBranch) {

    llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());

    if (PN->getNumIncomingValues() == 0) {

      PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));

      PN->eraseFromParent();

    }

  }

  EmitIfUsed(*this, EHResumeBlock);

  EmitIfUsed(*this, TerminateLandingPad);

  EmitIfUsed(*this, TerminateHandler);

  EmitIfUsed(*this, UnreachableBlock);

  for (const auto &FuncletAndParent : TerminateFunclets)

    EmitIfUsed(*this, FuncletAndParent.second);

  if (CGM.getCodeGenOpts().EmitDeclMetadata)

    EmitDeclMetadata();

  for (const auto &R : DeferredReplacements) {

    if (llvm::Value *Old = R.first) {

      Old->replaceAllUsesWith(R.second);

      cast<llvm::Instruction>(Old)->eraseFromParent();

    }

  }

  DeferredReplacements.clear();

  // Eliminate CleanupDestSlot alloca by replacing it with SSA values and

  // PHIs if the current function is a coroutine. We don't do it for all

  // functions as it may result in slight increase in numbers of instructions

  // if compiled with no optimizations. We do it for coroutine as the lifetime

  // of CleanupDestSlot alloca make correct coroutine frame building very

  // difficult.

  if (NormalCleanupDest.isValid() && 
isCoroutine()383
) {

    llvm::DominatorTree DT(*CurFn);

    llvm::PromoteMemToReg(

        cast<llvm::AllocaInst>(NormalCleanupDest.getPointer()), DT);

    NormalCleanupDest = Address::invalid();

  }

  // Scan function arguments for vector width.

  for (llvm::Argument &A : CurFn->args())

    if (auto *VT = dyn_cast<llvm::VectorType>(A.getType()))

      LargestVectorWidth =

          std::max((uint64_t)LargestVectorWidth,

                   VT->getPrimitiveSizeInBits().getKnownMinSize());

  // Update vector width based on return type.

  if (auto *VT = dyn_cast<llvm::VectorType>(CurFn->getReturnType()))

    LargestVectorWidth =

        std::max((uint64_t)LargestVectorWidth,

                 VT->getPrimitiveSizeInBits().getKnownMinSize());

  if (CurFnInfo->getMaxVectorWidth() > LargestVectorWidth)

    LargestVectorWidth = CurFnInfo->getMaxVectorWidth();

  // Add the required-vector-width attribute. This contains the max width from:

  // 1. min-vector-width attribute used in the source program.

  // 2. Any builtins used that have a vector width specified.

  // 3. Values passed in and out of inline assembly.

  // 4. Width of vector arguments and return types for this function.

  // 5. Width of vector aguments and return types for functions called by this

  //    function.

  CurFn->addFnAttr("min-legal-vector-width", llvm::utostr(LargestVectorWidth));

  // Add vscale_range attribute if appropriate.

  Optional<std::pair<unsigned, unsigned>> VScaleRange =

      getContext().getTargetInfo().getVScaleRange(getLangOpts());

  if (VScaleRange) {

    CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(

        getLLVMContext(), VScaleRange.getValue().first,

        VScaleRange.getValue().second));

  }

  // If we generated an unreachable return block, delete it now.

  if (ReturnBlock.isValid() && 
ReturnBlock.getBlock()->use_empty()3.43k
) {

    Builder.ClearInsertionPoint();

    ReturnBlock.getBlock()->eraseFromParent();

  }

  if (ReturnValue.isValid()) {

    auto *RetAlloca = dyn_cast<llvm::AllocaInst>(ReturnValue.getPointer());

    if (RetAlloca && 
RetAlloca->use_empty()150k
) {

      RetAlloca->eraseFromParent();

      ReturnValue = Address::invalid();

    }

  }

}

/// ShouldInstrumentFunction - Return true if the current function should be

/// instrumented with __cyg_profile_func_* calls

bool CodeGenFunction::ShouldInstrumentFunction() {

  if (!CGM.getCodeGenOpts().InstrumentFunctions &&

      
!CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining629k
 &&

      
!CGM.getCodeGenOpts().InstrumentFunctionEntryBare629k
)

    return false;

  if (!CurFuncDecl || 
CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()36
)

    return false;

  return true;

}

bool CodeGenFunction::ShouldSkipSanitizerInstrumentation() {

  if (!CurFuncDecl)

    return false;

  return CurFuncDecl->hasAttr<DisableSanitizerInstrumentationAttr>();

}

/// ShouldXRayInstrument - Return true if the current function should be

/// instrumented with XRay nop sleds.

bool CodeGenFunction::ShouldXRayInstrumentFunction() const {

  return CGM.getCodeGenOpts().XRayInstrumentFunctions;

}

/// AlwaysEmitXRayCustomEvents - Return true if we should emit IR for calls to

/// the __xray_customevent(...) builtin calls, when doing XRay instrumentation.

bool CodeGenFunction::AlwaysEmitXRayCustomEvents() const {

  return CGM.getCodeGenOpts().XRayInstrumentFunctions &&

         (CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||

          CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==

              XRayInstrKind::Custom);

}

bool CodeGenFunction::AlwaysEmitXRayTypedEvents() const {

  return CGM.getCodeGenOpts().XRayInstrumentFunctions &&

         (CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||

          CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==

              XRayInstrKind::Typed);

}

llvm::Constant *

CodeGenFunction::EncodeAddrForUseInPrologue(llvm::Function *F,

                                            llvm::Constant *Addr) {

  // Addresses stored in prologue data can't require run-time fixups and must

  // be PC-relative. Run-time fixups are undesirable because they necessitate

  // writable text segments, which are unsafe. And absolute addresses are

  // undesirable because they break PIE mode.

  // Add a layer of indirection through a private global. Taking its address

  // won't result in a run-time fixup, even if Addr has linkonce_odr linkage.

  auto *GV = new llvm::GlobalVariable(CGM.getModule(), Addr->getType(),

                                      /*isConstant=*/true,

                                      llvm::GlobalValue::PrivateLinkage, Addr);

  // Create a PC-relative address.

  auto *GOTAsInt = llvm::ConstantExpr::getPtrToInt(GV, IntPtrTy);

  auto *FuncAsInt = llvm::ConstantExpr::getPtrToInt(F, IntPtrTy);

  auto *PCRelAsInt = llvm::ConstantExpr::getSub(GOTAsInt, FuncAsInt);

  return (IntPtrTy == Int32Ty)

             ? 
PCRelAsInt70

             : 
llvm::ConstantExpr::getTrunc(PCRelAsInt, Int32Ty)41
;

}

llvm::Value *

CodeGenFunction::DecodeAddrUsedInPrologue(llvm::Value *F,

                                          llvm::Value *EncodedAddr) {

  // Reconstruct the address of the global.

  auto *PCRelAsInt = Builder.CreateSExt(EncodedAddr, IntPtrTy);

  auto *FuncAsInt = Builder.CreatePtrToInt(F, IntPtrTy, "func_addr.int");

  auto *GOTAsInt = Builder.CreateAdd(PCRelAsInt, FuncAsInt, "global_addr.int");

  auto *GOTAddr = Builder.CreateIntToPtr(GOTAsInt, Int8PtrPtrTy, "global_addr");

  // Load the original pointer through the global.

  return Builder.CreateLoad(Address(GOTAddr, Int8PtrTy, getPointerAlign()),

                            "decoded_addr");

}

void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,

                                               llvm::Function *Fn)

{

  if (!FD->hasAttr<OpenCLKernelAttr>())

    return;

  llvm::LLVMContext &Context = getLLVMContext();

  CGM.GenOpenCLArgMetadata(Fn, FD, this);

  if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {

    QualType HintQTy = A->getTypeHint();

    const ExtVectorType *HintEltQTy = HintQTy->getAs<ExtVectorType>();

    bool IsSignedInteger =

        HintQTy->isSignedIntegerType() ||

        
(1
HintEltQTy1
 && 
HintEltQTy->getElementType()->isSignedIntegerType()1
);

    llvm::Metadata *AttrMDArgs[] = {

        llvm::ConstantAsMetadata::get(llvm::UndefValue::get(

            CGM.getTypes().ConvertType(A->getTypeHint()))),

        llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

            llvm::IntegerType::get(Context, 32),

            llvm::APInt(32, (uint64_t)(IsSignedInteger ? 
11
 : 
01
))))};

    Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));

  }

  if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {

    llvm::Metadata *AttrMDArgs[] = {

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};

    Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));

  }

  if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {

    llvm::Metadata *AttrMDArgs[] = {

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};

    Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));

  }

  if (const OpenCLIntelReqdSubGroupSizeAttr *A =

          FD->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {

    llvm::Metadata *AttrMDArgs[] = {

        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};

    Fn->setMetadata("intel_reqd_sub_group_size",

                    llvm::MDNode::get(Context, AttrMDArgs));

  }

}

/// Determine whether the function F ends with a return stmt.

static bool endsWithReturn(const Decl* F) {

  const Stmt *Body = nullptr;

  if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))

    Body = FD->getBody();

  else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))

    Body = OMD->getBody();

  if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {

    auto LastStmt = CS->body_rbegin();

    if (LastStmt != CS->body_rend())

      return isa<ReturnStmt>(*LastStmt);

  }

  return false;

}

void CodeGenFunction::markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn) {

  if (SanOpts.has(SanitizerKind::Thread)) {

    Fn->addFnAttr("sanitize_thread_no_checking_at_run_time");

    Fn->removeFnAttr(llvm::Attribute::SanitizeThread);

  }

}

/// Check if the return value of this function requires sanitization.

bool CodeGenFunction::requiresReturnValueCheck() const {

  return requiresReturnValueNullabilityCheck() ||

         
(471k
SanOpts.has(SanitizerKind::ReturnsNonnullAttribute)471k
 && 
CurCodeDecl111
 &&

          
CurCodeDecl->getAttr<ReturnsNonNullAttr>()111
);

}

static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx) {

  auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);

  if (!MD || 
!MD->getDeclName().getAsIdentifierInfo()3
 ||

      
!MD->getDeclName().getAsIdentifierInfo()->isStr("allocate")3
 ||

      
(2
MD->getNumParams() != 12
 && 
MD->getNumParams() != 21
))

    return false;

  if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.getSizeType())

    return false;

  if (MD->getNumParams() == 2) {

    auto *PT = MD->parameters()[1]->getType()->getAs<PointerType>();

    if (!PT || !PT->isVoidPointerType() ||

        !PT->getPointeeType().isConstQualified())

      return false;

  }

  return true;

}

/// Return the UBSan prologue signature for \p FD if one is available.

static llvm::Constant *getPrologueSignature(CodeGenModule &CGM,

                                            const FunctionDecl *FD) {

  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))

    if (!MD->isStatic())

      return nullptr;

  return CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM);

}

void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,

                                    llvm::Function *Fn,

                                    const CGFunctionInfo &FnInfo,

                                    const FunctionArgList &Args,

                                    SourceLocation Loc,

                                    SourceLocation StartLoc) {

  assert(!CurFn &&

         "Do not use a CodeGenFunction object for more than one function");

  const Decl *D = GD.getDecl();

  DidCallStackSave = false;

  CurCodeDecl = D;

  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);

  if (FD && 
FD->usesSEHTry()270k
)

    CurSEHParent = FD;

  CurFuncDecl = (D ? 
D->getNonClosureContext()305k
 : 
nullptr9.00k
);

  FnRetTy = RetTy;

  CurFn = Fn;

  CurFnInfo = &FnInfo;

  assert(CurFn->isDeclaration() && "Function already has body?");

  // If this function is ignored for any of the enabled sanitizers,

  // disable the sanitizer for the function.

  do {

#define SANITIZER(NAME, ID)                                                    \

  if (
SanOpts.empty()529k
)                                                         \

    
break310k
;                                                                     \

  
if (218k
SanOpts.has(SanitizerKind::ID)218k
)                                          \

    
if (7.25k
CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc)7.25k
)                    \

      
SanOpts.set(SanitizerKind::ID, false)55
;

#include "clang/Basic/Sanitizers.def"

#undef SANITIZER

  } while (
false3.89k
);

  if (D) {

    const bool SanitizeBounds = SanOpts.hasOneOf(SanitizerKind::Bounds);

    bool NoSanitizeCoverage = false;

    for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) {

      // Apply the no_sanitize* attributes to SanOpts.

      SanitizerMask mask = Attr->getMask();

      SanOpts.Mask &= ~mask;

      if (mask & SanitizerKind::Address)

        SanOpts.set(SanitizerKind::KernelAddress, false);

      if (mask & SanitizerKind::KernelAddress)

        SanOpts.set(SanitizerKind::Address, false);

      if (mask & SanitizerKind::HWAddress)

        SanOpts.set(SanitizerKind::KernelHWAddress, false);

      if (mask & SanitizerKind::KernelHWAddress)

        SanOpts.set(SanitizerKind::HWAddress, false);

      // SanitizeCoverage is not handled by SanOpts.

      if (Attr->hasCoverage())

        NoSanitizeCoverage = true;

    }

    if (SanitizeBounds && 
!SanOpts.hasOneOf(SanitizerKind::Bounds)120
)

      Fn->addFnAttr(llvm::Attribute::NoSanitizeBounds);

    if (NoSanitizeCoverage && 
CGM.getCodeGenOpts().hasSanitizeCoverage()24
)

      Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);

  }

  if (ShouldSkipSanitizerInstrumentation()) {

    CurFn->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);

  } else {

    // Apply sanitizer attributes to the function.

    if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))

      Fn->addFnAttr(llvm::Attribute::SanitizeAddress);

    if (SanOpts.hasOneOf(SanitizerKind::HWAddress |

                         SanitizerKind::KernelHWAddress))

      Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);

    if (SanOpts.has(SanitizerKind::MemtagStack))

      Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);

    if (SanOpts.has(SanitizerKind::Thread))

      Fn->addFnAttr(llvm::Attribute::SanitizeThread);

    if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))

      Fn->addFnAttr(llvm::Attribute::SanitizeMemory);

  }

  if (SanOpts.has(SanitizerKind::SafeStack))

    Fn->addFnAttr(llvm::Attribute::SafeStack);

  if (SanOpts.has(SanitizerKind::ShadowCallStack))

    Fn->addFnAttr(llvm::Attribute::ShadowCallStack);

  // Apply fuzzing attribute to the function.

  if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))

    Fn->addFnAttr(llvm::Attribute::OptForFuzzing);

  // Ignore TSan memory acesses from within ObjC/ObjC++ dealloc, initialize,

  // .cxx_destruct, __destroy_helper_block_ and all of their calees at run time.

  if (SanOpts.has(SanitizerKind::Thread)) {

    if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {

      IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);

      if (OMD->getMethodFamily() == OMF_dealloc ||

          
OMD->getMethodFamily() == OMF_initialize2
 ||

          
(1
OMD->getSelector().isUnarySelector()1
 && 
II->isStr(".cxx_destruct")1
)) {

        markAsIgnoreThreadCheckingAtRuntime(Fn);

      }

    }

  }

  // Ignore unrelated casts in STL allocate() since the allocator must cast

  // from void* to T* before object initialization completes. Don't match on the

  // namespace because not all allocators are in std::

  if (D && 
SanOpts.has(SanitizerKind::CFIUnrelatedCast)305k
) {

    if (matchesStlAllocatorFn(D, getContext()))

      SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;

  }

  // Ignore null checks in coroutine functions since the coroutines passes

  // are not aware of how to move the extra UBSan instructions across the split

  // coroutine boundaries.

  if (D && 
SanOpts.has(SanitizerKind::Null)305k
)

    if (FD && FD->getBody() &&

        FD->getBody()->getStmtClass() == Stmt::CoroutineBodyStmtClass)

      SanOpts.Mask &= ~SanitizerKind::Null;

  // Apply xray attributes to the function (as a string, for now)

  bool AlwaysXRayAttr = false;

  if (const auto *XRayAttr = D ? D->getAttr<XRayInstrumentAttr>() : nullptr) {

    if (CGM.getCodeGenOpts().XRayInstrumentationBundle.has(

            XRayInstrKind::FunctionEntry) ||

        CGM.getCodeGenOpts().XRayInstrumentationBundle.has(

            XRayInstrKind::FunctionExit)) {

      if (XRayAttr->alwaysXRayInstrument() && 
ShouldXRayInstrumentFunction()45
) {

        Fn->addFnAttr("function-instrument", "xray-always");

        AlwaysXRayAttr = true;

      }

      if (XRayAttr->neverXRayInstrument())

        Fn->addFnAttr("function-instrument", "xray-never");

      if (const auto *LogArgs = D->getAttr<XRayLogArgsAttr>())

        if (ShouldXRayInstrumentFunction())

          Fn->addFnAttr("xray-log-args",

                        llvm::utostr(LogArgs->getArgumentCount()));

    }

  } else {

    if (ShouldXRayInstrumentFunction() && 
!CGM.imbueXRayAttrs(Fn, Loc)31
)

      Fn->addFnAttr(

          "xray-instruction-threshold",

          llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));

  }

  if (ShouldXRayInstrumentFunction()) {

    if (CGM.getCodeGenOpts().XRayIgnoreLoops)

      Fn->addFnAttr("xray-ignore-loops");

    if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(

            XRayInstrKind::FunctionExit))

      Fn->addFnAttr("xray-skip-exit");

    if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(

            XRayInstrKind::FunctionEntry))

      Fn->addFnAttr("xray-skip-entry");

    auto FuncGroups = CGM.getCodeGenOpts().XRayTotalFunctionGroups;

    if (FuncGroups > 1) {

      auto FuncName = llvm::makeArrayRef<uint8_t>(

          CurFn->getName().bytes_begin(), CurFn->getName().bytes_end());

      auto Group = crc32(FuncName) % FuncGroups;

      if (Group != CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&

          
!AlwaysXRayAttr10
)

        Fn->addFnAttr("function-instrument", "xray-never");

    }

  }

  if (CGM.getCodeGenOpts().getProfileInstr() != CodeGenOptions::ProfileNone)

    if (CGM.isProfileInstrExcluded(Fn, Loc))

      Fn->addFnAttr(llvm::Attribute::NoProfile);

  unsigned Count, Offset;

  if (const auto *Attr =

          D ? D->getAttr<PatchableFunctionEntryAttr>() : nullptr) {

    Count = Attr->getCount();

    Offset = Attr->getOffset();

  } else {

    Count = CGM.getCodeGenOpts().PatchableFunctionEntryCount;

    Offset = CGM.getCodeGenOpts().PatchableFunctionEntryOffset;

  }

  if (Count && 
Offset <= Count16
) {

    Fn->addFnAttr("patchable-function-entry", std::to_string(Count - Offset));

    if (Offset)

      Fn->addFnAttr("patchable-function-prefix", std::to_string(Offset));

  }

  // Instruct that functions for COFF/CodeView targets should start with a

  // patchable instruction, but only on x86/x64. Don't forward this to ARM/ARM64

  // backends as they don't need it -- instructions on these architectures are

  // always atomically patchable at runtime.

  if (CGM.getCodeGenOpts().HotPatch &&

      
getContext().getTargetInfo().getTriple().isX86()11
)

    Fn->addFnAttr("patchable-function", "prologue-short-redirect");

  // Add no-jump-tables value.

  if (CGM.getCodeGenOpts().NoUseJumpTables)

    Fn->addFnAttr("no-jump-tables", "true");

  // Add no-inline-line-tables value.

  if (CGM.getCodeGenOpts().NoInlineLineTables)

    Fn->addFnAttr("no-inline-line-tables");

  // Add profile-sample-accurate value.

  if (CGM.getCodeGenOpts().ProfileSampleAccurate)

    Fn->addFnAttr("profile-sample-accurate");

  if (!CGM.getCodeGenOpts().SampleProfileFile.empty())

    Fn->addFnAttr("use-sample-profile");

  if (D && 
D->hasAttr<CFICanonicalJumpTableAttr>()305k
)

    Fn->addFnAttr("cfi-canonical-jump-table");

  if (D && 
D->hasAttr<NoProfileFunctionAttr>()305k
)

    Fn->addFnAttr(llvm::Attribute::NoProfile);

  if (FD && 
getLangOpts().OpenCL270k
) {

    // Add metadata for a kernel function.

    EmitOpenCLKernelMetadata(FD, Fn);

  }

  // If we are checking function types, emit a function type signature as

  // prologue data.

  if (FD && 
getLangOpts().CPlusPlus270k
 && 
SanOpts.has(SanitizerKind::Function)186k
) {

    if (llvm::Constant *PrologueSig = getPrologueSignature(CGM, FD)) {

      // Remove any (C++17) exception specifications, to allow calling e.g. a

      // noexcept function through a non-noexcept pointer.

      auto ProtoTy = getContext().getFunctionTypeWithExceptionSpec(

          FD->getType(), EST_None);

      llvm::Constant *FTRTTIConst =

          CGM.GetAddrOfRTTIDescriptor(ProtoTy, /*ForEH=*/true);

      llvm::Constant *FTRTTIConstEncoded =

          EncodeAddrForUseInPrologue(Fn, FTRTTIConst);

      llvm::Constant *PrologueStructElems[] = {PrologueSig, FTRTTIConstEncoded};

      llvm::Constant *PrologueStructConst =

          llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);

      Fn->setPrologueData(PrologueStructConst);

    }

  }

  // If we're checking nullability, we need to know whether we can check the

  // return value. Initialize the flag to 'true' and refine it in EmitParmDecl.

  if (SanOpts.has(SanitizerKind::NullabilityReturn)) {

    auto Nullability = FnRetTy->getNullability(getContext());

    if (Nullability && 
*Nullability == NullabilityKind::NonNull17
) {

      if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&

            
CurCodeDecl1
 && 
CurCodeDecl->getAttr<ReturnsNonNullAttr>()1
))

        RetValNullabilityPrecondition =

            llvm::ConstantInt::getTrue(getLLVMContext());

    }

  }

  // If we're in C++ mode and the function name is "main", it is guaranteed

  // to be norecurse by the standard (3.6.1.3 "The function main shall not be

  // used within a program").

  //

  // OpenCL C 2.0 v2.2-11 s6.9.i:

  //     Recursion is not supported.

  //

  // SYCL v1.2.1 s3.10:

  //     kernels cannot include RTTI information, exception classes,

  //     recursive code, virtual functions or make use of C++ libraries that

  //     are not compiled for the device.

  if (FD && 
(270k
(270k
getLangOpts().CPlusPlus270k
 && 
FD->isMain()186k
) ||

             
getLangOpts().OpenCL266k
 || 
getLangOpts().SYCLIsDevice265k
 ||

             
(265k
getLangOpts().CUDA265k
 && 
FD->hasAttr<CUDAGlobalAttr>()604
)))

    Fn->addFnAttr(llvm::Attribute::NoRecurse);

  llvm::RoundingMode RM = getLangOpts().getFPRoundingMode();

  llvm::fp::ExceptionBehavior FPExceptionBehavior =

      ToConstrainedExceptMD(getLangOpts().getFPExceptionMode());

  Builder.setDefaultConstrainedRounding(RM);

  Builder.setDefaultConstrainedExcept(FPExceptionBehavior);

  if ((FD && 
(270k
FD->UsesFPIntrin()270k
 || 
FD->hasAttr<StrictFPAttr>()269k
)) ||

      
(313k
!FD313k
 && 
(44.1k
FPExceptionBehavior != llvm::fp::ebIgnore44.1k
 ||

               
RM != llvm::RoundingMode::NearestTiesToEven44.1k
))) {

    Builder.setIsFPConstrained(true);

    Fn->addFnAttr(llvm::Attribute::StrictFP);

  }

  // If a custom alignment is used, force realigning to this alignment on

  // any main function which certainly will need it.

  if (FD && 
(270k
(270k
FD->isMain()270k
 || 
FD->isMSVCRTEntryPoint()265k
) &&

             
CGM.getCodeGenOpts().StackAlignment5.67k
))

    Fn->addFnAttr("stackrealign");

  // "main" doesn't need to zero out call-used registers.

  if (FD && 
FD->isMain()270k
)

    Fn->removeFnAttr("zero-call-used-regs");

  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);

  // Create a marker to make it easy to insert allocas into the entryblock

  // later.  Don't create this with the builder, because we don't want it

  // folded.

  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);

  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "allocapt", EntryBB);

  ReturnBlock = getJumpDestInCurrentScope("return");

  Builder.SetInsertPoint(EntryBB);

  // If we're checking the return value, allocate space for a pointer to a

  // precise source location of the checked return statement.

  if (requiresReturnValueCheck()) {

    ReturnLocation = CreateDefaultAlignTempAlloca(Int8PtrTy, "return.sloc.ptr");

    Builder.CreateStore(llvm::ConstantPointerNull::get(Int8PtrTy),

                        ReturnLocation);

  }