//===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//

//

// 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 contains code to emit Builtin calls as LLVM code.

//

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

#include "ABIInfo.h"

#include "CGCUDARuntime.h"

#include "CGCXXABI.h"

#include "CGObjCRuntime.h"

#include "CGOpenCLRuntime.h"

#include "CGRecordLayout.h"

#include "CodeGenFunction.h"

#include "CodeGenModule.h"

#include "ConstantEmitter.h"

#include "PatternInit.h"

#include "TargetInfo.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/Decl.h"

#include "clang/AST/OSLog.h"

#include "clang/AST/OperationKinds.h"

#include "clang/Basic/TargetBuiltins.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TargetOptions.h"

#include "clang/CodeGen/CGFunctionInfo.h"

#include "clang/Frontend/FrontendDiagnostic.h"

#include "llvm/ADT/APFloat.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/FloatingPointMode.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Analysis/ValueTracking.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/InlineAsm.h"

#include "llvm/IR/Intrinsics.h"

#include "llvm/IR/IntrinsicsAArch64.h"

#include "llvm/IR/IntrinsicsAMDGPU.h"

#include "llvm/IR/IntrinsicsARM.h"

#include "llvm/IR/IntrinsicsBPF.h"

#include "llvm/IR/IntrinsicsHexagon.h"

#include "llvm/IR/IntrinsicsNVPTX.h"

#include "llvm/IR/IntrinsicsPowerPC.h"

#include "llvm/IR/IntrinsicsR600.h"

#include "llvm/IR/IntrinsicsRISCV.h"

#include "llvm/IR/IntrinsicsS390.h"

#include "llvm/IR/IntrinsicsVE.h"

#include "llvm/IR/IntrinsicsWebAssembly.h"

#include "llvm/IR/IntrinsicsX86.h"

#include "llvm/IR/MDBuilder.h"

#include "llvm/IR/MatrixBuilder.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/ScopedPrinter.h"

#include "llvm/TargetParser/AArch64TargetParser.h"

#include "llvm/TargetParser/X86TargetParser.h"

#include <optional>

#include <sstream>

using namespace clang;

using namespace CodeGen;

using namespace llvm;

static void initializeAlloca(CodeGenFunction &CGF, AllocaInst *AI, Value *Size,

                             Align AlignmentInBytes) {

  ConstantInt *Byte;

  switch (CGF.getLangOpts().getTrivialAutoVarInit()) {

  case LangOptions::TrivialAutoVarInitKind::Uninitialized:

    // Nothing to initialize.

    return;

  case LangOptions::TrivialAutoVarInitKind::Zero:

    Byte = CGF.Builder.getInt8(0x00);

    break;

  case LangOptions::TrivialAutoVarInitKind::Pattern: {

    llvm::Type *Int8 = llvm::IntegerType::getInt8Ty(CGF.CGM.getLLVMContext());

    Byte = llvm::dyn_cast<llvm::ConstantInt>(

        initializationPatternFor(CGF.CGM, Int8));

    break;

  }

  }

  if (CGF.CGM.stopAutoInit())

    return;

  auto *I = CGF.Builder.CreateMemSet(AI, Byte, Size, AlignmentInBytes);

  I->addAnnotationMetadata("auto-init");

}

/// getBuiltinLibFunction - Given a builtin id for a function like

/// "__builtin_fabsf", return a Function* for "fabsf".

