llvm/clang/lib/CodeGen/SwiftCallingConv.cpp

//===--- SwiftCallingConv.cpp - Lowering for the Swift calling convention -===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Implementation of the abstract lowering for the Swift calling convention.
//
//===----------------------------------------------------------------------===//

#include "clang/CodeGen/SwiftCallingConv.h"
#include "ABIInfo.h"
#include "CodeGenModule.h"
#include "TargetInfo.h"
#include "clang/Basic/TargetInfo.h"
#include <optional>

usingnamespaceclang;
usingnamespaceCodeGen;
usingnamespaceswiftcall;

static const SwiftABIInfo &getSwiftABIInfo(CodeGenModule &CGM) { … }

static bool isPowerOf2(unsigned n) { … }

/// Given two types with the same size, try to find a common type.
static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) { … }

static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) { … }

static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type) { … }

void SwiftAggLowering::addTypedData(QualType type, CharUnits begin) { … }

void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin) { … }

void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin,
                                    const ASTRecordLayout &layout) { … }

void SwiftAggLowering::addBitFieldData(const FieldDecl *bitfield,
                                       CharUnits recordBegin,
                                       uint64_t bitfieldBitBegin) { … }

void SwiftAggLowering::addTypedData(llvm::Type *type, CharUnits begin) { … }

void SwiftAggLowering::addTypedData(llvm::Type *type,
                                    CharUnits begin, CharUnits end) { … }

void SwiftAggLowering::addLegalTypedData(llvm::Type *type,
                                         CharUnits begin, CharUnits end) { … }

void SwiftAggLowering::addEntry(llvm::Type *type,
                                CharUnits begin, CharUnits end) { … }

/// Replace the entry of vector type at offset 'index' with a sequence
/// of its component vectors.
void SwiftAggLowering::splitVectorEntry(unsigned index) { … }

/// Given a power-of-two unit size, return the offset of the aligned unit
/// of that size which contains the given offset.
///
/// In other words, round down to the nearest multiple of the unit size.
static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) { … }

static bool areBytesInSameUnit(CharUnits first, CharUnits second,
                               CharUnits chunkSize) { … }

static bool isMergeableEntryType(llvm::Type *type) { … }

bool SwiftAggLowering::shouldMergeEntries(const StorageEntry &first,
                                          const StorageEntry &second,
                                          CharUnits chunkSize) { … }

void SwiftAggLowering::finish() { … }

void SwiftAggLowering::enumerateComponents(EnumerationCallback callback) const { … }

std::pair<llvm::StructType*, llvm::Type*>
SwiftAggLowering::getCoerceAndExpandTypes() const { … }

bool SwiftAggLowering::shouldPassIndirectly(bool asReturnValue) const { … }

bool swiftcall::shouldPassIndirectly(CodeGenModule &CGM,
                                     ArrayRef<llvm::Type*> componentTys,
                                     bool asReturnValue) { … }

CharUnits swiftcall::getMaximumVoluntaryIntegerSize(CodeGenModule &CGM) { … }

CharUnits swiftcall::getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type) { … }

bool swiftcall::isLegalIntegerType(CodeGenModule &CGM,
                                   llvm::IntegerType *intTy) { … }

bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
                                  llvm::VectorType *vectorTy) { … }

bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
                                  llvm::Type *eltTy, unsigned numElts) { … }

std::pair<llvm::Type*, unsigned>
swiftcall::splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
                                llvm::VectorType *vectorTy) { … }

void swiftcall::legalizeVectorType(CodeGenModule &CGM, CharUnits origVectorSize,
                                   llvm::VectorType *origVectorTy,
                             llvm::SmallVectorImpl<llvm::Type*> &components) { … }

bool swiftcall::mustPassRecordIndirectly(CodeGenModule &CGM,
                                         const RecordDecl *record) { … }

static ABIArgInfo classifyExpandedType(SwiftAggLowering &lowering,
                                       bool forReturn,
                                       CharUnits alignmentForIndirect) { … }

static ABIArgInfo classifyType(CodeGenModule &CGM, CanQualType type,
                               bool forReturn) { … }

ABIArgInfo swiftcall::classifyReturnType(CodeGenModule &CGM, CanQualType type) { … }

ABIArgInfo swiftcall::classifyArgumentType(CodeGenModule &CGM,
                                           CanQualType type) { … }

void swiftcall::computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI) { … }

// Is swifterror lowered to a register by the target ABI.
bool swiftcall::isSwiftErrorLoweredInRegister(CodeGenModule &CGM) { … }