lib/libtnf/abi.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 *  Copyright (c) 1994, by Sun Microsytems, Inc.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "libtnf.h"

/*
 * Operations based on ABI bootstrap assumptions
 */

#define _GET_TAG(tnf, p)        \
    _GET_REF32(tnf, p)

#define _GET_TAG_ARG(tnf, p)        \
    _GET_REF16(tnf, p)

#define _GET_SELF_SIZE(tnf, p)      \
    _GET_UINT32(tnf, &((struct tnf_array_hdr *)(p))->self_size)

#define _GET_NAME(tnf, p)       \
    _GET_REF32(tnf, &((struct tnf_type_hdr *)(p))->name)

#define _GET_PROPERTIES(tnf, p)     \
    _GET_REF32(tnf, &((struct tnf_type_hdr *)(p))->properties)

#define _GET_SLOT_TYPES(tnf, p)     \
    _GET_REF32(tnf, &((struct tnf_struct_type_hdr *)(p))->slot_types)

#define _GET_TYPE_SIZE(tnf, p)      \
    _GET_UINT32(tnf, &((struct tnf_struct_type_hdr *)(p))->type_size)

#define _GET_HEADER_SIZE(tnf, p)    \
    _GET_UINT32(tnf, &((struct tnf_array_type_hdr *)(p))->header_size)

#define _GET_DERIVED_BASE(tnf, p)   \
    _GET_REF32(tnf, &((struct tnf_derived_type_hdr *)(p))->derived_base)

/*
 * Static declarations
 */

static caddr_t  fetch_slot(TNF *, caddr_t, tnf_ref32_t *);

/*
 * retrieve tag slot from a record
 */

tnf_ref32_t *
_tnf_get_tag(TNF *tnf, tnf_ref32_t *record)
{
    return (_GET_TAG(tnf, record));
}

/*
 * Retrieve tag_arg from tag slot of a record
 */

tnf_ref32_t *
_tnf_get_tag_arg(TNF *tnf, tnf_ref32_t *record)
{
    return (_GET_TAG_ARG(tnf, record));
}

/*
 * Retrieve the self_size slot of an ABI array record
 */

size_t
_tnf_get_self_size(TNF *tnf, tnf_ref32_t *array)
{
    return (_GET_SELF_SIZE(tnf, array));
}

/*
 * Calculate the number of elements in ABI array record
 */

unsigned
_tnf_get_element_count(TNF *tnf, tnf_ref32_t *array, unsigned eltsize)
{
    size_t      size, hdrsize;
#ifdef INFINITE_RECURSION_ARRAY
    tnf_ref32_t *base_tag;

    size        = _tnf_get_self_size(tnf, array);
    base_tag    = _tnf_get_base_tag(tnf, _tnf_get_tag(tnf, array));
    hdrsize     = _tnf_get_header_size(tnf, base_tag);
    return (((size - hdrsize) / eltsize));
#else
    size        = _tnf_get_self_size(tnf, array);
    hdrsize     = sizeof (struct tnf_array_hdr);
    return (((size - hdrsize) / eltsize));
#endif
}

/*
 * Retrieve the base pointer of an ABI array record
 */

caddr_t
/* ARGSUSED */
_tnf_get_elements(TNF *tnf, tnf_ref32_t *array)
{
#ifdef INFINITE_RECURSION_ARRAY
    size_t      hdrsize;
    tnf_ref32_t *base_tag;

    base_tag    = _tnf_get_base_tag(tnf, _tnf_get_tag(tnf, array));
    hdrsize     = _tnf_get_header_size(tnf, base_tag);
    return ((caddr_t)((char *)array + hdrsize));
#else
    return ((caddr_t)((char *)array + sizeof (struct tnf_array_hdr)));
#endif
}

/*
 * Retrieve the chars in an ABI string record
 */

char *
_tnf_get_chars(TNF *tnf, tnf_ref32_t *string)
{
    return ((char *)_tnf_get_elements(tnf, string));
}

/*
 * Retrieve the string in the name slot of a type record
 */

char *
_tnf_get_name(TNF *tnf, tnf_ref32_t *tag)
{
    return (_tnf_get_chars(tnf, _GET_NAME(tnf, tag)));
}

/*
 * Retrieve the properties array slot of a type record
 */

tnf_ref32_t *
_tnf_get_properties(TNF *tnf, tnf_ref32_t *tag)
{
    return (_GET_PROPERTIES(tnf, tag));
}

/*
 * Retrieve the slot_types slot of struct_type or array_type record
 */

