blob: d3fe36a1dbc1f40807a27b5f05b56f9ad304ed10 [file] [log] [blame]
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
* GObject introspection: Compute structure offsets
*
* Copyright (C) 2008 Red Hat, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "girffi.h"
#include "girnode-private.h"
#include <string.h>
/* The C standard specifies that an enumeration can be any char or any signed
* or unsigned integer type capable of representing all the values of the
* enumeration. We use test enumerations to figure out what choices the
* compiler makes. (Ignoring > 32 bit enumerations)
*/
typedef enum {
ENUM_1 = 1 /* compiler could use int8, uint8, int16, uint16, int32, uint32 */
} Enum1;
typedef enum {
ENUM_2 = 128 /* compiler could use uint8, int16, uint16, int32, uint32 */
} Enum2;
typedef enum {
ENUM_3 = 257 /* compiler could use int16, uint16, int32, uint32 */
} Enum3;
typedef enum {
ENUM_4 = G_MAXSHORT + 1 /* compiler could use uint16, int32, uint32 */
} Enum4;
typedef enum {
ENUM_5 = G_MAXUSHORT + 1 /* compiler could use int32, uint32 */
} Enum5;
typedef enum {
ENUM_6 = ((unsigned int)G_MAXINT) + 1 /* compiler could use uint32 */
} Enum6;
typedef enum {
ENUM_7 = -1 /* compiler could use int8, int16, int32 */
} Enum7;
typedef enum {
ENUM_8 = -129 /* compiler could use int16, int32 */
} Enum8;
typedef enum {
ENUM_9 = G_MINSHORT - 1 /* compiler could use int32 */
} Enum9;
static void
compute_enum_storage_type (GIIrNodeEnum *enum_node)
{
GList *l;
int64_t max_value = 0;
int64_t min_value = 0;
int width;
gboolean signed_type;
if (enum_node->storage_type != GI_TYPE_TAG_VOID) /* already done */
return;
for (l = enum_node->values; l; l = l->next)
{
GIIrNodeValue *value = l->data;
if (value->value > max_value)
max_value = value->value;
if (value->value < min_value)
min_value = value->value;
}
if (min_value < 0)
{
signed_type = TRUE;
if (min_value > -128 && max_value <= 127)
width = sizeof(Enum7);
else if (min_value >= G_MINSHORT && max_value <= G_MAXSHORT)
width = sizeof(Enum8);
else
width = sizeof(Enum9);
}
else
{
if (max_value <= 127)
{
width = sizeof (Enum1);
signed_type = (int64_t)(Enum1)(-1) < 0;
}
else if (max_value <= 255)
{
width = sizeof (Enum2);
signed_type = (int64_t)(Enum2)(-1) < 0;
}
else if (max_value <= G_MAXSHORT)
{
width = sizeof (Enum3);
signed_type = (int64_t)(Enum3)(-1) < 0;
}
else if (max_value <= G_MAXUSHORT)
{
width = sizeof (Enum4);
signed_type = (int64_t)(Enum4)(-1) < 0;
}
else if (max_value <= G_MAXINT)
{
width = sizeof (Enum5);
signed_type = (int64_t)(Enum5)(-1) < 0;
}
else
{
width = sizeof (Enum6);
signed_type = (int64_t)(Enum6)(-1) < 0;
}
}
if (width == 1)
enum_node->storage_type = signed_type ? GI_TYPE_TAG_INT8 : GI_TYPE_TAG_UINT8;
else if (width == 2)
enum_node->storage_type = signed_type ? GI_TYPE_TAG_INT16 : GI_TYPE_TAG_UINT16;
else if (width == 4)
enum_node->storage_type = signed_type ? GI_TYPE_TAG_INT32 : GI_TYPE_TAG_UINT32;
else if (width == 8)
enum_node->storage_type = signed_type ? GI_TYPE_TAG_INT64 : GI_TYPE_TAG_UINT64;
else
g_error ("Unexpected enum width %d", width);
}
static gboolean
get_enum_size_alignment (GIIrNodeEnum *enum_node,
size_t *size,
size_t *alignment)
{
ffi_type *type_ffi;
compute_enum_storage_type (enum_node);
switch (enum_node->storage_type)
{
case GI_TYPE_TAG_INT8:
case GI_TYPE_TAG_UINT8:
type_ffi = &ffi_type_uint8;
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_UINT16:
type_ffi = &ffi_type_uint16;
break;
case GI_TYPE_TAG_INT32:
case GI_TYPE_TAG_UINT32:
type_ffi = &ffi_type_uint32;
break;
case GI_TYPE_TAG_INT64:
case GI_TYPE_TAG_UINT64:
type_ffi = &ffi_type_uint64;
break;
default:
g_error ("Unexpected enum storage type %s",
gi_type_tag_to_string (enum_node->storage_type));
}
*size = type_ffi->size;
*alignment = type_ffi->alignment;
return TRUE;
}
static gboolean
get_interface_size_alignment (GIIrTypelibBuild *build,
GIIrNodeType *type,
size_t *size,
size_t *alignment,
const char *who)
{
GIIrNode *iface;
iface = gi_ir_find_node (build, ((GIIrNode*)type)->module, type->giinterface);
if (!iface)
{
gi_ir_module_fatal (build, 0, "Can't resolve type '%s' for %s", type->giinterface, who);
*size = 0;
*alignment = 0;
return FALSE;
}
gi_ir_node_compute_offsets (build, iface);
switch (iface->type)
{
case GI_IR_NODE_BOXED:
{
GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)iface;
*size = boxed->size;
*alignment = boxed->alignment;
break;
}
case GI_IR_NODE_STRUCT:
{
GIIrNodeStruct *struct_ = (GIIrNodeStruct *)iface;
*size = struct_->size;
*alignment = struct_->alignment;
break;
}
case GI_IR_NODE_OBJECT:
case GI_IR_NODE_INTERFACE:
{
GIIrNodeInterface *interface = (GIIrNodeInterface *)iface;
*size = interface->size;
*alignment = interface->alignment;
break;
}
case GI_IR_NODE_UNION:
{
GIIrNodeUnion *union_ = (GIIrNodeUnion *)iface;
*size = union_->size;
*alignment = union_->alignment;
break;
}
case GI_IR_NODE_ENUM:
case GI_IR_NODE_FLAGS:
{
return get_enum_size_alignment ((GIIrNodeEnum *)iface,
size, alignment);
}
case GI_IR_NODE_CALLBACK:
{
*size = ffi_type_pointer.size;
*alignment = ffi_type_pointer.alignment;
break;
}
default:
{
g_warning ("%s has is not a pointer and is of type %s",
who,
gi_ir_node_type_to_string (iface->type));
*size = 0;
*alignment = 0;
return FALSE;
}
}
return *alignment > 0;
}
static gboolean
get_type_size_alignment (GIIrTypelibBuild *build,
GIIrNodeType *type,
size_t *size,
size_t *alignment,
const char *who)
{
ffi_type *type_ffi;
if (type->is_pointer)
{
type_ffi = &ffi_type_pointer;
}
else if (type->tag == GI_TYPE_TAG_ARRAY)
{
size_t elt_size;
size_t elt_alignment;
if (!type->has_size
|| !get_type_size_alignment(build, type->parameter_type1,
&elt_size, &elt_alignment, who))
{
*size = 0;
*alignment = 0;
return FALSE;
}
*size = type->size * elt_size;
*alignment = elt_alignment;
return TRUE;
}
else
{
if (type->tag == GI_TYPE_TAG_INTERFACE)
{
return get_interface_size_alignment (build, type, size, alignment, who);
}
else
{
type_ffi = gi_type_tag_get_ffi_type (type->tag, type->is_pointer);
if (type_ffi == &ffi_type_void)
{
g_warning ("%s has void type", who);
*size = 0;
*alignment = 0;
return FALSE;
}
else if (type_ffi == &ffi_type_pointer)
{
g_warning ("%s has is not a pointer and is of type %s",
who,
gi_type_tag_to_string (type->tag));
*size = 0;
*alignment = 0;
return FALSE;
}
}
}
g_assert (type_ffi);
*size = type_ffi->size;
*alignment = type_ffi->alignment;
return TRUE;
}
static gboolean
get_field_size_alignment (GIIrTypelibBuild *build,
GIIrNodeField *field,
GIIrNode *parent_node,
size_t *size,
size_t *alignment)
{
GIIrModule *module = build->module;
char *who;
gboolean success;
who = g_strdup_printf ("field %s.%s.%s", module->name, parent_node->name, ((GIIrNode *)field)->name);
if (field->callback)
{
*size = ffi_type_pointer.size;
*alignment = ffi_type_pointer.alignment;
success = TRUE;
}
else
success = get_type_size_alignment (build, field->type, size, alignment, who);
g_free (who);
return success;
}
#define GI_ALIGN(n, align) (((n) + (align) - 1) & ~((align) - 1))
static gboolean
compute_struct_field_offsets (GIIrTypelibBuild *build,
GIIrNode *node,
GList *members,
size_t *size_out,
size_t *alignment_out,
GIIrOffsetsState *offsets_state_out)
{
size_t size = 0;
size_t alignment = 1;
GList *l;
gboolean have_error = FALSE;
*offsets_state_out = GI_IR_OFFSETS_IN_PROGRESS; /* mark to detect recursion */
for (l = members; l; l = l->next)
{
GIIrNode *member = (GIIrNode *)l->data;
if (member->type == GI_IR_NODE_FIELD)
{
GIIrNodeField *field = (GIIrNodeField *)member;
if (!have_error)
{
size_t member_size;
size_t member_alignment;
if (get_field_size_alignment (build, field, node,
&member_size, &member_alignment))
{
size = GI_ALIGN (size, member_alignment);
alignment = MAX (alignment, member_alignment);
field->offset = size;
field->offset_state = GI_IR_OFFSETS_COMPUTED;
size += member_size;
}
else
have_error = TRUE;
}
if (have_error)
{
field->offset = 0;
field->offset_state = GI_IR_OFFSETS_FAILED;
}
}
else if (member->type == GI_IR_NODE_CALLBACK)
{
size = GI_ALIGN (size, ffi_type_pointer.alignment);
alignment = MAX (alignment, ffi_type_pointer.alignment);
size += ffi_type_pointer.size;
}
}
/* Structs are tail-padded out to a multiple of their alignment */
size = GI_ALIGN (size, alignment);
if (!have_error)
{
*size_out = size;
*alignment_out = alignment;
*offsets_state_out = GI_IR_OFFSETS_COMPUTED;
}
else
{
*size_out = 0;
*alignment_out = 0;
*offsets_state_out = GI_IR_OFFSETS_FAILED;
}
return !have_error;
}
static gboolean
compute_union_field_offsets (GIIrTypelibBuild *build,
GIIrNode *node,
GList *members,
size_t *size_out,
size_t *alignment_out,
GIIrOffsetsState *offsets_state_out)
{
size_t size = 0;
size_t alignment = 1;
GList *l;
gboolean have_error = FALSE;
*offsets_state_out = GI_IR_OFFSETS_IN_PROGRESS; /* mark to detect recursion */
for (l = members; l; l = l->next)
{
GIIrNode *member = (GIIrNode *)l->data;
if (member->type == GI_IR_NODE_FIELD)
{
GIIrNodeField *field = (GIIrNodeField *)member;
if (!have_error)
{
size_t member_size;
size_t member_alignment;
if (get_field_size_alignment (build,field, node,
&member_size, &member_alignment))
{
size = MAX (size, member_size);
alignment = MAX (alignment, member_alignment);
}
else
have_error = TRUE;
}
}
}
/* Unions are tail-padded out to a multiple of their alignment */
size = GI_ALIGN (size, alignment);
if (!have_error)
{
*size_out = size;
*alignment_out = alignment;
*offsets_state_out = GI_IR_OFFSETS_COMPUTED;
}
else
{
*size_out = 0;
*alignment_out = 0;
*offsets_state_out = GI_IR_OFFSETS_FAILED;
}
return !have_error;
}
static gboolean
check_needs_computation (GIIrTypelibBuild *build,
GIIrNode *node,
GIIrOffsetsState offsets_state)
{
GIIrModule *module = build->module;
if (offsets_state == GI_IR_OFFSETS_IN_PROGRESS)
{
g_warning ("Recursion encountered when computing the size of %s.%s",
module->name, node->name);
}
return offsets_state == GI_IR_OFFSETS_UNKNOWN;
}
/*
* gi_ir_node_compute_offsets:
* @build: Current typelib build
* @node: a #GIIrNode
*
* If a node is a a structure or union, makes sure that the field
* offsets have been computed, and also computes the overall size and
* alignment for the type.
*
* Since: 2.80
*/
void
gi_ir_node_compute_offsets (GIIrTypelibBuild *build,
GIIrNode *node)
{
gboolean appended_stack;
if (build->stack)
appended_stack = node != (GIIrNode*)build->stack->data;
else
appended_stack = TRUE;
if (appended_stack)
build->stack = g_list_prepend (build->stack, node);
switch (node->type)
{
case GI_IR_NODE_BOXED:
{
GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
if (!check_needs_computation (build, node, boxed->offsets_state))
return;
compute_struct_field_offsets (build, node, boxed->members,
&boxed->size, &boxed->alignment, &boxed->offsets_state);
break;
}
case GI_IR_NODE_STRUCT:
{
GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
if (!check_needs_computation (build, node, struct_->offsets_state))
return;
compute_struct_field_offsets (build, node, struct_->members,
&struct_->size, &struct_->alignment, &struct_->offsets_state);
break;
}
case GI_IR_NODE_OBJECT:
case GI_IR_NODE_INTERFACE:
{
GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
if (!check_needs_computation (build, node, iface->offsets_state))
return;
compute_struct_field_offsets (build, node, iface->members,
&iface->size, &iface->alignment, &iface->offsets_state);
break;
}
case GI_IR_NODE_UNION:
{
GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
if (!check_needs_computation (build, node, union_->offsets_state))
return;
compute_union_field_offsets (build, (GIIrNode*)union_, union_->members,
&union_->size, &union_->alignment, &union_->offsets_state);
break;
}
case GI_IR_NODE_ENUM:
case GI_IR_NODE_FLAGS:
{
GIIrNodeEnum *enum_ = (GIIrNodeEnum *)node;
if (enum_->storage_type != GI_TYPE_TAG_VOID) /* already done */
return;
compute_enum_storage_type (enum_);
break;
}
default:
break;
}
if (appended_stack)
build->stack = g_list_delete_link (build->stack, build->stack);
}