| //===- BPF.cpp - BPF ABI Implementation ----------------------------------===// | |
| // | |
| // 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 "llvm/ABI/FunctionInfo.h" | |
| #include "llvm/ABI/TargetInfo.h" | |
| #include "llvm/ABI/Types.h" | |
| #include "llvm/Support/Alignment.h" | |
| #include "llvm/Support/Casting.h" | |
| namespace llvm::abi { | |
| class BPFTargetInfo : public TargetInfo { | |
| private: | |
| ABICompatInfo CompatInfo; | |
| ArgInfo classifyReturnType(const Type *RetTy) const { | |
| if (RetTy->isVoid()) | |
| return ArgInfo::getIgnore(); | |
| if (isAggregateTypeForABI(RetTy)) { | |
| if (RetTy->isZeroSize()) | |
| return ArgInfo::getIgnore(); | |
| return getNaturalAlignIndirect(RetTy, /*ByVal=*/false); | |
| } | |
| if (const auto *IntTy = dyn_cast<IntegerType>(RetTy)) { | |
| if (IntTy->isBitInt() && IntTy->getSizeInBits().getFixedValue() > 128) | |
| return getNaturalAlignIndirect(RetTy, /*ByVal=*/false); | |
| } | |
| return ArgInfo::getDirect(); | |
| } | |
| ArgInfo classifyArgumentType(const Type *ArgTy) const { | |
| if (const auto *RT = dyn_cast<RecordType>(ArgTy)) | |
| if (RT->isTransparentUnion() && RT->getNumFields() > 0) | |
| ArgTy = RT->getFields()[0].FieldType; | |
| if (isAggregateTypeForABI(ArgTy)) { | |
| if (ArgTy->isZeroSize()) | |
| return ArgInfo::getIgnore(); | |
| auto SizeInBits = ArgTy->getSizeInBits().getFixedValue(); | |
| if (SizeInBits <= 128) { | |
| const Type *CoerceTy; | |
| if (SizeInBits <= 64) { | |
| CoerceTy = TB.getIntegerType(alignTo(SizeInBits, 8), Align(8), false); | |
| } else { | |
| const Type *RegTy = TB.getIntegerType(64, Align(8), false); | |
| CoerceTy = TB.getArrayType(RegTy, 2, 128); | |
| } | |
| return ArgInfo::getDirect(CoerceTy); | |
| } | |
| return getNaturalAlignIndirect(ArgTy, /*ByVal=*/true); | |
| } | |
| if (const auto *IntTy = dyn_cast<IntegerType>(ArgTy)) { | |
| if (IntTy->isBitInt() && IntTy->getSizeInBits().getFixedValue() > 128) | |
| return getNaturalAlignIndirect(ArgTy, /*ByVal=*/true); | |
| if (isPromotableInteger(IntTy)) | |
| return ArgInfo::getExtend(ArgTy); | |
| } | |
| return ArgInfo::getDirect(); | |
| } | |
| public: | |
| BPFTargetInfo(TypeBuilder &Builder) : TargetInfo(Builder) {} | |
| const ABICompatInfo &getABICompatInfo() const override { return CompatInfo; } | |
| void computeInfo(FunctionInfo &FI) const override { | |
| FI.getReturnInfo() = classifyReturnType(FI.getReturnType()); | |
| for (auto &I : FI.arguments()) | |
| I.Info = classifyArgumentType(I.ABIType); | |
| } | |
| }; | |
| std::unique_ptr<TargetInfo> createBPFTargetInfo(TypeBuilder &TB) { | |
| return std::make_unique<BPFTargetInfo>(TB); | |
| } | |
| } // namespace llvm::abi |