tnf_ref32_t *
_tnf_get_slot_types(TNF *tnf, tnf_ref32_t *tag)
{
    return (_GET_SLOT_TYPES(tnf, tag));
}

/*
 * Retrieve the header_size slot of an array_type record
 */

size_t
_tnf_get_header_size(TNF *tnf, tnf_ref32_t *tag)
{
    return (_GET_HEADER_SIZE(tnf, tag));
}

/*
 * Retrieve the derived_base slot of a derived_type record
 */

tnf_ref32_t *
_tnf_get_derived_base(TNF *tnf, tnf_ref32_t *tag)
{
    return (_GET_DERIVED_BASE(tnf, tag));
}


/*
 * Find the root (self-tagged) type record
 */

tnf_ref32_t *
_tnf_get_root_tag(TNF *tnf, tnf_ref32_t *record)
{
    if (tnf->root_tag)
        return (tnf->root_tag);
    else {
        tnf_ref32_t *p1, *p2;
        p1 = record;
        while ((p2 = _tnf_get_tag(tnf, p1)) != p1)
            p1 = p2;
        tnf->root_tag = p2;
        return (p2);
    }
}

/*
 * Search ABI type array for a type named name
 */

tnf_ref32_t *
_tnf_get_element_named(TNF *tnf, tnf_ref32_t *array, char *name)
{
    unsigned    count, i;
    tnf_ref32_t *elts;

    count   = _tnf_get_element_count(tnf, array, sizeof (tnf_ref32_t));
    /* LINTED pointer cast may result in improper alignment */
    elts    = (tnf_ref32_t *)_tnf_get_elements(tnf, array);

    for (i = 0; i < count; i++) {
        tnf_ref32_t *type_elt;

        if ((type_elt = _GET_REF32(tnf, &elts[i])) == TNF_NULL) {
            /* Can't have missing type records */
            _tnf_error(tnf, TNF_ERR_BADTNF);
            return (TNF_NULL);
        }

        if (strcmp(name, _tnf_get_name(tnf, type_elt)) == 0)
            /* Found a type record named name */
            return (type_elt);
    }
    return (TNF_NULL);
}

/*
 * Look in type record's properties for named type.
 * Recursively look at derived_base properties as well.
 */

tnf_ref32_t *
_tnf_get_property(TNF *tnf, tnf_ref32_t *tag, char *name)
{
    tnf_ref32_t *properties, *property;

    if (strcmp(name, _tnf_get_name(tnf, tag)) == 0)
        /* name is type name */
        return (tag);

    if ((properties = _tnf_get_properties(tnf, tag)) == TNF_NULL)
        /* no properties */
        return (TNF_NULL);

    if ((property = _tnf_get_element_named(tnf, properties, name))
        != TNF_NULL)
        /* found property named name */
        return (property);

    /*
     * Recursively check base type of derived types
     */
    if (_tnf_get_element_named(tnf, properties, TNF_N_DERIVED)
        != TNF_NULL) {
        /* tag is a derived type: check its derived_base */
        tnf_ref32_t *base_tag;

        base_tag = _tnf_get_derived_base(tnf, tag);
        /* tnf_derived has derived_base == TNF_NULL */
        if (base_tag != TNF_NULL)
            return (_tnf_get_property(tnf, base_tag, name));
    }

    return (TNF_NULL);
}

/*
 * Get the ultimate base type of a type record
 */

tnf_ref32_t *
_tnf_get_base_tag(TNF *tnf, tnf_ref32_t *tag)
{
    tnf_ref32_t *properties;

    if ((properties = _tnf_get_properties(tnf, tag)) == TNF_NULL)
        /* no properties */
        return (tag);

    if (_tnf_get_element_named(tnf, properties, TNF_N_DERIVED)
        != TNF_NULL) {
        tnf_ref32_t *base_tag;

        if ((base_tag = _tnf_get_derived_base(tnf, tag)) != TNF_NULL)
            return (_tnf_get_base_tag(tnf, base_tag));
    }

    return (tag);
}

/*
 * Calculate the reference size of an object with type==tag
 */

size_t
_tnf_get_ref_size(TNF *tnf, tnf_ref32_t *tag)
{
    if (HAS_PROPERTY(tnf, tag, TNF_N_TAGGED)) {
        /* Tagged objects occupy 4 bytes for reference */
        return ((sizeof (tnf_ref32_t)));
    } else if (HAS_PROPERTY(tnf, tag, TNF_N_INLINE)) {
        /* Inline slots cannot be self sized */
        return (_tnf_get_storage_size(tnf, tag));
    } else {
        /* Illegal to have references to abstract objects */
        _tnf_error(tnf, TNF_ERR_BADTNF);
        return ((0));
    }
}

