//===- PNaCl.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;

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

// le32/PNaCl bitcode ABI Implementation

//

// This is a simplified version of the x86_32 ABI.  Arguments and return values

// are always passed on the stack.

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

class PNaClABIInfo : public ABIInfo {

 public:

  PNaClABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}

  ABIArgInfo classifyReturnType(QualType RetTy) const;

  ABIArgInfo classifyArgumentType(QualType RetTy) const;

  void computeInfo(CGFunctionInfo &FI) const override;

  Address EmitVAArg(CodeGenFunction &CGF,

                    Address VAListAddr, QualType Ty) const override;

};

class PNaClTargetCodeGenInfo : public TargetCodeGenInfo {

 public:

   PNaClTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)

       : TargetCodeGenInfo(std::make_unique<PNaClABIInfo>(CGT)) {}

};

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

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

    FI.getReturnInfo() = classifyReturnType(FI.getReturnType());

  for (auto &I : FI.arguments())

    I.info = classifyArgumentType(I.type);

}

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

                                QualType Ty) const {

  // The PNaCL ABI is a bit odd, in that varargs don't use normal

  // function classification. Structs get passed directly for varargs

  // functions, through a rewriting transform in

  // pnacl-llvm/lib/Transforms/NaCl/ExpandVarArgs.cpp, which allows

  // this target to actually support a va_arg instructions with an

  // aggregate type, unlike other targets.

  return EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect());

}

/// Classify argument of given type \p Ty.

ABIArgInfo PNaClABIInfo::classifyArgumentType(QualType Ty) const {

  if (isAggregateTypeForABI(Ty)) {

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

      return getNaturalAlignIndirect(Ty, RAA == CGCXXABI::RAA_DirectInMemory);

    return getNaturalAlignIndirect(Ty);

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

    // Treat an enum type as its underlying type.

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

  } else if (Ty->isFloatingType()) {

    // Floating-point types don't go inreg.

    return ABIArgInfo::getDirect();

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

    // Treat bit-precise integers as integers if <= 64, otherwise pass

    // indirectly.

    if (EIT->getNumBits() > 64)

      return getNaturalAlignIndirect(Ty);

    return ABIArgInfo::getDirect();

  }

  return (isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)

                                            : ABIArgInfo::getDirect());

}

ABIArgInfo PNaClABIInfo::classifyReturnType(QualType RetTy) const {

  if (RetTy->isVoidType())

    return ABIArgInfo::getIgnore();

  // In the PNaCl ABI we always return records/structures on the stack.

  if (isAggregateTypeForABI(RetTy))

    return getNaturalAlignIndirect(RetTy);

  // Treat bit-precise integers as integers if <= 64, otherwise pass indirectly.

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

    if (EIT->getNumBits() > 64)

      return getNaturalAlignIndirect(RetTy);

    return ABIArgInfo::getDirect();

  }

  // Treat an enum type as its underlying type.

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

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

  return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)

                                               : ABIArgInfo::getDirect());

}

std::unique_ptr<TargetCodeGenInfo>

CodeGen::createPNaClTargetCodeGenInfo(CodeGenModule &CGM) {

  return std::make_unique<PNaClTargetCodeGenInfo>(CGM.getTypes());

}