| //===- Lanai.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; | |
| //===----------------------------------------------------------------------===// | |
| // Lanai ABI Implementation | |
| //===----------------------------------------------------------------------===// | |
| namespace { | |
| class LanaiABIInfo : public DefaultABIInfo { | |
| struct CCState { | |
| unsigned FreeRegs; | |
| }; | |
| public: | |
| LanaiABIInfo(CodeGen::CodeGenTypes &CGT) : DefaultABIInfo(CGT) {} | |
| bool shouldUseInReg(QualType Ty, CCState &State) const; | |
| void computeInfo(CGFunctionInfo &FI) const override { | |
| CCState State; | |
| // Lanai uses 4 registers to pass arguments unless the function has the | |
| // regparm attribute set. | |
| if (FI.getHasRegParm()) { | |
| State.FreeRegs = FI.getRegParm(); | |
| } else { | |
| State.FreeRegs = 4; | |
| } | |
| if (!getCXXABI().classifyReturnType(FI)) | |
| FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); | |
| for (auto &I : FI.arguments()) | |
| I.info = classifyArgumentType(I.type, State); | |
| } | |
| ABIArgInfo getIndirectResult(QualType Ty, bool ByVal, CCState &State) const; | |
| ABIArgInfo classifyArgumentType(QualType RetTy, CCState &State) const; | |
| }; | |
| } // end anonymous namespace | |
| bool LanaiABIInfo::shouldUseInReg(QualType Ty, CCState &State) const { | |
| unsigned Size = getContext().getTypeSize(Ty); | |
| unsigned SizeInRegs = llvm::alignTo(Size, 32U) / 32U; | |
| if (SizeInRegs == 0) | |
| return false; | |
| if (SizeInRegs > State.FreeRegs) { | |
| State.FreeRegs = 0; | |
| return false; | |
| } | |
| State.FreeRegs -= SizeInRegs; | |
| return true; | |
| } | |
| ABIArgInfo LanaiABIInfo::getIndirectResult(QualType Ty, bool ByVal, | |
| CCState &State) const { | |
| if (!ByVal) { | |
| if (State.FreeRegs) { | |
| --State.FreeRegs; // Non-byval indirects just use one pointer. | |
| return getNaturalAlignIndirectInReg(Ty); | |
| } | |
| return getNaturalAlignIndirect(Ty, getDataLayout().getAllocaAddrSpace(), | |
| false); | |
| } | |
| // Compute the byval alignment. | |
| const unsigned MinABIStackAlignInBytes = 4; | |
| unsigned TypeAlign = getContext().getTypeAlign(Ty) / 8; | |
| return ABIArgInfo::getIndirect( | |
| CharUnits::fromQuantity(4), | |
| /*AddrSpace=*/getDataLayout().getAllocaAddrSpace(), /*ByVal=*/true, | |
| /*Realign=*/TypeAlign > MinABIStackAlignInBytes); | |
| } | |
| ABIArgInfo LanaiABIInfo::classifyArgumentType(QualType Ty, | |
| CCState &State) const { | |
| // Check with the C++ ABI first. | |
| const RecordType *RT = Ty->getAsCanonical<RecordType>(); | |
| if (RT) { | |
| CGCXXABI::RecordArgABI RAA = getRecordArgABI(RT, getCXXABI()); | |
| if (RAA == CGCXXABI::RAA_Indirect) { | |
| return getIndirectResult(Ty, /*ByVal=*/false, State); | |
| } else if (RAA == CGCXXABI::RAA_DirectInMemory) { | |
| return getNaturalAlignIndirect( | |
| Ty, /*AddrSpace=*/getDataLayout().getAllocaAddrSpace(), | |
| /*ByVal=*/true); | |
| } | |
| } | |
| if (isAggregateTypeForABI(Ty)) { | |
| // Structures with flexible arrays are always indirect. | |
| if (RT && RT->getDecl()->getDefinitionOrSelf()->hasFlexibleArrayMember()) | |
| return getIndirectResult(Ty, /*ByVal=*/true, State); | |
| // Ignore empty structs/unions. | |
| if (isEmptyRecord(getContext(), Ty, true)) | |
| return ABIArgInfo::getIgnore(); | |
| llvm::LLVMContext &LLVMContext = getVMContext(); | |
| unsigned SizeInRegs = (getContext().getTypeSize(Ty) + 31) / 32; | |
| if (SizeInRegs <= State.FreeRegs) { | |
| llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext); | |
| SmallVector<llvm::Type *, 3> Elements(SizeInRegs, Int32); | |
| llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements); | |
| State.FreeRegs -= SizeInRegs; | |
| return ABIArgInfo::getDirectInReg(Result); | |
| } else { | |
| State.FreeRegs = 0; | |
| } | |
| return getIndirectResult(Ty, true, State); | |
| } | |
| // Treat an enum type as its underlying type. | |
| if (const auto *ED = Ty->getAsEnumDecl()) | |
| Ty = ED->getIntegerType(); | |
| bool InReg = shouldUseInReg(Ty, State); | |
| // Don't pass >64 bit integers in registers. | |
| if (const auto *EIT = Ty->getAs<BitIntType>()) | |
| if (EIT->getNumBits() > 64) | |
| return getIndirectResult(Ty, /*ByVal=*/true, State); | |
| if (isPromotableIntegerTypeForABI(Ty)) { | |
| if (InReg) | |
| return ABIArgInfo::getDirectInReg(); | |
| return ABIArgInfo::getExtend(Ty); | |
| } | |
| if (InReg) | |
| return ABIArgInfo::getDirectInReg(); | |
| return ABIArgInfo::getDirect(); | |
| } | |
| namespace { | |
| class LanaiTargetCodeGenInfo : public TargetCodeGenInfo { | |
| public: | |
| LanaiTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT) | |
| : TargetCodeGenInfo(std::make_unique<LanaiABIInfo>(CGT)) {} | |
| }; | |
| } | |
| std::unique_ptr<TargetCodeGenInfo> | |
| CodeGen::createLanaiTargetCodeGenInfo(CodeGenModule &CGM) { | |
| return std::make_unique<LanaiTargetCodeGenInfo>(CGM.getTypes()); | |
| } |