cpp_uno/gcc3_freebsd_aarch64/abi.cxx

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_bridges.hxx"

// This is an implementation of the parameter-classification rules of the
// AArch64 procedure call standard ("Procedure Call Standard for the Arm 64-bit
// Architecture", ARM IHI 0055).
//
// Unlike the System V AMD64 ABI (used by the x86-64 bridge), AAPCS64 does not
// split aggregates into per-eightbyte INTEGER/SSE classes.  Instead:
//   * scalars go in one GPR (x) or one FP/SIMD (v) register;
//   * a Homogeneous Floating-point Aggregate (HFA: <= 4 members, all the same
//     FP type, recursively) goes in consecutive v registers;
//   * any other aggregate <= 16 bytes goes in 1-2 GPRs;
//   * a non-HFA aggregate > 16 bytes is passed indirectly (a pointer to a
//     caller-allocated copy).
// Register fill is "all or nothing": if an aggregate does not fit entirely in
// the remaining registers of its bank, it is passed wholly on the stack.
//
// This is a clean-room implementation from the public specifications; see
// ../../../../AAPCS64_BRIDGE_SPEC.md.

#include "abi.hxx"

#include "bridges/cpp_uno/shared/types.hxx"

#include <rtl/ustring.hxx>
#include <string.h>

using namespace aarch64;

namespace {

// The element type of a Homogeneous Floating-point Aggregate.
enum HfaKind
{
    HFA_NONE,       // not (yet) an HFA
    HFA_FLOAT,      // all members are FLOAT (4-byte)
    HFA_DOUBLE      // all members are DOUBLE (8-byte)
};

// Combine the running HFA kind with a newly-seen member kind.  Two members
// of different FP types, or any non-FP member, break the homogeneity.
HfaKind mergeHfa( HfaKind running, HfaKind seen )
{
    if ( seen == HFA_NONE )
        return HFA_NONE;
    if ( running == HFA_NONE )
        return seen;
    return ( running == seen ) ? running : HFA_NONE;
}

bool isComplexAggregate( typelib_TypeDescriptionReference *pTypeRef )
{
    typelib_TypeDescription * pTypeDescr = 0;
    TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
    const typelib_CompoundTypeDescription *pComp =
        reinterpret_cast<const typelib_CompoundTypeDescription *>( pTypeDescr );
    bool complex = pComp->pBaseTypeDescription != 0 &&
        isComplexAggregate( pComp->pBaseTypeDescription->aBase.pWeakRef );
    for ( sal_Int32 i = 0; !complex && i < pComp->nMembers; ++i )
    {
        typelib_TypeClass typeClass = pComp->ppTypeRefs[i]->eTypeClass;
        if ( typeClass == typelib_TypeClass_STRUCT ||
             typeClass == typelib_TypeClass_EXCEPTION )
            complex = isComplexAggregate( pComp->ppTypeRefs[i] );
        else
            complex = !bridges::cpp_uno::shared::isSimpleType( typeClass );
    }
    TYPELIB_DANGER_RELEASE( pTypeDescr );
    return complex;
}

// Recursively determine whether pTypeRef is (part of) a homogeneous
// floating-point aggregate, accumulating the element kind and member count.
//
// Returns false the moment homogeneity is violated (a non-FP scalar, or a
// second distinct FP type, or > 4 elements).  A FLOAT/DOUBLE scalar counts as
// a 1-element HFA of itself; a struct flattens its members (and base classes).
bool collectHfa( typelib_TypeDescriptionReference *pTypeRef, HfaKind &rKind, int &rCount )
{
    switch ( pTypeRef->eTypeClass )
    {
        case typelib_TypeClass_FLOAT:
            rKind = mergeHfa( rKind, HFA_FLOAT );
            if ( rKind == HFA_NONE ) return false;
            return ( ++rCount <= 4 );

        case typelib_TypeClass_DOUBLE:
            rKind = mergeHfa( rKind, HFA_DOUBLE );
            if ( rKind == HFA_NONE ) return false;
            return ( ++rCount <= 4 );

        case typelib_TypeClass_STRUCT:
        case typelib_TypeClass_EXCEPTION:
        {
            typelib_TypeDescription * pTypeDescr = 0;
            TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );

            const typelib_CompoundTypeDescription *pComp =
                reinterpret_cast<const typelib_CompoundTypeDescription*>( pTypeDescr );

            // rCount is cumulative over the whole recursion, so remember where
            // this aggregate started in order to size-check it below.
            const int nCountAtEntry = rCount;
            bool bOk = true;

            // Flatten base class first (its members precede ours in layout).
            if ( pComp->pBaseTypeDescription )
            {
                bOk = collectHfa(
                    pComp->pBaseTypeDescription->aBase.pWeakRef, rKind, rCount );
            }

            for ( sal_Int32 i = 0; bOk && i < pComp->nMembers; ++i )
                bOk = collectHfa( pComp->ppTypeRefs[i], rKind, rCount );

            if ( bOk )
            {
                // Reject anything the elements do not tile exactly: only the
                // elements contributed by THIS aggregate count towards its size.
                sal_Int32 elementSize = rKind == HFA_FLOAT ? 4 : 8;
                bOk = pTypeDescr->nSize ==
                    ( rCount - nCountAtEntry ) * elementSize;
                for ( sal_Int32 i = 0; bOk && i < pComp->nMembers; ++i )
                    bOk = pComp->pMemberOffsets[i] % elementSize == 0;
            }

            TYPELIB_DANGER_RELEASE( pTypeDescr );
            return bOk;
        }

        default:
            // Any non-FP, non-aggregate member breaks homogeneity.
            rKind = HFA_NONE;
            return false;
    }
}

