/* Test program for dwarf_die_addr_die.

   Copyright (C) 2018 Red Hat, Inc.

   This file is part of elfutils.

   This file is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   elfutils 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 General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <config.h>

#include ELFUTILS_HEADER(dw)

#include <dwarf.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <assert.h>

#include <inttypes.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

/* The main Dwarf file.  */

static Dwarf *dwarf;

int

check_die (Dwarf_Die *die)

{

  if (dwarf_tag (die) == DW_TAG_invalid)

    {

      printf ("Invalid die\n");

      return -1;

    }

  int res = 0;

  void *addr = die->addr;

  Dwarf_Die die2;

  if (dwarf_die_addr_die (dwarf, addr, &die2) == NULL)

    {

      printf ("Bad die addr die at offset %" PRIx64 "\n",

	      dwarf_dieoffset (die));

      res = -1;

    }

  if (dwarf_tag (die) != dwarf_tag (&die2))

    {

      printf ("Tags differ for die at offset %" PRIx64 "\n",

	      dwarf_dieoffset (die));

      res = -1;

    }

  if (dwarf_cuoffset (die) != dwarf_cuoffset (&die2))

    {

      printf ("CU offsets differ for die at offset %" PRIx64 "\n",

	      dwarf_dieoffset (die));

      res = -1;

    }

  Dwarf_Die child;

  if (dwarf_child (die, &child) == 0)

    res |= check_die (&child);

  Dwarf_Die sibling;

  if (dwarf_siblingof (die, &sibling) == 0)

    res |= check_die (&sibling);

  return res;

}

int

check_dbg (Dwarf *dbg)

{

  int res = 0;

  Dwarf_Off off = 0;

  Dwarf_Off old_off = 0;

  size_t hsize;

  Dwarf_Off abbrev;

  uint8_t addresssize;

  uint8_t offsetsize;

  while (dwarf_nextcu (dbg, off, &off, &hsize, &abbrev, &addresssize,

                       &offsetsize) == 0)

    {

      Dwarf_Die die;

      if (dwarf_offdie (dbg, old_off + hsize, &die) != NULL)

	{

	  printf ("checking CU at %" PRIx64 "\n", old_off);

	  res |= check_die (&die);

	}

      old_off = off;

    }

  // Same for type...

  Dwarf_Half version;

  uint64_t typesig;

  Dwarf_Off typeoff;

  off = 0;

  old_off = 0;

  while (dwarf_next_unit (dbg, off, &off, &hsize, &version, &abbrev,

			  &addresssize, &offsetsize, &typesig, &typeoff) == 0)

    {

      Dwarf_Die die;

      if (dwarf_offdie_types (dbg, old_off + hsize, &die) != NULL)

	{

	  printf ("checking TU at %" PRIx64 "\n", old_off);

	  res |= check_die (&die);

	}

      // We should have seen this already, but double check...

      if (dwarf_offdie_types (dbg, old_off + typeoff, &die) != NULL)

	{

	  printf ("checking Type DIE at %" PRIx64 "\n",

		  old_off + hsize + typeoff);

	  res |= check_die (&die);

	}

      old_off = off;

    }

  Dwarf *alt = dwarf_getalt (dbg);

  if (alt != NULL)

    {

      printf ("checking alt debug\n");

      res |= check_dbg (alt);

    }

  // Split or Type Dwarf_Dies gotten through dwarf_get_units.

  Dwarf_CU *cu = NULL;

  Dwarf_Die subdie;

  uint8_t unit_type;

  while (dwarf_get_units (dbg, cu, &cu, NULL,

                          &unit_type, NULL, &subdie) == 0)

    {

      if (dwarf_tag (&subdie) != DW_TAG_invalid)

        {

	  printf ("checking %" PRIx8 " subdie\n", unit_type);

	  res |= check_die (&subdie);

	}

    }

  return res;

}

int

main (int argc, char *argv[])

{

  if (argc < 2)

    {

      printf ("No file given.\n");

      return -1;

    }

  const char *name = argv[1];

  int fd = open (name, O_RDONLY);

  if (fd < 0)

    {

      printf ("Cannnot open '%s': %s\n", name, strerror (errno));

      return -1;

    }

  dwarf = dwarf_begin (fd, DWARF_C_READ);

  if (dwarf == NULL)

    {

      printf ("Not a Dwarf file '%s': %s\n", name, dwarf_errmsg (-1));

      close (fd);

      return -1;

    }

  printf ("checking %s\n", name);

  int res = check_dbg (dwarf);

  dwarf_end (dwarf);

  close (fd);

  return res;

}