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>
423 lines
16 KiB
C++
423 lines
16 KiB
C++
//===- Hexagon.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;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Hexagon ABI Implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
|
|
class HexagonABIInfo : public DefaultABIInfo {
|
|
public:
|
|
HexagonABIInfo(CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
|
|
|
|
private:
|
|
ABIArgInfo classifyReturnType(QualType RetTy) const;
|
|
ABIArgInfo classifyArgumentType(QualType RetTy) const;
|
|
ABIArgInfo classifyArgumentType(QualType RetTy, unsigned *RegsLeft) const;
|
|
|
|
void computeInfo(CGFunctionInfo &FI) const override;
|
|
|
|
RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
|
|
AggValueSlot Slot) const override;
|
|
Address EmitVAArgFromMemory(CodeGenFunction &CFG, Address VAListAddr,
|
|
QualType Ty) const;
|
|
Address EmitVAArgForHexagon(CodeGenFunction &CFG, Address VAListAddr,
|
|
QualType Ty) const;
|
|
Address EmitVAArgForHexagonLinux(CodeGenFunction &CFG, Address VAListAddr,
|
|
QualType Ty) const;
|
|
};
|
|
|
|
class HexagonTargetCodeGenInfo : public TargetCodeGenInfo {
|
|
public:
|
|
HexagonTargetCodeGenInfo(CodeGenTypes &CGT)
|
|
: TargetCodeGenInfo(std::make_unique<HexagonABIInfo>(CGT)) {}
|
|
|
|
int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
|
|
return 29;
|
|
}
|
|
|
|
void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
|
|
CodeGen::CodeGenModule &GCM) const override {
|
|
if (GV->isDeclaration())
|
|
return;
|
|
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
|
|
if (!FD)
|
|
return;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
void HexagonABIInfo::computeInfo(CGFunctionInfo &FI) const {
|
|
unsigned RegsLeft = 6;
|
|
if (!getCXXABI().classifyReturnType(FI))
|
|
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
|
|
for (auto &I : FI.arguments())
|
|
I.info = classifyArgumentType(I.type, &RegsLeft);
|
|
}
|
|
|
|
static bool HexagonAdjustRegsLeft(uint64_t Size, unsigned *RegsLeft) {
|
|
assert(Size <= 64 && "Not expecting to pass arguments larger than 64 bits"
|
|
" through registers");
|
|
|
|
if (*RegsLeft == 0)
|
|
return false;
|
|
|
|
if (Size <= 32) {
|
|
(*RegsLeft)--;
|
|
return true;
|
|
}
|
|
|
|
if (2 <= (*RegsLeft & (~1U))) {
|
|
*RegsLeft = (*RegsLeft & (~1U)) - 2;
|
|
return true;
|
|
}
|
|
|
|
// Next available register was r5 but candidate was greater than 32-bits so it
|
|
// has to go on the stack. However we still consume r5
|
|
if (*RegsLeft == 1)
|
|
*RegsLeft = 0;
|
|
|
|
return false;
|
|
}
|
|
|
|
ABIArgInfo HexagonABIInfo::classifyArgumentType(QualType Ty,
|
|
unsigned *RegsLeft) const {
|
|
if (!isAggregateTypeForABI(Ty)) {
|
|
// Treat an enum type as its underlying type.
|
|
if (const EnumType *EnumTy = Ty->getAs<EnumType>())
|
|
Ty = EnumTy->getDecl()->getIntegerType();
|
|
|
|
uint64_t Size = getContext().getTypeSize(Ty);
|
|
if (Size <= 64)
|
|
HexagonAdjustRegsLeft(Size, RegsLeft);
|
|
|
|
if (Size > 64 && Ty->isBitIntType())
|
|
return getNaturalAlignIndirect(Ty, getDataLayout().getAllocaAddrSpace(),
|
|
/*ByVal=*/true);
|
|
|
|
return isPromotableIntegerTypeForABI(Ty) ? ABIArgInfo::getExtend(Ty)
|
|
: ABIArgInfo::getDirect();
|
|
}
|
|
|
|
if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI()))
|
|
return getNaturalAlignIndirect(Ty, getDataLayout().getAllocaAddrSpace(),
|
|
RAA == CGCXXABI::RAA_DirectInMemory);
|
|
|
|
// Ignore empty records.
|
|
if (isEmptyRecord(getContext(), Ty, true))
|
|
return ABIArgInfo::getIgnore();
|
|
|
|
uint64_t Size = getContext().getTypeSize(Ty);
|
|
unsigned Align = getContext().getTypeAlign(Ty);
|
|
|
|
if (Size > 64)
|
|
return getNaturalAlignIndirect(Ty, getDataLayout().getAllocaAddrSpace(),
|
|
/*ByVal=*/true);
|
|
|
|
if (HexagonAdjustRegsLeft(Size, RegsLeft))
|
|
Align = Size <= 32 ? 32 : 64;
|
|
if (Size <= Align) {
|
|
// Pass in the smallest viable integer type.
|
|
Size = llvm::bit_ceil(Size);
|
|
return ABIArgInfo::getDirect(llvm::Type::getIntNTy(getVMContext(), Size));
|
|
}
|
|
return DefaultABIInfo::classifyArgumentType(Ty);
|
|
}
|
|
|
|
ABIArgInfo HexagonABIInfo::classifyReturnType(QualType RetTy) const {
|
|
if (RetTy->isVoidType())
|
|
return ABIArgInfo::getIgnore();
|
|
|
|
const TargetInfo &T = CGT.getTarget();
|
|
uint64_t Size = getContext().getTypeSize(RetTy);
|
|
|
|
if (RetTy->getAs<VectorType>()) {
|
|
// HVX vectors are returned in vector registers or register pairs.
|
|
if (T.hasFeature("hvx")) {
|
|
assert(T.hasFeature("hvx-length64b") || T.hasFeature("hvx-length128b"));
|
|
uint64_t VecSize = T.hasFeature("hvx-length64b") ? 64*8 : 128*8;
|
|
if (Size == VecSize || Size == 2*VecSize)
|
|
return ABIArgInfo::getDirectInReg();
|
|
}
|
|
// Large vector types should be returned via memory.
|
|
if (Size > 64)
|
|
return getNaturalAlignIndirect(RetTy,
|
|
getDataLayout().getAllocaAddrSpace());
|
|
}
|
|
|
|
if (!isAggregateTypeForABI(RetTy)) {
|
|
// Treat an enum type as its underlying type.
|
|
if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
|
|
RetTy = EnumTy->getDecl()->getIntegerType();
|
|
|
|
if (Size > 64 && RetTy->isBitIntType())
|
|
return getNaturalAlignIndirect(
|
|
RetTy, getDataLayout().getAllocaAddrSpace(), /*ByVal=*/false);
|
|
|
|
return isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
|
|
: ABIArgInfo::getDirect();
|
|
}
|
|
|
|
if (isEmptyRecord(getContext(), RetTy, true))
|
|
return ABIArgInfo::getIgnore();
|
|
|
|
// Aggregates <= 8 bytes are returned in registers, other aggregates
|
|
// are returned indirectly.
|
|
if (Size <= 64) {
|
|
// Return in the smallest viable integer type.
|
|
Size = llvm::bit_ceil(Size);
|
|
return ABIArgInfo::getDirect(llvm::Type::getIntNTy(getVMContext(), Size));
|
|
}
|
|
return getNaturalAlignIndirect(RetTy, getDataLayout().getAllocaAddrSpace(),
|
|
/*ByVal=*/true);
|
|
}
|
|
|
|
Address HexagonABIInfo::EmitVAArgFromMemory(CodeGenFunction &CGF,
|
|
Address VAListAddr,
|
|
QualType Ty) const {
|
|
// Load the overflow area pointer.
|
|
Address __overflow_area_pointer_p =
|
|
CGF.Builder.CreateStructGEP(VAListAddr, 2, "__overflow_area_pointer_p");
|
|
llvm::Value *__overflow_area_pointer = CGF.Builder.CreateLoad(
|
|
__overflow_area_pointer_p, "__overflow_area_pointer");
|
|
|
|
uint64_t Align = CGF.getContext().getTypeAlign(Ty) / 8;
|
|
if (Align > 4) {
|
|
// Alignment should be a power of 2.
|
|
assert((Align & (Align - 1)) == 0 && "Alignment is not power of 2!");
|
|
|
|
// overflow_arg_area = (overflow_arg_area + align - 1) & -align;
|
|
llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int64Ty, Align - 1);
|
|
|
|
// Add offset to the current pointer to access the argument.
|
|
__overflow_area_pointer =
|
|
CGF.Builder.CreateGEP(CGF.Int8Ty, __overflow_area_pointer, Offset);
|
|
llvm::Value *AsInt =
|
|
CGF.Builder.CreatePtrToInt(__overflow_area_pointer, CGF.Int32Ty);
|
|
|
|
// Create a mask which should be "AND"ed
|
|
// with (overflow_arg_area + align - 1)
|
|
llvm::Value *Mask = llvm::ConstantInt::get(CGF.Int32Ty, -(int)Align);
|
|
__overflow_area_pointer = CGF.Builder.CreateIntToPtr(
|
|
CGF.Builder.CreateAnd(AsInt, Mask), __overflow_area_pointer->getType(),
|
|
"__overflow_area_pointer.align");
|
|
}
|
|
|
|
// Get the type of the argument from memory and bitcast
|
|
// overflow area pointer to the argument type.
|
|
llvm::Type *PTy = CGF.ConvertTypeForMem(Ty);
|
|
Address AddrTyped =
|
|
Address(__overflow_area_pointer, PTy, CharUnits::fromQuantity(Align));
|
|
|
|
// Round up to the minimum stack alignment for varargs which is 4 bytes.
|
|
uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4);
|
|
|
|
__overflow_area_pointer = CGF.Builder.CreateGEP(
|
|
CGF.Int8Ty, __overflow_area_pointer,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, Offset),
|
|
"__overflow_area_pointer.next");
|
|
CGF.Builder.CreateStore(__overflow_area_pointer, __overflow_area_pointer_p);
|
|
|
|
return AddrTyped;
|
|
}
|
|
|
|
Address HexagonABIInfo::EmitVAArgForHexagon(CodeGenFunction &CGF,
|
|
Address VAListAddr,
|
|
QualType Ty) const {
|
|
// FIXME: Need to handle alignment
|
|
llvm::Type *BP = CGF.Int8PtrTy;
|
|
CGBuilderTy &Builder = CGF.Builder;
|
|
Address VAListAddrAsBPP = VAListAddr.withElementType(BP);
|
|
llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
|
|
// Handle address alignment for type alignment > 32 bits
|
|
uint64_t TyAlign = CGF.getContext().getTypeAlign(Ty) / 8;
|
|
if (TyAlign > 4) {
|
|
assert((TyAlign & (TyAlign - 1)) == 0 && "Alignment is not power of 2!");
|
|
llvm::Value *AddrAsInt = Builder.CreatePtrToInt(Addr, CGF.Int32Ty);
|
|
AddrAsInt = Builder.CreateAdd(AddrAsInt, Builder.getInt32(TyAlign - 1));
|
|
AddrAsInt = Builder.CreateAnd(AddrAsInt, Builder.getInt32(~(TyAlign - 1)));
|
|
Addr = Builder.CreateIntToPtr(AddrAsInt, BP);
|
|
}
|
|
Address AddrTyped =
|
|
Address(Addr, CGF.ConvertType(Ty), CharUnits::fromQuantity(TyAlign));
|
|
|
|
uint64_t Offset = llvm::alignTo(CGF.getContext().getTypeSize(Ty) / 8, 4);
|
|
llvm::Value *NextAddr = Builder.CreateGEP(
|
|
CGF.Int8Ty, Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset), "ap.next");
|
|
Builder.CreateStore(NextAddr, VAListAddrAsBPP);
|
|
|
|
return AddrTyped;
|
|
}
|
|
|
|
Address HexagonABIInfo::EmitVAArgForHexagonLinux(CodeGenFunction &CGF,
|
|
Address VAListAddr,
|
|
QualType Ty) const {
|
|
int ArgSize = CGF.getContext().getTypeSize(Ty) / 8;
|
|
|
|
if (ArgSize > 8)
|
|
return EmitVAArgFromMemory(CGF, VAListAddr, Ty);
|
|
|
|
// Here we have check if the argument is in register area or
|
|
// in overflow area.
|
|
// If the saved register area pointer + argsize rounded up to alignment >
|
|
// saved register area end pointer, argument is in overflow area.
|
|
unsigned RegsLeft = 6;
|
|
Ty = CGF.getContext().getCanonicalType(Ty);
|
|
(void)classifyArgumentType(Ty, &RegsLeft);
|
|
|
|
llvm::BasicBlock *MaybeRegBlock = CGF.createBasicBlock("vaarg.maybe_reg");
|
|
llvm::BasicBlock *InRegBlock = CGF.createBasicBlock("vaarg.in_reg");
|
|
llvm::BasicBlock *OnStackBlock = CGF.createBasicBlock("vaarg.on_stack");
|
|
llvm::BasicBlock *ContBlock = CGF.createBasicBlock("vaarg.end");
|
|
|
|
// Get rounded size of the argument.GCC does not allow vararg of
|
|
// size < 4 bytes. We follow the same logic here.
|
|
ArgSize = (CGF.getContext().getTypeSize(Ty) <= 32) ? 4 : 8;
|
|
int ArgAlign = (CGF.getContext().getTypeSize(Ty) <= 32) ? 4 : 8;
|
|
|
|
// Argument may be in saved register area
|
|
CGF.EmitBlock(MaybeRegBlock);
|
|
|
|
// Load the current saved register area pointer.
|
|
Address __current_saved_reg_area_pointer_p = CGF.Builder.CreateStructGEP(
|
|
VAListAddr, 0, "__current_saved_reg_area_pointer_p");
|
|
llvm::Value *__current_saved_reg_area_pointer = CGF.Builder.CreateLoad(
|
|
__current_saved_reg_area_pointer_p, "__current_saved_reg_area_pointer");
|
|
|
|
// Load the saved register area end pointer.
|
|
Address __saved_reg_area_end_pointer_p = CGF.Builder.CreateStructGEP(
|
|
VAListAddr, 1, "__saved_reg_area_end_pointer_p");
|
|
llvm::Value *__saved_reg_area_end_pointer = CGF.Builder.CreateLoad(
|
|
__saved_reg_area_end_pointer_p, "__saved_reg_area_end_pointer");
|
|
|
|
// If the size of argument is > 4 bytes, check if the stack
|
|
// location is aligned to 8 bytes
|
|
if (ArgAlign > 4) {
|
|
|
|
llvm::Value *__current_saved_reg_area_pointer_int =
|
|
CGF.Builder.CreatePtrToInt(__current_saved_reg_area_pointer,
|
|
CGF.Int32Ty);
|
|
|
|
__current_saved_reg_area_pointer_int = CGF.Builder.CreateAdd(
|
|
__current_saved_reg_area_pointer_int,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, (ArgAlign - 1)),
|
|
"align_current_saved_reg_area_pointer");
|
|
|
|
__current_saved_reg_area_pointer_int =
|
|
CGF.Builder.CreateAnd(__current_saved_reg_area_pointer_int,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, -ArgAlign),
|
|
"align_current_saved_reg_area_pointer");
|
|
|
|
__current_saved_reg_area_pointer =
|
|
CGF.Builder.CreateIntToPtr(__current_saved_reg_area_pointer_int,
|
|
__current_saved_reg_area_pointer->getType(),
|
|
"align_current_saved_reg_area_pointer");
|
|
}
|
|
|
|
llvm::Value *__new_saved_reg_area_pointer =
|
|
CGF.Builder.CreateGEP(CGF.Int8Ty, __current_saved_reg_area_pointer,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, ArgSize),
|
|
"__new_saved_reg_area_pointer");
|
|
|
|
llvm::Value *UsingStack = nullptr;
|
|
UsingStack = CGF.Builder.CreateICmpSGT(__new_saved_reg_area_pointer,
|
|
__saved_reg_area_end_pointer);
|
|
|
|
CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, InRegBlock);
|
|
|
|
// Argument in saved register area
|
|
// Implement the block where argument is in register saved area
|
|
CGF.EmitBlock(InRegBlock);
|
|
|
|
CGF.Builder.CreateStore(__new_saved_reg_area_pointer,
|
|
__current_saved_reg_area_pointer_p);
|
|
|
|
CGF.EmitBranch(ContBlock);
|
|
|
|
// Argument in overflow area
|
|
// Implement the block where the argument is in overflow area.
|
|
CGF.EmitBlock(OnStackBlock);
|
|
|
|
// Load the overflow area pointer
|
|
Address __overflow_area_pointer_p =
|
|
CGF.Builder.CreateStructGEP(VAListAddr, 2, "__overflow_area_pointer_p");
|
|
llvm::Value *__overflow_area_pointer = CGF.Builder.CreateLoad(
|
|
__overflow_area_pointer_p, "__overflow_area_pointer");
|
|
|
|
// Align the overflow area pointer according to the alignment of the argument
|
|
if (ArgAlign > 4) {
|
|
llvm::Value *__overflow_area_pointer_int =
|
|
CGF.Builder.CreatePtrToInt(__overflow_area_pointer, CGF.Int32Ty);
|
|
|
|
__overflow_area_pointer_int =
|
|
CGF.Builder.CreateAdd(__overflow_area_pointer_int,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, ArgAlign - 1),
|
|
"align_overflow_area_pointer");
|
|
|
|
__overflow_area_pointer_int =
|
|
CGF.Builder.CreateAnd(__overflow_area_pointer_int,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, -ArgAlign),
|
|
"align_overflow_area_pointer");
|
|
|
|
__overflow_area_pointer = CGF.Builder.CreateIntToPtr(
|
|
__overflow_area_pointer_int, __overflow_area_pointer->getType(),
|
|
"align_overflow_area_pointer");
|
|
}
|
|
|
|
// Get the pointer for next argument in overflow area and store it
|
|
// to overflow area pointer.
|
|
llvm::Value *__new_overflow_area_pointer = CGF.Builder.CreateGEP(
|
|
CGF.Int8Ty, __overflow_area_pointer,
|
|
llvm::ConstantInt::get(CGF.Int32Ty, ArgSize),
|
|
"__overflow_area_pointer.next");
|
|
|
|
CGF.Builder.CreateStore(__new_overflow_area_pointer,
|
|
__overflow_area_pointer_p);
|
|
|
|
CGF.Builder.CreateStore(__new_overflow_area_pointer,
|
|
__current_saved_reg_area_pointer_p);
|
|
|
|
CGF.EmitBranch(ContBlock);
|
|
// Get the correct pointer to load the variable argument
|
|
// Implement the ContBlock
|
|
CGF.EmitBlock(ContBlock);
|
|
|
|
llvm::Type *MemTy = CGF.ConvertTypeForMem(Ty);
|
|
llvm::PHINode *ArgAddr = CGF.Builder.CreatePHI(
|
|
llvm::PointerType::getUnqual(MemTy->getContext()), 2, "vaarg.addr");
|
|
ArgAddr->addIncoming(__current_saved_reg_area_pointer, InRegBlock);
|
|
ArgAddr->addIncoming(__overflow_area_pointer, OnStackBlock);
|
|
|
|
return Address(ArgAddr, MemTy, CharUnits::fromQuantity(ArgAlign));
|
|
}
|
|
|
|
RValue HexagonABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
|
|
QualType Ty, AggValueSlot Slot) const {
|
|
|
|
if (getTarget().getTriple().isMusl())
|
|
return CGF.EmitLoadOfAnyValue(
|
|
CGF.MakeAddrLValue(EmitVAArgForHexagonLinux(CGF, VAListAddr, Ty), Ty),
|
|
Slot);
|
|
|
|
return CGF.EmitLoadOfAnyValue(
|
|
CGF.MakeAddrLValue(EmitVAArgForHexagon(CGF, VAListAddr, Ty), Ty), Slot);
|
|
}
|
|
|
|
std::unique_ptr<TargetCodeGenInfo>
|
|
CodeGen::createHexagonTargetCodeGenInfo(CodeGenModule &CGM) {
|
|
return std::make_unique<HexagonTargetCodeGenInfo>(CGM.getTypes());
|
|
}
|