//===- LoongArch.cpp ------------------------------------------------------===//

//

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

//

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

#include "ABIInfoImpl.h"

#include "TargetInfo.h"

using namespace clang;

using namespace clang::CodeGen;

// LoongArch ABI Implementation. Documented at

// https://loongson.github.io/LoongArch-Documentation/LoongArch-ELF-ABI-EN.html

//

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

namespace {

class LoongArchABIInfo : public DefaultABIInfo {

private:

  // Size of the integer ('r') registers in bits.

  unsigned GRLen;

  // Size of the floating point ('f') registers in bits.

  unsigned FRLen;

  // Number of general-purpose argument registers.

  static const int NumGARs = 8;

  // Number of floating-point argument registers.

  static const int NumFARs = 8;

  bool detectFARsEligibleStructHelper(QualType Ty, CharUnits CurOff,

                                      llvm::Type *&Field1Ty,

                                      CharUnits &Field1Off,

                                      llvm::Type *&Field2Ty,

                                      CharUnits &Field2Off) const;

public:

  LoongArchABIInfo(CodeGen::CodeGenTypes &CGT, unsigned GRLen, unsigned FRLen)

      : DefaultABIInfo(CGT), GRLen(GRLen), FRLen(FRLen) {}

  void computeInfo(CGFunctionInfo &FI) const override;

  ABIArgInfo classifyArgumentType(QualType Ty, bool IsFixed, int &GARsLeft,

                                  int &FARsLeft) const;

  ABIArgInfo classifyReturnType(QualType RetTy) const;

  Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,

                    QualType Ty) const override;

  ABIArgInfo extendType(QualType Ty) const;

  bool detectFARsEligibleStruct(QualType Ty, llvm::Type *&Field1Ty,

                                CharUnits &Field1Off, llvm::Type *&Field2Ty,

                                CharUnits &Field2Off, int &NeededArgGPRs,

                                int &NeededArgFPRs) const;

  ABIArgInfo coerceAndExpandFARsEligibleStruct(llvm::Type *Field1Ty,

                                               CharUnits Field1Off,

                                               llvm::Type *Field2Ty,

                                               CharUnits Field2Off) const;

};

} // end anonymous namespace

void LoongArchABIInfo::computeInfo(CGFunctionInfo &FI) const {

  QualType RetTy = FI.getReturnType();

  if (!getCXXABI().classifyReturnType(FI))

    FI.getReturnInfo() = classifyReturnType(RetTy);

  // IsRetIndirect is true if classifyArgumentType indicated the value should

  // be passed indirect, or if the type size is a scalar greater than 2*GRLen

  // and not a complex type with elements <= FRLen. e.g. fp128 is passed direct

  // in LLVM IR, relying on the backend lowering code to rewrite the argument

  // list and pass indirectly on LA32.

  bool IsRetIndirect = FI.getReturnInfo().getKind() == ABIArgInfo::Indirect;

  if (!IsRetIndirect && RetTy->isScalarType() &&

      getContext().getTypeSize(RetTy) > (2 * GRLen)) {

    if (RetTy->isComplexType() && FRLen) {

      QualType EltTy = RetTy->castAs<ComplexType>()->getElementType();

      IsRetIndirect = getContext().getTypeSize(EltTy) > FRLen;

    } else {

      // This is a normal scalar > 2*GRLen, such as fp128 on LA32.

      IsRetIndirect = true;

    }

  }

  // We must track the number of GARs and FARs used in order to conform to the

  // LoongArch ABI. As GAR usage is different for variadic arguments, we must

  // also track whether we are examining a vararg or not.

  int GARsLeft = IsRetIndirect ? NumGARs - 1 : NumGARs;

  int FARsLeft = FRLen ? NumFARs : 0;

  int NumFixedArgs = FI.getNumRequiredArgs();

  int ArgNum = 0;

  for (auto &ArgInfo : FI.arguments()) {

    ArgInfo.info = classifyArgumentType(

        ArgInfo.type, /*IsFixed=*/ArgNum < NumFixedArgs, GARsLeft, FARsLeft);

    ArgNum++;

  }

}