llvm::Constant *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,

                                                     unsigned BuiltinID) {

  assert(Context.BuiltinInfo.isLibFunction(BuiltinID));

  // Get the name, skip over the __builtin_ prefix (if necessary).

  StringRef Name;

  GlobalDecl D(FD);

  // TODO: This list should be expanded or refactored after all GCC-compatible

  // std libcall builtins are implemented.

  static SmallDenseMap<unsigned, StringRef, 64> F128Builtins{

      {Builtin::BI__builtin___fprintf_chk, "__fprintf_chkieee128"},

      {Builtin::BI__builtin___printf_chk, "__printf_chkieee128"},

      {Builtin::BI__builtin___snprintf_chk, "__snprintf_chkieee128"},

      {Builtin::BI__builtin___sprintf_chk, "__sprintf_chkieee128"},

      {Builtin::BI__builtin___vfprintf_chk, "__vfprintf_chkieee128"},

      {Builtin::BI__builtin___vprintf_chk, "__vprintf_chkieee128"},

      {Builtin::BI__builtin___vsnprintf_chk, "__vsnprintf_chkieee128"},

      {Builtin::BI__builtin___vsprintf_chk, "__vsprintf_chkieee128"},

      {Builtin::BI__builtin_fprintf, "__fprintfieee128"},

      {Builtin::BI__builtin_printf, "__printfieee128"},

      {Builtin::BI__builtin_snprintf, "__snprintfieee128"},

      {Builtin::BI__builtin_sprintf, "__sprintfieee128"},

      {Builtin::BI__builtin_vfprintf, "__vfprintfieee128"},

      {Builtin::BI__builtin_vprintf, "__vprintfieee128"},

      {Builtin::BI__builtin_vsnprintf, "__vsnprintfieee128"},

      {Builtin::BI__builtin_vsprintf, "__vsprintfieee128"},

      {Builtin::BI__builtin_fscanf, "__fscanfieee128"},

      {Builtin::BI__builtin_scanf, "__scanfieee128"},

      {Builtin::BI__builtin_sscanf, "__sscanfieee128"},

      {Builtin::BI__builtin_vfscanf, "__vfscanfieee128"},

      {Builtin::BI__builtin_vscanf, "__vscanfieee128"},

      {Builtin::BI__builtin_vsscanf, "__vsscanfieee128"},

      {Builtin::BI__builtin_nexttowardf128, "__nexttowardieee128"},

  };

  // The AIX library functions frexpl, ldexpl, and modfl are for 128-bit

  // IBM 'long double' (i.e. __ibm128). Map to the 'double' versions

  // if it is 64-bit 'long double' mode.

  static SmallDenseMap<unsigned, StringRef, 4> AIXLongDouble64Builtins{

      {Builtin::BI__builtin_frexpl, "frexp"},

      {Builtin::BI__builtin_ldexpl, "ldexp"},

      {Builtin::BI__builtin_modfl, "modf"},

  };

  // If the builtin has been declared explicitly with an assembler label,

  // use the mangled name. This differs from the plain label on platforms

  // that prefix labels.

  if (FD->hasAttr<AsmLabelAttr>())

    Name = getMangledName(D);

  else {

    // TODO: This mutation should also be applied to other targets other than

    // PPC, after backend supports IEEE 128-bit style libcalls.

    if (getTriple().isPPC64() &&

        &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad() &&

        F128Builtins.contains(BuiltinID))

      Name = F128Builtins[BuiltinID];

    else if (getTriple().isOSAIX() &&

             &getTarget().getLongDoubleFormat() ==

                 &llvm::APFloat::IEEEdouble() &&

             AIXLongDouble64Builtins.contains(BuiltinID))

      Name = AIXLongDouble64Builtins[BuiltinID];

    else

      Name = Context.BuiltinInfo.getName(BuiltinID).substr(10);

  }

  llvm::FunctionType *Ty =

    cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));

  return GetOrCreateLLVMFunction(Name, Ty, D, /*ForVTable=*/false);

}

/// Emit the conversions required to turn the given value into an

/// integer of the given size.

static Value *EmitToInt(CodeGenFunction &CGF, llvm::Value *V,

                        QualType T, llvm::IntegerType *IntType) {

  V = CGF.EmitToMemory(V, T);

  if (V->getType()->isPointerTy())

    return CGF.Builder.CreatePtrToInt(V, IntType);

  assert(V->getType() == IntType);

  return V;

}

static Value *EmitFromInt(CodeGenFunction &CGF, llvm::Value *V,

                          QualType T, llvm::Type *ResultType) {

  V = CGF.EmitFromMemory(V, T);

  if (ResultType->isPointerTy())

    return CGF.Builder.CreateIntToPtr(V, ResultType);

  assert(V->getType() == ResultType);

  return V;

}

static Address CheckAtomicAlignment(CodeGenFunction &CGF, const CallExpr *E) {

  ASTContext &Ctx = CGF.getContext();

  Address Ptr = CGF.EmitPointerWithAlignment(E->getArg(0));

  unsigned Bytes = Ptr.getElementType()->isPointerTy()

                       ? Ctx.getTypeSizeInChars(Ctx.VoidPtrTy).getQuantity()

                       : Ptr.getElementType()->getScalarSizeInBits() / 8;

  unsigned Align = Ptr.getAlignment().getQuantity();

  if (Align % Bytes != 0) {

    DiagnosticsEngine &Diags = CGF.CGM.getDiags();

    Diags.Report(E->getBeginLoc(), diag::warn_sync_op_misaligned);

    // Force address to be at least naturally-aligned.

    return Ptr.withAlignment(CharUnits::fromQuantity(Bytes));

  }

  return Ptr;

}

/// Utility to insert an atomic instruction based on Intrinsic::ID

/// and the expression node.