/*
 * Calculate storage size of an object with type==tag
 */

size_t
_tnf_get_storage_size(TNF *tnf, tnf_ref32_t *tag)
{
    if (_tnf_get_tag(tnf, tag) == _tnf_get_root_tag(tnf, tag))
        return (_GET_TYPE_SIZE(tnf, tag));
    else {
        tnf_ref32_t *base_tag; /* implementation tag */
        caddr_t     sizep;
        tnf_ref32_t *slot_types;

#ifndef INFINITE_RECURSION_SIZE
        char        *base_name;
        static struct n2s {
            char    *name;
            size_t  size;
        } n2s[] = {
        { TNF_N_CHAR,       sizeof (tnf_char_t) },
        { TNF_N_INT8,       sizeof (tnf_int8_t) },
        { TNF_N_INT16,      sizeof (tnf_int16_t) },
        { TNF_N_INT32,      sizeof (tnf_int32_t) },
        { TNF_N_UINT8,      sizeof (tnf_uint8_t) },
        { TNF_N_UINT16,     sizeof (tnf_uint16_t) },
        { TNF_N_UINT32,     sizeof (tnf_uint32_t) },
        { TNF_N_INT64,      sizeof (tnf_int64_t) },
        { TNF_N_UINT64,     sizeof (tnf_uint64_t) },
        { TNF_N_FLOAT32,    sizeof (tnf_float32_t) },
        { TNF_N_FLOAT64,    sizeof (tnf_float64_t) },
        { NULL,         0 }
        };
        struct n2s  *p;
#endif

        base_tag    = _tnf_get_base_tag(tnf, tag);

#ifndef INFINITE_RECURSION_SIZE
        base_name   = _tnf_get_name(tnf, base_tag);

        /* XXX Why are we in this mess? */
        p = n2s;
        while (p->name) {
            if (strcmp(p->name, base_name) == 0)
                return (p->size);
            p++;
        }
#endif

        sizep = _tnf_get_slot_typed(tnf, base_tag, TNF_N_TYPE_SIZE);
        if (sizep)
            /* Type sized */
        /* LINTED pointer cast may result in improper alignment */
            return (_GET_UINT32(tnf, (tnf_uint32_t *)sizep));

        slot_types = (tnf_ref32_t *)
        /* LINTED pointer cast may result in improper alignment */
            _tnf_get_slot_typed(tnf, base_tag, TNF_N_SLOT_TYPES);
        if (slot_types &&
            _tnf_get_element_named(tnf, slot_types, TNF_N_SELF_SIZE))
            /* Self sized */
            return ((size_t)-1);
        else
            /* Abstract */
            return (0);
    }
}

/*
 * Return the alignment restriction for any tag
 */

unsigned
_tnf_get_align(TNF *tnf, tnf_ref32_t *tag)
{
    if (HAS_PROPERTY(tnf, tag, TNF_N_SCALAR)) {
        tnf_ref32_t *base_tag;
        caddr_t     alignp;

        base_tag = _tnf_get_base_tag(tnf, tag);
        alignp   = _tnf_get_slot_typed(tnf, base_tag, TNF_N_ALIGN);
        if (alignp)
        /* LINTED pointer cast may result in improper alignment */
            return (_GET_UINT32(tnf, (tnf_uint32_t *)alignp));
    }
    /* default: word alignment */
    return ((4));
}

/*
 * Only works for records
 * Doesn't check for slot_names in tag
 * Tag records, for example, never have named slots
 */