// Returns true if the struct is a potential candidate to be passed in FARs (and

// GARs). If this function returns true, the caller is responsible for checking

// that if there is only a single field then that field is a float.

bool LoongArchABIInfo::detectFARsEligibleStructHelper(

    QualType Ty, CharUnits CurOff, llvm::Type *&Field1Ty, CharUnits &Field1Off,

    llvm::Type *&Field2Ty, CharUnits &Field2Off) const {

  bool IsInt = Ty->isIntegralOrEnumerationType();

  bool IsFloat = Ty->isRealFloatingType();

  if (IsInt || IsFloat) {

    uint64_t Size = getContext().getTypeSize(Ty);

    if (IsInt && Size > GRLen)

      return false;

    // Can't be eligible if larger than the FP registers. Half precision isn't

    // currently supported on LoongArch and the ABI hasn't been confirmed, so

    // default to the integer ABI in that case.

    if (IsFloat && (Size > FRLen || Size < 32))

      return false;

    // Can't be eligible if an integer type was already found (int+int pairs

    // are not eligible).

    if (IsInt && Field1Ty && Field1Ty->isIntegerTy())

      return false;

    if (!Field1Ty) {

      Field1Ty = CGT.ConvertType(Ty);

      Field1Off = CurOff;

      return true;

    }

    if (!Field2Ty) {

      Field2Ty = CGT.ConvertType(Ty);

      Field2Off = CurOff;

      return true;

    }

    return false;

  }

  if (auto CTy = Ty->getAs<ComplexType>()) {

    if (Field1Ty)

      return false;

    QualType EltTy = CTy->getElementType();

    if (getContext().getTypeSize(EltTy) > FRLen)

      return false;

    Field1Ty = CGT.ConvertType(EltTy);

    Field1Off = CurOff;

    Field2Ty = Field1Ty;

    Field2Off = Field1Off + getContext().getTypeSizeInChars(EltTy);

    return true;

  }

  if (const ConstantArrayType *ATy = getContext().getAsConstantArrayType(Ty)) {

    uint64_t ArraySize = ATy->getSize().getZExtValue();

    QualType EltTy = ATy->getElementType();

    // Non-zero-length arrays of empty records make the struct ineligible to be

    // passed via FARs in C++.

    if (const auto *RTy = EltTy->getAs<RecordType>()) {

      if (ArraySize != 0 && isa<CXXRecordDecl>(RTy->getDecl()) &&

          isEmptyRecord(getContext(), EltTy, true, true))

        return false;

    }

    CharUnits EltSize = getContext().getTypeSizeInChars(EltTy);

    for (uint64_t i = 0; i < ArraySize; ++i) {

      if (!detectFARsEligibleStructHelper(EltTy, CurOff, Field1Ty, Field1Off,

                                          Field2Ty, Field2Off))

        return false;

      CurOff += EltSize;

    }

    return true;

  }

  if (const auto *RTy = Ty->getAs<RecordType>()) {

    // Structures with either a non-trivial destructor or a non-trivial

    // copy constructor are not eligible for the FP calling convention.

    if (getRecordArgABI(Ty, CGT.getCXXABI()))

      return false;

    const RecordDecl *RD = RTy->getDecl();

    if (isEmptyRecord(getContext(), Ty, true, true) &&

        (!RD->isUnion() || !isa<CXXRecordDecl>(RD)))

      return true;

    // Unions aren't eligible unless they're empty in C (which is caught above).

    if (RD->isUnion())

      return false;

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

    // If this is a C++ record, check the bases first.

    if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {

      for (const CXXBaseSpecifier &B : CXXRD->bases()) {

        const auto *BDecl =

            cast<CXXRecordDecl>(B.getType()->castAs<RecordType>()->getDecl());

        if (!detectFARsEligibleStructHelper(

                B.getType(), CurOff + Layout.getBaseClassOffset(BDecl),

                Field1Ty, Field1Off, Field2Ty, Field2Off))

          return false;

      }

    }

    for (const FieldDecl *FD : RD->fields()) {

      QualType QTy = FD->getType();

      if (FD->isBitField()) {

        unsigned BitWidth = FD->getBitWidthValue(getContext());

        // Zero-width bitfields are ignored.

        if (BitWidth == 0)

          continue;

        // Allow a bitfield with a type greater than GRLen as long as the

        // bitwidth is GRLen or less.

        if (getContext().getTypeSize(QTy) > GRLen && BitWidth <= GRLen) {

          QTy = getContext().getIntTypeForBitwidth(GRLen, false);

        }

      }

      if (!detectFARsEligibleStructHelper(

              QTy,

              CurOff + getContext().toCharUnitsFromBits(

                           Layout.getFieldOffset(FD->getFieldIndex())),

              Field1Ty, Field1Off, Field2Ty, Field2Off))

        return false;

    }

    return Field1Ty != nullptr;

  }

  return false;

}

