OpenSolaris_b135/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));
}