static Value *MakeBinaryAtomicValue(

    CodeGenFunction &CGF, llvm::AtomicRMWInst::BinOp Kind, const CallExpr *E,

    AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {

  QualType T = E->getType();

  assert(E->getArg(0)->getType()->isPointerType());

  assert(CGF.getContext().hasSameUnqualifiedType(T,

                                  E->getArg(0)->getType()->getPointeeType()));

  assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  llvm::IntegerType *IntType = llvm::IntegerType::get(

      CGF.getLLVMContext(), CGF.getContext().getTypeSize(T));

  llvm::Value *Val = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Type *ValueType = Val->getType();

  Val = EmitToInt(CGF, Val, T, IntType);

  llvm::Value *Result =

      CGF.Builder.CreateAtomicRMW(Kind, DestAddr, Val, Ordering);

  return EmitFromInt(CGF, Result, T, ValueType);

}

static Value *EmitNontemporalStore(CodeGenFunction &CGF, const CallExpr *E) {

  Value *Val = CGF.EmitScalarExpr(E->getArg(0));

  Address Addr = CGF.EmitPointerWithAlignment(E->getArg(1));

  Val = CGF.EmitToMemory(Val, E->getArg(0)->getType());

  LValue LV = CGF.MakeAddrLValue(Addr, E->getArg(0)->getType());

  LV.setNontemporal(true);

  CGF.EmitStoreOfScalar(Val, LV, false);

  return nullptr;

}

static Value *EmitNontemporalLoad(CodeGenFunction &CGF, const CallExpr *E) {

  Address Addr = CGF.EmitPointerWithAlignment(E->getArg(0));

  LValue LV = CGF.MakeAddrLValue(Addr, E->getType());

  LV.setNontemporal(true);

  return CGF.EmitLoadOfScalar(LV, E->getExprLoc());

}

static RValue EmitBinaryAtomic(CodeGenFunction &CGF,

                               llvm::AtomicRMWInst::BinOp Kind,

                               const CallExpr *E) {

  return RValue::get(MakeBinaryAtomicValue(CGF, Kind, E));

}

/// Utility to insert an atomic instruction based Intrinsic::ID and

/// the expression node, where the return value is the result of the

/// operation.

static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF,

                                   llvm::AtomicRMWInst::BinOp Kind,

                                   const CallExpr *E,

                                   Instruction::BinaryOps Op,

                                   bool Invert = false) {

  QualType T = E->getType();

  assert(E->getArg(0)->getType()->isPointerType());

  assert(CGF.getContext().hasSameUnqualifiedType(T,

                                  E->getArg(0)->getType()->getPointeeType()));

  assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  llvm::IntegerType *IntType = llvm::IntegerType::get(

      CGF.getLLVMContext(), CGF.getContext().getTypeSize(T));

  llvm::Value *Val = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Type *ValueType = Val->getType();

  Val = EmitToInt(CGF, Val, T, IntType);

  llvm::Value *Result = CGF.Builder.CreateAtomicRMW(

      Kind, DestAddr, Val, llvm::AtomicOrdering::SequentiallyConsistent);

  Result = CGF.Builder.CreateBinOp(Op, Result, Val);

  if (Invert)

    Result =

        CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,

                                llvm::ConstantInt::getAllOnesValue(IntType));

  Result = EmitFromInt(CGF, Result, T, ValueType);

  return RValue::get(Result);

}

/// Utility to insert an atomic cmpxchg instruction.

///

/// @param CGF The current codegen function.

/// @param E   Builtin call expression to convert to cmpxchg.

///            arg0 - address to operate on

///            arg1 - value to compare with

///            arg2 - new value

/// @param ReturnBool Specifies whether to return success flag of

///                   cmpxchg result or the old value.

///

/// @returns result of cmpxchg, according to ReturnBool

///

/// Note: In order to lower Microsoft's _InterlockedCompareExchange* intrinsics

/// invoke the function EmitAtomicCmpXchgForMSIntrin.

static Value *MakeAtomicCmpXchgValue(CodeGenFunction &CGF, const CallExpr *E,

                                     bool ReturnBool) {

  QualType T = ReturnBool ? E->getArg(1)->getType() : E->getType();

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  llvm::IntegerType *IntType = llvm::IntegerType::get(

      CGF.getLLVMContext(), CGF.getContext().getTypeSize(T));

  Value *Cmp = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Type *ValueType = Cmp->getType();

  Cmp = EmitToInt(CGF, Cmp, T, IntType);

  Value *New = EmitToInt(CGF, CGF.EmitScalarExpr(E->getArg(2)), T, IntType);

  Value *Pair = CGF.Builder.CreateAtomicCmpXchg(

      DestAddr, Cmp, New, llvm::AtomicOrdering::SequentiallyConsistent,

      llvm::AtomicOrdering::SequentiallyConsistent);

  if (ReturnBool)

    // Extract boolean success flag and zext it to int.

    return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),

                                  CGF.ConvertType(E->getType()));

  else

    // Extract old value and emit it using the same type as compare value.

    return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T,

                       ValueType);

}

/// This function should be invoked to emit atomic cmpxchg for Microsoft's

/// _InterlockedCompareExchange* intrinsics which have the following signature:

/// T _InterlockedCompareExchange(T volatile *Destination,

///                               T Exchange,

///                               T Comparand);

///

/// Whereas the llvm 'cmpxchg' instruction has the following syntax:

/// cmpxchg *Destination, Comparand, Exchange.

/// So we need to swap Comparand and Exchange when invoking

/// CreateAtomicCmpXchg. That is the reason we could not use the above utility

/// function MakeAtomicCmpXchgValue since it expects the arguments to be

/// already swapped.

static