// Determine if a struct is eligible to be passed in FARs (and GARs) (i.e., when

// flattened it contains a single fp value, fp+fp, or int+fp of appropriate

// size). If so, NeededFARs and NeededGARs are incremented appropriately.

bool LoongArchABIInfo::detectFARsEligibleStruct(

    QualType Ty, llvm::Type *&Field1Ty, CharUnits &Field1Off,

    llvm::Type *&Field2Ty, CharUnits &Field2Off, int &NeededGARs,

    int &NeededFARs) const {

  Field1Ty = nullptr;

  Field2Ty = nullptr;

  NeededGARs = 0;

  NeededFARs = 0;

  if (!detectFARsEligibleStructHelper(Ty, CharUnits::Zero(), Field1Ty,

                                      Field1Off, Field2Ty, Field2Off))

    return false;

  if (!Field1Ty)

    return false;

  // Not really a candidate if we have a single int but no float.

  if (Field1Ty && !Field2Ty && !Field1Ty->isFloatingPointTy())

    return false;

  if (Field1Ty && Field1Ty->isFloatingPointTy())

    NeededFARs++;

  else if (Field1Ty)

    NeededGARs++;

  if (Field2Ty && Field2Ty->isFloatingPointTy())

    NeededFARs++;

  else if (Field2Ty)

    NeededGARs++;

  return true;

}

// Call getCoerceAndExpand for the two-element flattened struct described by

// Field1Ty, Field1Off, Field2Ty, Field2Off. This method will create an

// appropriate coerceToType and unpaddedCoerceToType.

ABIArgInfo LoongArchABIInfo::coerceAndExpandFARsEligibleStruct(

    llvm::Type *Field1Ty, CharUnits Field1Off, llvm::Type *Field2Ty,

    CharUnits Field2Off) const {

  SmallVector<llvm::Type *, 3> CoerceElts;

  SmallVector<llvm::Type *, 2> UnpaddedCoerceElts;

  if (!Field1Off.isZero())

    CoerceElts.push_back(llvm::ArrayType::get(

        llvm::Type::getInt8Ty(getVMContext()), Field1Off.getQuantity()));

  CoerceElts.push_back(Field1Ty);

  UnpaddedCoerceElts.push_back(Field1Ty);

  if (!Field2Ty) {

    return ABIArgInfo::getCoerceAndExpand(

        llvm::StructType::get(getVMContext(), CoerceElts, !Field1Off.isZero()),

        UnpaddedCoerceElts[0]);

  }

  CharUnits Field2Align =

      CharUnits::fromQuantity(getDataLayout().getABITypeAlign(Field2Ty));

  CharUnits Field1End =

      Field1Off +

      CharUnits::fromQuantity(getDataLayout().getTypeStoreSize(Field1Ty));

  CharUnits Field2OffNoPadNoPack = Field1End.alignTo(Field2Align);

  CharUnits Padding = CharUnits::Zero();

  if (Field2Off > Field2OffNoPadNoPack)

    Padding = Field2Off - Field2OffNoPadNoPack;

  else if (Field2Off != Field2Align && Field2Off > Field1End)

    Padding = Field2Off - Field1End;

  bool IsPacked = !Field2Off.isMultipleOf(Field2Align);

  if (!Padding.isZero())

    CoerceElts.push_back(llvm::ArrayType::get(

        llvm::Type::getInt8Ty(getVMContext()), Padding.getQuantity()));

  CoerceElts.push_back(Field2Ty);

  UnpaddedCoerceElts.push_back(Field2Ty);

  return ABIArgInfo::getCoerceAndExpand(

      llvm::StructType::get(getVMContext(), CoerceElts, IsPacked),

      llvm::StructType::get(getVMContext(), UnpaddedCoerceElts, IsPacked));

}