caddr_t
_tnf_get_slot_typed(TNF *tnf, tnf_ref32_t *record, char *name)
{
    tnf_ref32_t     *tag, *base_tag;
    tnf_ref32_t *slot_types, *types;
    unsigned    count, i;
    unsigned    offset;

    tag         = _tnf_get_tag(tnf, record);
    base_tag    = _tnf_get_base_tag(tnf, tag);

    /*
     * The position of slot_types is ABI fixed
     * XXX Assume it is present in tag
     */
    slot_types = _tnf_get_slot_types(tnf, base_tag);
    count = _tnf_get_element_count(tnf, slot_types, sizeof (tnf_ref32_t));
    /* LINTED pointer cast may result in improper alignment */
    types = (tnf_ref32_t *)_tnf_get_elements(tnf, slot_types);

    offset  = 0;

    for (i = 0; i < count; i++) {
        tnf_ref32_t *type_elt;
        size_t      ref_size, align;

        /* Find the type record for slot */
        if ((type_elt = _GET_REF32(tnf, &types[i])) == TNF_NULL) {
            /* Can't have missing type records */
            _tnf_error(tnf, TNF_ERR_BADTNF);
            return ((caddr_t)NULL);
        }

        /* See similar hack in init_slots() */

        /* Calculate reference size */
        ref_size = _tnf_get_ref_size(tnf, type_elt);

        /*
         * Calculate alignment
         * XXX Prevent infinite recursion by assuming that
         * a reference size of 4 implies word alignment
         */
        align = (ref_size == 4)? 4: _tnf_get_align(tnf, type_elt);

        /* Adjust offset to account for alignment, if needed */
        offset = ALIGN(offset, align);

        /* Check whether name corresponds to type name */
        if (strcmp(name, _tnf_get_name(tnf, type_elt)) == 0)
            /* Found the slot */
            return (fetch_slot(tnf, (caddr_t)record + offset,
                    type_elt));

        /* Bump offset by reference size */
        offset += ref_size;
    }

    return ((caddr_t)NULL);
}

/*
 * Only works for records
 */

caddr_t
_tnf_get_slot_named(TNF *tnf, tnf_ref32_t *record, char *name)
{
    tnf_ref32_t     *tag, *base_tag;
    tnf_ref32_t *slot_types, *slot_names, *types, *names;
    unsigned    count, i;
    unsigned    offset;

    tag         = _tnf_get_tag(tnf, record);
    base_tag    = _tnf_get_base_tag(tnf, tag);

    /*
     * slot_names are optional
     */
    slot_names = (tnf_ref32_t *)
        /* LINTED pointer cast may result in improper alignment */
        _tnf_get_slot_typed(tnf, base_tag, TNF_N_SLOT_NAMES);

    /* no slot_names; use _tnf_get_slot_typed() */
    if (slot_names == TNF_NULL)
        return (_tnf_get_slot_typed(tnf, record, name));

    /*
     * The position of slot_types is ABI fixed
     * XXX Assume it is present in tag
     */
    slot_types = _tnf_get_slot_types(tnf, base_tag);
    count = _tnf_get_element_count(tnf, slot_types, sizeof (tnf_ref32_t));
    /* LINTED pointer cast may result in improper alignment */
    types = (tnf_ref32_t *)_tnf_get_elements(tnf, slot_types);
    /* LINTED pointer cast may result in improper alignment */
    names = (tnf_ref32_t *)_tnf_get_elements(tnf, slot_names);

    offset  = 0;

    for (i = 0; i < count; i++) {
        tnf_ref32_t *type_elt, *name_elt;
        size_t      ref_size, align;

        /* Find the type record for slot */
        if ((type_elt = _GET_REF32(tnf, &types[i])) == TNF_NULL) {
            /* Can't have missing type records */
            _tnf_error(tnf, TNF_ERR_BADTNF);
            return ((caddr_t)NULL);
        }

        /* XXX Keep consistent with init_slots() */

        /* Calculate reference size */
        ref_size = _tnf_get_ref_size(tnf, type_elt);

        /*
         * Calculate alignment
         * XXX Prevent infinite recursion by assuming that
         * a reference size of 4 implies word alignment
         */
        align = (ref_size == 4)? 4: _tnf_get_align(tnf, type_elt);

        /* Adjust offset to account for alignment, if needed */
        offset = ALIGN(offset, align);

        /* First check slot name, then type name */
        if ((((name_elt = _GET_REF32(tnf, &names[i])) != TNF_NULL) &&
            (strcmp(name, _tnf_get_chars(tnf, name_elt)) == 0)) ||
            (strcmp(name, _tnf_get_name(tnf, type_elt)) == 0))
            /* Found slot */
            return (fetch_slot(tnf, (caddr_t)record + offset,
                    type_elt));

        /* Bump offset by reference size */
        offset += ref_size;
    }

    return ((caddr_t)NULL);
}

static caddr_t
fetch_slot(TNF *tnf, caddr_t p, tnf_ref32_t *tag)
{
    if (HAS_PROPERTY(tnf, tag, TNF_N_INLINE))
        return (p);
    else            /* XXX assume tagged */
        /* LINTED pointer cast may result in improper alignment */
        return ((caddr_t)_GET_REF32(tnf, (tnf_ref32_t *)p));
}