Value *EmitAtomicCmpXchgForMSIntrin(CodeGenFunction &CGF, const CallExpr *E,

    AtomicOrdering SuccessOrdering = AtomicOrdering::SequentiallyConsistent) {

  assert(E->getArg(0)->getType()->isPointerType());

  assert(CGF.getContext().hasSameUnqualifiedType(

      E->getType(), E->getArg(0)->getType()->getPointeeType()));

  assert(CGF.getContext().hasSameUnqualifiedType(E->getType(),

                                                 E->getArg(1)->getType()));

  assert(CGF.getContext().hasSameUnqualifiedType(E->getType(),

                                                 E->getArg(2)->getType()));

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  auto *Comparand = CGF.EmitScalarExpr(E->getArg(2));

  auto *Exchange = CGF.EmitScalarExpr(E->getArg(1));

  // For Release ordering, the failure ordering should be Monotonic.

  auto FailureOrdering = SuccessOrdering == AtomicOrdering::Release ?

                         AtomicOrdering::Monotonic :

                         SuccessOrdering;

  // The atomic instruction is marked volatile for consistency with MSVC. This

  // blocks the few atomics optimizations that LLVM has. If we want to optimize

  // _Interlocked* operations in the future, we will have to remove the volatile

  // marker.

  auto *Result = CGF.Builder.CreateAtomicCmpXchg(

      DestAddr, Comparand, Exchange, SuccessOrdering, FailureOrdering);

  Result->setVolatile(true);

  return CGF.Builder.CreateExtractValue(Result, 0);

}

// 64-bit Microsoft platforms support 128 bit cmpxchg operations. They are

// prototyped like this:

//

// unsigned char _InterlockedCompareExchange128...(

//     __int64 volatile * _Destination,

//     __int64 _ExchangeHigh,

//     __int64 _ExchangeLow,

//     __int64 * _ComparandResult);

//

// Note that Destination is assumed to be at least 16-byte aligned, despite

// being typed int64.

static Value *EmitAtomicCmpXchg128ForMSIntrin(CodeGenFunction &CGF,

                                              const CallExpr *E,

                                              AtomicOrdering SuccessOrdering) {

  assert(E->getNumArgs() == 4);

  llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *ExchangeHigh = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Value *ExchangeLow = CGF.EmitScalarExpr(E->getArg(2));

  Address ComparandAddr = CGF.EmitPointerWithAlignment(E->getArg(3));

  assert(DestPtr->getType()->isPointerTy());

  assert(!ExchangeHigh->getType()->isPointerTy());

  assert(!ExchangeLow->getType()->isPointerTy());

  // For Release ordering, the failure ordering should be Monotonic.

  auto FailureOrdering = SuccessOrdering == AtomicOrdering::Release

                             ? AtomicOrdering::Monotonic

                             : SuccessOrdering;

  // Convert to i128 pointers and values. Alignment is also overridden for

  // destination pointer.

  llvm::Type *Int128Ty = llvm::IntegerType::get(CGF.getLLVMContext(), 128);

  Address DestAddr(DestPtr, Int128Ty,

                   CGF.getContext().toCharUnitsFromBits(128));

  ComparandAddr = ComparandAddr.withElementType(Int128Ty);

  // (((i128)hi) << 64) | ((i128)lo)

  ExchangeHigh = CGF.Builder.CreateZExt(ExchangeHigh, Int128Ty);

  ExchangeLow = CGF.Builder.CreateZExt(ExchangeLow, Int128Ty);

  ExchangeHigh =

      CGF.Builder.CreateShl(ExchangeHigh, llvm::ConstantInt::get(Int128Ty, 64));

  llvm::Value *Exchange = CGF.Builder.CreateOr(ExchangeHigh, ExchangeLow);

  // Load the comparand for the instruction.

  llvm::Value *Comparand = CGF.Builder.CreateLoad(ComparandAddr);

  auto *CXI = CGF.Builder.CreateAtomicCmpXchg(DestAddr, Comparand, Exchange,

                                              SuccessOrdering, FailureOrdering);

  // The atomic instruction is marked volatile for consistency with MSVC. This

  // blocks the few atomics optimizations that LLVM has. If we want to optimize

  // _Interlocked* operations in the future, we will have to remove the volatile

  // marker.

  CXI->setVolatile(true);

  // Store the result as an outparameter.

  CGF.Builder.CreateStore(CGF.Builder.CreateExtractValue(CXI, 0),

                          ComparandAddr);

  // Get the success boolean and zero extend it to i8.

  Value *Success = CGF.Builder.CreateExtractValue(CXI, 1);

  return CGF.Builder.CreateZExt(Success, CGF.Int8Ty);

}

