39ec9de7c2
`sret` arguments are always going to reside in the stack/`alloca` address space, which makes the current formulation where their AS is derived from the pointee somewhat quaint. This patch ensures that `sret` ends up pointing to the `alloca` AS in IR function signatures, and also guards agains trying to pass a casted `alloca`d pointer to a `sret` arg, which can happen for most languages, when compiled for targets that have a non-zero `alloca` AS (e.g. AMDGCN) / map `LangAS::default` to a non-zero value (SPIR-V). A target could still choose to do something different here, by e.g. overriding `classifyReturnType` behaviour. In a broader sense, this patch extends non-aliased indirect args to also carry an AS, which leads to changing the `getIndirect()` interface. At the moment we're only using this for (indirect) returns, but it allows for future handling of indirect args themselves. We default to using the AllocaAS as that matches what Clang is currently doing, however if, in the future, a target would opt for e.g. placing indirect returns in some other storage, with another AS, this will require revisiting. --------- Co-authored-by: Matt Arsenault <arsenm2@gmail.com> Co-authored-by: Matt Arsenault <Matthew.Arsenault@amd.com>
115 lines
4.5 KiB
C++
115 lines
4.5 KiB
C++
//===- 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;
|
|
RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
|
|
AggValueSlot Slot) 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);
|
|
}
|
|
|
|
RValue PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
|
|
QualType Ty, AggValueSlot Slot) 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 CGF.EmitLoadOfAnyValue(
|
|
CGF.MakeAddrLValue(
|
|
EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect()), Ty),
|
|
Slot);
|
|
}
|
|
|
|
/// 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, getDataLayout().getAllocaAddrSpace(),
|
|
RAA == CGCXXABI::RAA_DirectInMemory);
|
|
return getNaturalAlignIndirect(Ty, getDataLayout().getAllocaAddrSpace());
|
|
} 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, getDataLayout().getAllocaAddrSpace());
|
|
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, getDataLayout().getAllocaAddrSpace());
|
|
|
|
// 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,
|
|
getDataLayout().getAllocaAddrSpace());
|
|
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());
|
|
}
|