// Classify an aggregate (STRUCT/EXCEPTION).  Sets the GPR/FPR counts and
// returns true if it is passed in registers, false if it must be passed
// indirectly (in memory).
bool classifyAggregate( typelib_TypeDescriptionReference *pTypeRef, int &nUsedGPR, int &nUsedFPR )
{
    // First, the HFA test.
    HfaKind kind = HFA_NONE;
    int count = 0;
    if ( collectHfa( pTypeRef, kind, count ) && kind != HFA_NONE )
    {
        nUsedFPR = count;
        nUsedGPR = 0;
        return true; // HFA passed in consecutive FP regs
    }

    // Not HFA: if bigger than 16 bytes, pass indirectly.
    typelib_TypeDescription * pTypeDescr = 0;
    TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
    if ( pTypeDescr->nSize > 16 )
    {
        TYPELIB_DANGER_RELEASE( pTypeDescr );
        nUsedGPR = nUsedFPR = 0;
        return false; // indirect
    }

    // small aggregate: it occupies 1 or 2 GPRs depending on size
    nUsedFPR = 0;
    nUsedGPR = ( pTypeDescr->nSize + 7 ) / 8;
    if ( nUsedGPR < 1 ) nUsedGPR = 1;
    TYPELIB_DANGER_RELEASE( pTypeDescr );
    return true;
}

} // anonymous namespace

// Public API implementations.
namespace aarch64
{

bool examine_argument( typelib_TypeDescriptionReference *pTypeRef, bool bInReturn, int &nUsedGPR, int &nUsedFPR )
{
    // For returns, the hidden param rule uses >16 bytes for aggregates.
    if ( pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION )
    {
        return classifyAggregate( pTypeRef, nUsedGPR, nUsedFPR );
    }

    // Scalars: floats -> FPR, others -> GPR
    switch ( pTypeRef->eTypeClass )
    {
        case typelib_TypeClass_FLOAT:
            nUsedFPR = 1; nUsedGPR = 0; return true;
        case typelib_TypeClass_DOUBLE:
            nUsedFPR = 1; nUsedGPR = 0; return true;
        default:
            nUsedFPR = 0; nUsedGPR = 1; return true;
    }
}

bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
{
    if ( pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION )
    {
        typelib_TypeDescription * pTypeDescr = 0;
        TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
        bool ret = pTypeDescr->nSize > 16;
        TYPELIB_DANGER_RELEASE( pTypeDescr );
        return ret;
    }
    return false; // scalars and small aggregates return in registers
}

sal_uInt32 get_return_kind( typelib_TypeDescriptionReference *pTypeRef )
{
    if ( pTypeRef->eTypeClass == typelib_TypeClass_FLOAT )
        return typelib_TypeClass_FLOAT;

    if ( pTypeRef->eTypeClass == typelib_TypeClass_DOUBLE )
        return typelib_TypeClass_DOUBLE;

    if ( pTypeRef->eTypeClass == typelib_TypeClass_STRUCT ||
         pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION )
    {
        HfaKind kind = HFA_NONE;
        int count = 0;

        if ( collectHfa( pTypeRef, kind, count ) )
        {
            if ( kind == HFA_FLOAT )
                return RETURN_KIND_HFA_FLOAT;

            if ( kind == HFA_DOUBLE )
                return RETURN_KIND_HFA_DOUBLE;
        }
    }

    return pTypeRef->eTypeClass;
}

void fill_struct( typelib_TypeDescriptionReference *pTypeRef, const sal_uInt64* pGPR, const double* pFPR, void *pStruct )
{
    // For small aggregates, copy from GPR slots; for HFAs, copy from FPR slots.
    if ( pTypeRef->eTypeClass == typelib_TypeClass_STRUCT || pTypeRef->eTypeClass == typelib_TypeClass_EXCEPTION )
    {
        int nGPR=0, nFPR=0;
        if ( classifyAggregate( pTypeRef, nGPR, nFPR ) )
        {
            if ( nFPR > 0 )
            {
            // HFA: copy elements from FPR slots. For FLOAT HFAs each element is
            // 4 bytes but occupies an 8-byte saved slot; copy each float from the
            // low 4 bytes of the corresponding double-sized slot. DOUBLE HFAs
            // can be copied directly.
            HfaKind kind = HFA_NONE;
            int count = 0;
            if ( collectHfa( pTypeRef, kind, count ) && kind == HFA_FLOAT )
            {
                for ( int i = 0; i < nFPR; ++i )
                    memcpy(
                        static_cast<char *>( pStruct ) + i * sizeof(float),
                        reinterpret_cast<const char *>( pFPR) + i * sizeof(double),
                        sizeof(float) );
            }
            else
            {
                memcpy( pStruct, pFPR, nFPR * sizeof(double) );
            }
            }
            else
            {
                memcpy( pStruct, pGPR, nGPR * sizeof(sal_uInt64) );
            }
        }
    }
}

sal_uInt32 align_stack_offset( sal_uInt32 offset, typelib_TypeDescriptionReference *pTypeRef )
{
    // AArch64 stack overflow area is packed; align to natural alignment of the type (8)
    const sal_uInt32 align = 8;
    return ( offset + align - 1 ) & ~( align - 1 );
}

sal_uInt32 stack_size( typelib_TypeDescriptionReference *pTypeRef )
{
    // For simple types and small aggregates, size is rounded to 8
    typelib_TypeDescription * pTypeDescr = 0;
    TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
    sal_uInt32 size = pTypeDescr->nSize;
    TYPELIB_DANGER_RELEASE( pTypeDescr );
    return ( size + 7 ) & ~7u;
}

} // namespace aarch64