static Value *EmitAtomicIncrementValue(CodeGenFunction &CGF, const CallExpr *E,

    AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {

  assert(E->getArg(0)->getType()->isPointerType());

  auto *IntTy = CGF.ConvertType(E->getType());

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  auto *Result = CGF.Builder.CreateAtomicRMW(

      AtomicRMWInst::Add, DestAddr, ConstantInt::get(IntTy, 1), Ordering);

  return CGF.Builder.CreateAdd(Result, ConstantInt::get(IntTy, 1));

}

static Value *EmitAtomicDecrementValue(

    CodeGenFunction &CGF, const CallExpr *E,

    AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {

  assert(E->getArg(0)->getType()->isPointerType());

  auto *IntTy = CGF.ConvertType(E->getType());

  Address DestAddr = CheckAtomicAlignment(CGF, E);

  auto *Result = CGF.Builder.CreateAtomicRMW(

      AtomicRMWInst::Sub, DestAddr, ConstantInt::get(IntTy, 1), Ordering);

  return CGF.Builder.CreateSub(Result, ConstantInt::get(IntTy, 1));

}

// Build a plain volatile load.

static Value *EmitISOVolatileLoad(CodeGenFunction &CGF, const CallExpr *E) {

  Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));

  QualType ElTy = E->getArg(0)->getType()->getPointeeType();

  CharUnits LoadSize = CGF.getContext().getTypeSizeInChars(ElTy);

  llvm::Type *ITy =

      llvm::IntegerType::get(CGF.getLLVMContext(), LoadSize.getQuantity() * 8);

  llvm::LoadInst *Load = CGF.Builder.CreateAlignedLoad(ITy, Ptr, LoadSize);

  Load->setVolatile(true);

  return Load;

}

// Build a plain volatile store.

static Value *EmitISOVolatileStore(CodeGenFunction &CGF, const CallExpr *E) {

  Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));

  Value *Value = CGF.EmitScalarExpr(E->getArg(1));

  QualType ElTy = E->getArg(0)->getType()->getPointeeType();

  CharUnits StoreSize = CGF.getContext().getTypeSizeInChars(ElTy);

  llvm::StoreInst *Store =

      CGF.Builder.CreateAlignedStore(Value, Ptr, StoreSize);

  Store->setVolatile(true);

  return Store;

}

// Emit a simple mangled intrinsic that has 1 argument and a return type

// matching the argument type. Depending on mode, this may be a constrained

// floating-point intrinsic.

static Value *emitUnaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,

                                const CallExpr *E, unsigned IntrinsicID,

                                unsigned ConstrainedIntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

  if (CGF.Builder.getIsFPConstrained()) {

    Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());

    return CGF.Builder.CreateConstrainedFPCall(F, { Src0 });

  } else {

    Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

    return CGF.Builder.CreateCall(F, Src0);

  }

}

// Emit an intrinsic that has 2 operands of the same type as its result.

// Depending on mode, this may be a constrained floating-point intrinsic.

static Value *emitBinaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,

                                const CallExpr *E, unsigned IntrinsicID,

                                unsigned ConstrainedIntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  if (CGF.Builder.getIsFPConstrained()) {

    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

    Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());

    return CGF.Builder.CreateConstrainedFPCall(F, { Src0, Src1 });

  } else {

    Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

    return CGF.Builder.CreateCall(F, { Src0, Src1 });

  }

}

// Has second type mangled argument.

static Value *emitBinaryExpMaybeConstrainedFPBuiltin(

    CodeGenFunction &CGF, const CallExpr *E, llvm::Intrinsic::ID IntrinsicID,

    llvm::Intrinsic::ID ConstrainedIntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  if (CGF.Builder.getIsFPConstrained()) {

    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

    Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID,

                                       {Src0->getType(), Src1->getType()});

    return CGF.Builder.CreateConstrainedFPCall(F, {Src0, Src1});

  }

  Function *F =

      CGF.CGM.getIntrinsic(IntrinsicID, {Src0->getType(), Src1->getType()});

  return CGF.Builder.CreateCall(F, {Src0, Src1});

}

// Emit an intrinsic that has 3 operands of the same type as its result.

// Depending on mode, this may be a constrained floating-point intrinsic.

static Value *emitTernaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,

                                 const CallExpr *E, unsigned IntrinsicID,

                                 unsigned ConstrainedIntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));

  if (CGF.Builder.getIsFPConstrained()) {

    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

    Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());

    return CGF.Builder.CreateConstrainedFPCall(F, { Src0, Src1, Src2 });

  } else {

    Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

    return CGF.Builder.CreateCall(F, { Src0, Src1, Src2 });

  }

}

// Emit an intrinsic where all operands are of the same type as the result.

// Depending on mode, this may be a constrained floating-point intrinsic.

static Value *emitCallMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,

                                                unsigned IntrinsicID,

                                                unsigned ConstrainedIntrinsicID,

                                                llvm::Type *Ty,

                                                ArrayRef<Value *> Args) {

  Function *F;

  if (CGF.Builder.getIsFPConstrained())

    F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Ty);

  else

    F = CGF.CGM.getIntrinsic(IntrinsicID, Ty);

  if (CGF.Builder.getIsFPConstrained())

    return CGF.Builder.CreateConstrainedFPCall(F, Args);

  else

    return CGF.Builder.CreateCall(F, Args);

}

