//===--- 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 "CGHLSLRuntime.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/Support/xxhash.h"

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

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

#include <optional>

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) ||

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

    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 && CurFn)

    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 && CurFn)

    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;

  default:

    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 = FPFeatures.getRoundingMode();

  CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);

  auto NewExceptionBehavior =

      ToConstrainedExceptMD(static_cast<LangOptions::FPExceptionModeKind>(

          FPFeatures.getExceptionMode()));

  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() &&

          FPFeatures.getAllowApproxFunc() && FPFeatures.getNoSignedZero() &&

          FPFeatures.allowFPContractAcrossStatement());

}

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()) {

      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() &&

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

      // 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) return;

  if (!BB->use_empty()) {

    CGF.CurFn->insert(CGF.CurFn->end(), BB);

    return;

  }

  delete BB;

}

void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {

  assert(BreakContinueStack.empty() &&

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

  bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0

    && NumSimpleReturnExprs == NumReturnExprs

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

  // 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);

  bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;

  std::optional<ApplyDebugLocation> OAL;

  if (HasCleanups) {

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

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

    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.

        OAL = 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()) {

    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().getKnownMinValue());

  // Update vector width based on return type.

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

    LargestVectorWidth =

        std::max((uint64_t)LargestVectorWidth,

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

  if (CurFnInfo->getMaxVectorWidth() > LargestVectorWidth)

    LargestVectorWidth = CurFnInfo->getMaxVectorWidth();

  // Add the min-legal-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 arguments and return types for functions called by this

  //    function.

  if (getContext().getTargetInfo().getTriple().isX86())

    CurFn->addFnAttr("min-legal-vector-width",

                     llvm::utostr(LargestVectorWidth));

  // Add vscale_range attribute if appropriate.

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

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

  if (VScaleRange) {

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

        getLLVMContext(), VScaleRange->first, VScaleRange->second));

  }

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

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

    Builder.ClearInsertionPoint();

    ReturnBlock.getBlock()->eraseFromParent();

  }

  if (ReturnValue.isValid()) {

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

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

      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().InstrumentFunctionsAfterInlining &&

      !CGM.getCodeGenOpts().InstrumentFunctionEntryBare)

    return false;

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

    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::ConstantInt *

CodeGenFunction::getUBSanFunctionTypeHash(QualType Ty) const {

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

  // noexcept function through a non-noexcept pointer.

  if (!Ty->isFunctionNoProtoType())

    Ty = getContext().getFunctionTypeWithExceptionSpec(Ty, EST_None);

  std::string Mangled;

  llvm::raw_string_ostream Out(Mangled);

  CGM.getCXXABI().getMangleContext().mangleCanonicalTypeName(Ty, Out, false);

  return llvm::ConstantInt::get(

      CGM.Int32Ty, static_cast<uint32_t>(llvm::xxh3_64bits(Mangled)));

}

void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,

                                         llvm::Function *Fn) {

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

    return;

  llvm::LLVMContext &Context = getLLVMContext();

  CGM.GenKernelArgMetadata(Fn, FD, this);

  if (!getLangOpts().OpenCL)

    return;

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

    QualType HintQTy = A->getTypeHint();

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

    bool IsSignedInteger =

        HintQTy->isSignedIntegerType() ||

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

    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 ? 1 : 0))))};

    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() ||

         (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) && CurCodeDecl &&

          CurCodeDecl->getAttr<ReturnsNonNullAttr>());

}

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

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

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

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

      (MD->getNumParams() != 1 && MD->getNumParams() != 2))

    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;

}

bool CodeGenFunction::isInAllocaArgument(CGCXXABI &ABI, QualType Ty) {

  const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();

  return RD && ABI.getRecordArgABI(RD) == CGCXXABI::RAA_DirectInMemory;

}

bool CodeGenFunction::hasInAllocaArg(const CXXMethodDecl *MD) {

  return getTarget().getTriple().getArch() == llvm::Triple::x86 &&

         getTarget().getCXXABI().isMicrosoft() &&

         llvm::any_of(MD->parameters(), [&](ParmVarDecl *P) {

           return isInAllocaArgument(CGM.getCXXABI(), P->getType());

         });

}

/// 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())

    CurSEHParent = GD;

  CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);

  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())                                                         \

    break;                                                                     \

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

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

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

#include "clang/Basic/Sanitizers.def"

#undef SANITIZER

  } while (false);

  if (D) {

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

    SanitizerMask no_sanitize_mask;

    bool NoSanitizeCoverage = false;

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

      no_sanitize_mask |= Attr->getMask();

      // SanitizeCoverage is not handled by SanOpts.

      if (Attr->hasCoverage())

        NoSanitizeCoverage = true;

    }

    // Apply the no_sanitize* attributes to SanOpts.

    SanOpts.Mask &= ~no_sanitize_mask;

    if (no_sanitize_mask & SanitizerKind::Address)

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

    if (no_sanitize_mask & SanitizerKind::KernelAddress)

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

    if (no_sanitize_mask & SanitizerKind::HWAddress)

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

    if (no_sanitize_mask & SanitizerKind::KernelHWAddress)

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

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

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

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

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

    // Some passes need the non-negated no_sanitize attribute. Pass them on.

    if (CGM.getCodeGenOpts().hasSanitizeBinaryMetadata()) {

      if (no_sanitize_mask & SanitizerKind::Thread)

        Fn->addFnAttr("no_sanitize_thread");

    }

  }

  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_initialize ||

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

        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)) {

    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))

    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()) {

        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))

      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::ArrayRef<uint8_t>(CurFn->getName().bytes_begin(),

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

      auto Group = crc32(FuncName) % FuncGroups;

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

          !AlwaysXRayAttr)

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