ABIArgInfo LoongArchABIInfo::classifyArgumentType(QualType Ty, bool IsFixed,

                                                  int &GARsLeft,

                                                  int &FARsLeft) const {

  assert(GARsLeft <= NumGARs && "GAR tracking underflow");

  Ty = useFirstFieldIfTransparentUnion(Ty);

  // Structures with either a non-trivial destructor or a non-trivial

  // copy constructor are always passed indirectly.

  if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI())) {

    if (GARsLeft)

      GARsLeft -= 1;

    return getNaturalAlignIndirect(Ty, /*ByVal=*/RAA ==

                                           CGCXXABI::RAA_DirectInMemory);

  }

  uint64_t Size = getContext().getTypeSize(Ty);

  // Ignore empty struct or union whose size is zero, e.g. `struct { }` in C or

  // `struct { int a[0]; }` in C++. In C++, `struct { }` is empty but it's size

  // is 1 byte and g++ doesn't ignore it; clang++ matches this behaviour.

  if (isEmptyRecord(getContext(), Ty, true) && Size == 0)

    return ABIArgInfo::getIgnore();

  // Pass floating point values via FARs if possible.

  if (IsFixed && Ty->isFloatingType() && !Ty->isComplexType() &&

      FRLen >= Size && FARsLeft) {

    FARsLeft--;

    return ABIArgInfo::getDirect();

  }

  // Complex types for the *f or *d ABI must be passed directly rather than

  // using CoerceAndExpand.

  if (IsFixed && Ty->isComplexType() && FRLen && FARsLeft >= 2) {

    QualType EltTy = Ty->castAs<ComplexType>()->getElementType();

    if (getContext().getTypeSize(EltTy) <= FRLen) {

      FARsLeft -= 2;

      return ABIArgInfo::getDirect();

    }

  }

  if (IsFixed && FRLen && Ty->isStructureOrClassType()) {

    llvm::Type *Field1Ty = nullptr;

    llvm::Type *Field2Ty = nullptr;

    CharUnits Field1Off = CharUnits::Zero();

    CharUnits Field2Off = CharUnits::Zero();

    int NeededGARs = 0;

    int NeededFARs = 0;

    bool IsCandidate = detectFARsEligibleStruct(

        Ty, Field1Ty, Field1Off, Field2Ty, Field2Off, NeededGARs, NeededFARs);

    if (IsCandidate && NeededGARs <= GARsLeft && NeededFARs <= FARsLeft) {

      GARsLeft -= NeededGARs;

      FARsLeft -= NeededFARs;

      return coerceAndExpandFARsEligibleStruct(Field1Ty, Field1Off, Field2Ty,

                                               Field2Off);

    }

  }

  uint64_t NeededAlign = getContext().getTypeAlign(Ty);

  // Determine the number of GARs needed to pass the current argument

  // according to the ABI. 2*GRLen-aligned varargs are passed in "aligned"

  // register pairs, so may consume 3 registers.

  int NeededGARs = 1;

  if (!IsFixed && NeededAlign == 2 * GRLen)

    NeededGARs = 2 + (GARsLeft % 2);

  else if (Size > GRLen && Size <= 2 * GRLen)

    NeededGARs = 2;

  if (NeededGARs > GARsLeft)

    NeededGARs = GARsLeft;

  GARsLeft -= NeededGARs;

  if (!isAggregateTypeForABI(Ty) && !Ty->isVectorType()) {

    // Treat an enum type as its underlying type.

    if (const EnumType *EnumTy = Ty->getAs<EnumType>())

      Ty = EnumTy->getDecl()->getIntegerType();

    // All integral types are promoted to GRLen width.

    if (Size < GRLen && Ty->isIntegralOrEnumerationType())

      return extendType(Ty);

    if (const auto *EIT = Ty->getAs<BitIntType>()) {

      if (EIT->getNumBits() < GRLen)

        return extendType(Ty);

      if (EIT->getNumBits() > 128 ||

          (!getContext().getTargetInfo().hasInt128Type() &&

           EIT->getNumBits() > 64))

        return getNaturalAlignIndirect(Ty, /*ByVal=*/false);

    }

    return ABIArgInfo::getDirect();

  }

  // Aggregates which are <= 2*GRLen will be passed in registers if possible,

  // so coerce to integers.

  if (Size <= 2 * GRLen) {

    // Use a single GRLen int if possible, 2*GRLen if 2*GRLen alignment is

    // required, and a 2-element GRLen array if only GRLen alignment is

    // required.

    if (Size <= GRLen) {

      return ABIArgInfo::getDirect(

          llvm::IntegerType::get(getVMContext(), GRLen));

    }

    if (getContext().getTypeAlign(Ty) == 2 * GRLen) {

      return ABIArgInfo::getDirect(

          llvm::IntegerType::get(getVMContext(), 2 * GRLen));

    }

    return ABIArgInfo::getDirect(

        llvm::ArrayType::get(llvm::IntegerType::get(getVMContext(), GRLen), 2));

  }

  return getNaturalAlignIndirect(Ty, /*ByVal=*/false);

}