// Emit a simple mangled intrinsic that has 1 argument and a return type

// matching the argument type.

static Value *emitUnaryBuiltin(CodeGenFunction &CGF, const CallExpr *E,

                               unsigned IntrinsicID,

                               llvm::StringRef Name = "") {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

  return CGF.Builder.CreateCall(F, Src0, Name);

}

// Emit an intrinsic that has 2 operands of the same type as its result.

static Value *emitBinaryBuiltin(CodeGenFunction &CGF,

                                const CallExpr *E,

                                unsigned IntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

  return CGF.Builder.CreateCall(F, { Src0, Src1 });

}

// Emit an intrinsic that has 3 operands of the same type as its result.

static Value *emitTernaryBuiltin(CodeGenFunction &CGF,

                                 const CallExpr *E,

                                 unsigned IntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));

  Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

  return CGF.Builder.CreateCall(F, { Src0, Src1, Src2 });

}

// Emit an intrinsic that has 1 float or double operand, and 1 integer.

static Value *emitFPIntBuiltin(CodeGenFunction &CGF,

                               const CallExpr *E,

                               unsigned IntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());

  return CGF.Builder.CreateCall(F, {Src0, Src1});

}

// Emit an intrinsic that has overloaded integer result and fp operand.

static Value *

emitMaybeConstrainedFPToIntRoundBuiltin(CodeGenFunction &CGF, const CallExpr *E,

                                        unsigned IntrinsicID,

                                        unsigned ConstrainedIntrinsicID) {

  llvm::Type *ResultType = CGF.ConvertType(E->getType());

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  if (CGF.Builder.getIsFPConstrained()) {

    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);

    Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID,

                                       {ResultType, Src0->getType()});

    return CGF.Builder.CreateConstrainedFPCall(F, {Src0});

  } else {

    Function *F =

        CGF.CGM.getIntrinsic(IntrinsicID, {ResultType, Src0->getType()});

    return CGF.Builder.CreateCall(F, Src0);

  }

}

static Value *emitFrexpBuiltin(CodeGenFunction &CGF, const CallExpr *E,

                               llvm::Intrinsic::ID IntrinsicID) {

  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));

  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));

  QualType IntPtrTy = E->getArg(1)->getType()->getPointeeType();

  llvm::Type *IntTy = CGF.ConvertType(IntPtrTy);

  llvm::Function *F =

      CGF.CGM.getIntrinsic(IntrinsicID, {Src0->getType(), IntTy});

  llvm::Value *Call = CGF.Builder.CreateCall(F, Src0);

  llvm::Value *Exp = CGF.Builder.CreateExtractValue(Call, 1);

  LValue LV = CGF.MakeNaturalAlignAddrLValue(Src1, IntPtrTy);

  CGF.EmitStoreOfScalar(Exp, LV);

  return CGF.Builder.CreateExtractValue(Call, 0);

}

/// EmitFAbs - Emit a call to @llvm.fabs().

static Value *EmitFAbs(CodeGenFunction &CGF, Value *V) {

  Function *F = CGF.CGM.getIntrinsic(Intrinsic::fabs, V->getType());

  llvm::CallInst *Call = CGF.Builder.CreateCall(F, V);

  Call->setDoesNotAccessMemory();

  return Call;

}

/// Emit the computation of the sign bit for a floating point value. Returns

/// the i1 sign bit value.

static Value *EmitSignBit(CodeGenFunction &CGF, Value *V) {

  LLVMContext &C = CGF.CGM.getLLVMContext();

  llvm::Type *Ty = V->getType();

  int Width = Ty->getPrimitiveSizeInBits();

  llvm::Type *IntTy = llvm::IntegerType::get(C, Width);

  V = CGF.Builder.CreateBitCast(V, IntTy);

  if (Ty->isPPC_FP128Ty()) {

    // We want the sign bit of the higher-order double. The bitcast we just

    // did works as if the double-double was stored to memory and then

    // read as an i128. The "store" will put the higher-order double in the

    // lower address in both little- and big-Endian modes, but the "load"

    // will treat those bits as a different part of the i128: the low bits in

    // little-Endian, the high bits in big-Endian. Therefore, on big-Endian

    // we need to shift the high bits down to the low before truncating.

    Width >>= 1;

    if (CGF.getTarget().isBigEndian()) {

      Value *ShiftCst = llvm::ConstantInt::get(IntTy, Width);

      V = CGF.Builder.CreateLShr(V, ShiftCst);

    }

    // We are truncating value in order to extract the higher-order

    // double, which we will be using to extract the sign from.

    IntTy = llvm::IntegerType::get(C, Width);

    V = CGF.Builder.CreateTrunc(V, IntTy);

  }

  Value *Zero = llvm::Constant::getNullValue(IntTy);

  return CGF.Builder.CreateICmpSLT(V, Zero);

}

