/* -*- 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 = ((guint)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;
  gint64 max_value = 0;
  gint64 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 = (gint64)(Enum1)(-1) < 0;
	}
      else if (max_value <= 255)
	{
	  width = sizeof (Enum2);
	  signed_type = (gint64)(Enum2)(-1) < 0;
	}
      else if (max_value <= G_MAXSHORT)
	{
	  width = sizeof (Enum3);
	  signed_type = (gint64)(Enum3)(-1) < 0;
	}
      else if (max_value <= G_MAXUSHORT)
	{
	  width = sizeof (Enum4);
	  signed_type = (gint64)(Enum4)(-1) < 0;
	}
      else if (max_value <= G_MAXINT)
	{
	  width = sizeof (Enum5);
	  signed_type = (gint64)(Enum5)(-1) < 0;
	}
      else
	{
	  width = sizeof (Enum6);
	  signed_type = (gint64)(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,
                         gint         *size,
                         gint         *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,
                              gint             *size,
                              gint             *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 = -1;
      *alignment = -1;
      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 = -1;
	*alignment = -1;
	break;
      }
    }

  return *alignment > 0;
}

static gboolean
get_type_size_alignment (GIIrTypelibBuild *build,
                         GIIrNodeType     *type,
                         gint             *size,
                         gint             *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)
    {
      gint elt_size, elt_alignment;

      if (!type->has_size
          || !get_type_size_alignment(build, type->parameter_type1,
                                      &elt_size, &elt_alignment, who))
        {
          *size = -1;
          *alignment = -1;
          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 = -1;
	      *alignment = -1;
	      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 = -1;
	      *alignment = -1;
	      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,
                          gint             *size,
                          gint             *alignment)
{
  GIIrModule *module = build->module;
  gchar *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,
                              gint             *size_out,
                              gint             *alignment_out)
{
  int size = 0;
  int alignment = 1;
  GList *l;
  gboolean have_error = FALSE;

  *alignment_out = -2; /* 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)
	    {
	      int member_size;
	      int 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;
		  size += member_size;
		}
	      else
		have_error = TRUE;
	    }

	  if (have_error)
	    field->offset = -1;
	}
      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;
    }
  else
    {
      *size_out = -1;
      *alignment_out = -1;
    }

  return !have_error;
}

static gboolean
compute_union_field_offsets (GIIrTypelibBuild *build,
                             GIIrNode         *node,
                             GList            *members,
                             gint             *size_out,
                             gint             *alignment_out)
{
  int size = 0;
  int alignment = 1;
  GList *l;
  gboolean have_error = FALSE;

  *alignment_out = -2; /* 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)
	    {
	      int member_size;
	      int 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;
    }
  else
    {
      *size_out = -1;
      *alignment_out = -1;
    }

  return !have_error;
}

static gboolean
check_needs_computation (GIIrTypelibBuild *build,
                         GIIrNode         *node,
                         gint              alignment)
{
  GIIrModule *module = build->module;
  /*
   *  0: Not yet computed
   * >0: Previously succeeded
   * -1: Previously failed
   * -2: In progress
   */
  if (alignment == -2)
    {
      g_warning ("Recursion encountered when computing the size of %s.%s",
		 module->name, node->name);
    }

  return alignment == 0;
}

/*
 * 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->alignment))
	  return;

	compute_struct_field_offsets (build, node, boxed->members,
				      &boxed->size, &boxed->alignment);
	break;
      }
    case GI_IR_NODE_STRUCT:
      {
	GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;

	if (!check_needs_computation (build, node, struct_->alignment))
	  return;

	compute_struct_field_offsets (build, node, struct_->members,
				      &struct_->size, &struct_->alignment);
	break;
      }
    case GI_IR_NODE_OBJECT:
    case GI_IR_NODE_INTERFACE:
      {
	GIIrNodeInterface *iface = (GIIrNodeInterface *)node;

	if (!check_needs_computation (build, node, iface->alignment))
	  return;

	compute_struct_field_offsets (build, node, iface->members,
				      &iface->size, &iface->alignment);
	break;
      }
    case GI_IR_NODE_UNION:
      {
	GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;

	if (!check_needs_computation (build, node, union_->alignment))
	  return;

	compute_union_field_offsets (build, (GIIrNode*)union_, union_->members,
				     &union_->size, &union_->alignment);
	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);
}