ABIArgInfo LoongArchABIInfo::classifyReturnType(QualType RetTy) const {

  if (RetTy->isVoidType())

    return ABIArgInfo::getIgnore();

  // The rules for return and argument types are the same, so defer to

  // classifyArgumentType.

  int GARsLeft = 2;

  int FARsLeft = FRLen ? 2 : 0;

  return classifyArgumentType(RetTy, /*IsFixed=*/true, GARsLeft, FARsLeft);

}

Address LoongArchABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,

                                    QualType Ty) const {

  CharUnits SlotSize = CharUnits::fromQuantity(GRLen / 8);

  // Empty records are ignored for parameter passing purposes.

  if (isEmptyRecord(getContext(), Ty, true))

    return Address(CGF.Builder.CreateLoad(VAListAddr),

                   CGF.ConvertTypeForMem(Ty), SlotSize);

  auto TInfo = getContext().getTypeInfoInChars(Ty);

  // Arguments bigger than 2*GRLen bytes are passed indirectly.

  return emitVoidPtrVAArg(CGF, VAListAddr, Ty,

                          /*IsIndirect=*/TInfo.Width > 2 * SlotSize, TInfo,

                          SlotSize,

                          /*AllowHigherAlign=*/true);

}

ABIArgInfo LoongArchABIInfo::extendType(QualType Ty) const {

  int TySize = getContext().getTypeSize(Ty);

  // LA64 ABI requires unsigned 32 bit integers to be sign extended.

  if (GRLen == 64 && Ty->isUnsignedIntegerOrEnumerationType() && TySize == 32)

    return ABIArgInfo::getSignExtend(Ty);

  return ABIArgInfo::getExtend(Ty);

}

namespace {

class LoongArchTargetCodeGenInfo : public TargetCodeGenInfo {

public:

  LoongArchTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, unsigned GRLen,

                             unsigned FRLen)

      : TargetCodeGenInfo(

            std::make_unique<LoongArchABIInfo>(CGT, GRLen, FRLen)) {}

};

} // namespace

std::unique_ptr<TargetCodeGenInfo>

CodeGen::createLoongArchTargetCodeGenInfo(CodeGenModule &CGM, unsigned GRLen,

                                          unsigned FLen) {

  return std::make_unique<LoongArchTargetCodeGenInfo>(CGM.getTypes(), GRLen,

                                                      FLen);

}