static RValue emitLibraryCall(CodeGenFunction &CGF, const FunctionDecl *FD,

                              const CallExpr *E, llvm::Constant *calleeValue) {

  CGCallee callee = CGCallee::forDirect(calleeValue, GlobalDecl(FD));

  return CGF.EmitCall(E->getCallee()->getType(), callee, E, ReturnValueSlot());

}

/// Emit a call to llvm.{sadd,uadd,ssub,usub,smul,umul}.with.overflow.*

/// depending on IntrinsicID.

///

/// \arg CGF The current codegen function.

/// \arg IntrinsicID The ID for the Intrinsic we wish to generate.

/// \arg X The first argument to the llvm.*.with.overflow.*.

/// \arg Y The second argument to the llvm.*.with.overflow.*.

/// \arg Carry The carry returned by the llvm.*.with.overflow.*.

/// \returns The result (i.e. sum/product) returned by the intrinsic.

static llvm::Value *EmitOverflowIntrinsic(CodeGenFunction &CGF,

                                          const llvm::Intrinsic::ID IntrinsicID,

                                          llvm::Value *X, llvm::Value *Y,

                                          llvm::Value *&Carry) {

  // Make sure we have integers of the same width.

  assert(X->getType() == Y->getType() &&

         "Arguments must be the same type. (Did you forget to make sure both "

         "arguments have the same integer width?)");

  Function *Callee = CGF.CGM.getIntrinsic(IntrinsicID, X->getType());

  llvm::Value *Tmp = CGF.Builder.CreateCall(Callee, {X, Y});

  Carry = CGF.Builder.CreateExtractValue(Tmp, 1);

  return CGF.Builder.CreateExtractValue(Tmp, 0);

}

static Value *emitRangedBuiltin(CodeGenFunction &CGF,

                                unsigned IntrinsicID,

                                int low, int high) {

    llvm::MDBuilder MDHelper(CGF.getLLVMContext());

    llvm::MDNode *RNode = MDHelper.createRange(APInt(32, low), APInt(32, high));

    Function *F = CGF.CGM.getIntrinsic(IntrinsicID, {});

    llvm::Instruction *Call = CGF.Builder.CreateCall(F);

    Call->setMetadata(llvm::LLVMContext::MD_range, RNode);

    Call->setMetadata(llvm::LLVMContext::MD_noundef,

                      llvm::MDNode::get(CGF.getLLVMContext(), std::nullopt));

    return Call;

}

namespace {

  struct WidthAndSignedness {

    unsigned Width;

    bool Signed;

  };

}

static WidthAndSignedness

getIntegerWidthAndSignedness(const clang::ASTContext &context,

                             const clang::QualType Type) {

  assert(Type->isIntegerType() && "Given type is not an integer.");

  unsigned Width = Type->isBooleanType()  ? 1

                   : Type->isBitIntType() ? context.getIntWidth(Type)

                                          : context.getTypeInfo(Type).Width;

  bool Signed = Type->isSignedIntegerType();

  return {Width, Signed};

}

// Given one or more integer types, this function produces an integer type that

// encompasses them: any value in one of the given types could be expressed in

// the encompassing type.

static struct WidthAndSignedness

EncompassingIntegerType(ArrayRef<struct WidthAndSignedness> Types) {

  assert(Types.size() > 0 && "Empty list of types.");

  // If any of the given types is signed, we must return a signed type.

  bool Signed = false;

  for (const auto &Type : Types) {

    Signed |= Type.Signed;

  }

  // The encompassing type must have a width greater than or equal to the width

  // of the specified types.  Additionally, if the encompassing type is signed,

  // its width must be strictly greater than the width of any unsigned types

  // given.

  unsigned Width = 0;

  for (const auto &Type : Types) {

    unsigned MinWidth = Type.Width + (Signed && !Type.Signed);

    if (Width < MinWidth) {

      Width = MinWidth;

    }

  }

  return {Width, Signed};

}

Value *CodeGenFunction::EmitVAStartEnd(Value *ArgValue, bool IsStart) {

  Intrinsic::ID inst = IsStart ? Intrinsic::vastart : Intrinsic::vaend;

  return Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue);

}

/// Checks if using the result of __builtin_object_size(p, @p From) in place of

/// __builtin_object_size(p, @p To) is correct

static bool areBOSTypesCompatible(int From, int To) {

  // Note: Our __builtin_object_size implementation currently treats Type=0 and

  // Type=2 identically. Encoding this implementation detail here may make

  // improving __builtin_object_size difficult in the future, so it's omitted.

  return From == To || (From == 0 && To == 1) || (From == 3 && To == 2);

}

static llvm::Value *

getDefaultBuiltinObjectSizeResult(unsigned Type, llvm::IntegerType *ResType) {

  return ConstantInt::get(ResType, (Type & 2) ? 0 : -1, /*isSigned=*/true);

}

llvm::Value *

CodeGenFunction::evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,

                                                 llvm::IntegerType *ResType,

                                                 llvm::Value *EmittedE,

                                                 bool IsDynamic) {

  uint64_t ObjectSize;

  if (!E->tryEvaluateObjectSize(ObjectSize, getContext(), Type))

    return emitBuiltinObjectSize(E, Type, ResType, EmittedE, IsDynamic);

  return ConstantInt::get(ResType, ObjectSize, /*isSigned=*/true);

}

const FieldDecl *CodeGenFunction::FindFlexibleArrayMemberField(

    ASTContext &Ctx, const RecordDecl *RD, StringRef Name, uint64_t &Offset) {

  const LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel =

      getLangOpts().getStrictFlexArraysLevel();

  unsigned FieldNo = 0;

  bool IsUnion = RD->isUnion();

  for (const Decl *D : RD->decls()) {

    if (const auto *Field = dyn_cast<FieldDecl>(D);

        Field && (Name.empty() || Field->getNameAsString() == Name) &&

        Decl::isFlexibleArrayMemberLike(

            Ctx, Field, Field->getType(), StrictFlexArraysLevel,

            /*IgnoreTemplateOrMacroSubstitution=*/true)) {

      const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);

      Offset += Layout.getFieldOffset(FieldNo);

      return Field;

    }

    if (const auto *Record = dyn_cast<RecordDecl>(D))

      if (const FieldDecl *Field =

              FindFlexibleArrayMemberField(Ctx, Record, Name, Offset)) {

        const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);

        Offset += Layout.getFieldOffset(FieldNo);

        return Field;

      }

    if (!IsUnion && isa<FieldDecl>(D))

      ++FieldNo;

  }

  return nullptr;

}

static unsigned CountCountedByAttrs(const RecordDecl *RD) {

  unsigned Num = 0;

  for (const Decl *D : RD->decls()) {

    if (const auto *FD = dyn_cast<FieldDecl>(D);

        FD && FD->hasAttr<CountedByAttr>()) {

      return ++Num;

    }

    if (const auto *Rec = dyn_cast<RecordDecl>(D))

      Num += CountCountedByAttrs(Rec);

  }

  return Num;

}

llvm::Value *

CodeGenFunction::emitFlexibleArrayMemberSize(const Expr *E, unsigned Type,

                                             llvm::IntegerType *ResType) {

  // The code generated here calculates the size of a struct with a flexible

  // array member that uses the counted_by attribute. There are two instances

  // we handle:

  //

  //       struct s {

  //         unsigned long flags;

  //         int count;

  //         int array[] __attribute__((counted_by(count)));

  //       }

  //

  //   1) bdos of the flexible array itself:

  //

  //     __builtin_dynamic_object_size(p->array, 1) ==

  //         p->count * sizeof(*p->array)

  //

  //   2) bdos of a pointer into the flexible array:

  //

  //     __builtin_dynamic_object_size(&p->array[42], 1) ==

  //         (p->count - 42) * sizeof(*p->array)

  //

  //   2) bdos of the whole struct, including the flexible array:

  //

  //     __builtin_dynamic_object_size(p, 1) ==

  //        max(sizeof(struct s),

  //            offsetof(struct s, array) + p->count * sizeof(*p->array))

  //

  ASTContext &Ctx = getContext();

  const Expr *Base = E->IgnoreParenImpCasts();

  const Expr *Idx = nullptr;

  if (const auto *UO = dyn_cast<UnaryOperator>(Base);

      UO && UO->getOpcode() == UO_AddrOf) {

    Expr *SubExpr = UO->getSubExpr()->IgnoreParenImpCasts();

    if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(SubExpr)) {

      Base = ASE->getBase()->IgnoreParenImpCasts();

      Idx = ASE->getIdx()->IgnoreParenImpCasts();

      if (const auto *IL = dyn_cast<IntegerLiteral>(Idx)) {

        int64_t Val = IL->getValue().getSExtValue();

        if (Val < 0)

          return getDefaultBuiltinObjectSizeResult(Type, ResType);

        if (Val == 0)

          // The index is 0, so we don't need to take it into account.

          Idx = nullptr;

      }

    } else {

      // Potential pointer to another element in the struct.

      Base = SubExpr;

    }

  }

  // Get the flexible array member Decl.

  const RecordDecl *OuterRD = nullptr;

  std::string FAMName;

  if (const auto *ME = dyn_cast<MemberExpr>(Base)) {

    // Check if \p Base is referencing the FAM itself.

    const ValueDecl *VD = ME->getMemberDecl();

    OuterRD = VD->getDeclContext()->getOuterLexicalRecordContext();

    FAMName = VD->getNameAsString();

  } else if (const auto *DRE = dyn_cast<DeclRefExpr>(Base)) {

    // Check if we're pointing to the whole struct.

    QualType Ty = DRE->getDecl()->getType();

    if (Ty->isPointerType())

      Ty = Ty->getPointeeType();

    OuterRD = Ty->getAsRecordDecl();

    // If we have a situation like this:

    //

    //     struct union_of_fams {

    //         int flags;

    //         union {

    //             signed char normal_field;

    //             struct {

    //                 int count1;

    //                 int arr1[] __counted_by(count1);

    //             };