/* Test program for DWARF (.debug_frame) CFI handling.

   Copyright (C) 2009-2010, 2013, 2015, 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 <assert.h>

#include <inttypes.h>

#include ELFUTILS_HEADER(dw)

#include <dwarf.h>

#include <argp.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <locale.h>

#include <stdlib.h>

#include <string.h>

#include "system.h"

#include "../libdw/known-dwarf.h"

static const char *

op_name (unsigned int code)

{

  static const char *const known[] =

    {

#define DWARF_ONE_KNOWN_DW_OP(NAME, CODE) [CODE] = #NAME,

      DWARF_ALL_KNOWN_DW_OP

#undef DWARF_ONE_KNOWN_DW_OP

    };

  if (likely (code < sizeof (known) / sizeof (known[0])))

    return known[code];

  return NULL;

}

static void

print_detail (int result, const Dwarf_Op *ops, size_t nops)

{

  if (result < 0)

    printf ("indeterminate (%s)\n", dwarf_errmsg (-1));

  else if (nops == 0)

    printf ("%s\n", ops == NULL ? "same_value" : "undefined");

  else

    {

      printf ("%s expression:", result == 0 ? "location" : "value");

      for (size_t i = 0; i < nops; ++i)

	{

	  printf (" %s", op_name(ops[i].atom));

	  if (ops[i].number2 == 0)

	    {

	      if (ops[i].atom == DW_OP_addr)

		printf ("(%#" PRIx64 ")", ops[i].number);

	      else if (ops[i].number != 0)

		printf ("(%" PRId64 ")", ops[i].number);

	    }

	  else

	    printf ("(%" PRId64 ",%" PRId64 ")",

		    ops[i].number, ops[i].number2);

	}

      puts ("");

    }

}

static int

handle_address (Dwarf_CFI *cfi, GElf_Addr pc)

{

  Dwarf_Frame *frame;

  int result = dwarf_cfi_addrframe (cfi, pc, &frame);

  if (result != 0)

    {

      printf ("dwarf_cfi_addrframe: %s\n", dwarf_errmsg (-1));

      return 1;

    }

  Dwarf_Addr start = pc;

  Dwarf_Addr end = pc;

  bool signalp;

  int ra_regno = dwarf_frame_info (frame, &start, &end, &signalp);

  printf ("%#" PRIx64 " => [%#" PRIx64 ", %#" PRIx64 "):\n",

	  pc, start, end);

  if (ra_regno < 0)

    printf ("\treturn address register unavailable (%s)\n",

	    dwarf_errmsg (-1));

  else

    printf ("\treturn address in reg%u%s\n",

	    ra_regno, signalp ? " (signal frame)" : "");

  // Point cfa_ops to dummy to match print_detail expectations.

  // (nops == 0 && cfa_ops != NULL => "undefined")

  Dwarf_Op dummy;

  Dwarf_Op *cfa_ops = &dummy;

  size_t cfa_nops;

  result = dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops);

  printf ("\tCFA ");

  print_detail (result, cfa_ops, cfa_nops);

  // Print the location of the first 10 (DWARF nr) registers

  for (int r = 0; r < 10; r++)

    {

      Dwarf_Op ops_mem[3];

      Dwarf_Op *ops;

      size_t nops;

      printf ("\treg%d: ", r);

      int reg_result = dwarf_frame_register (frame, r, ops_mem, &ops, &nops;;

      print_detail (reg_result, ops, nops);

      result |= reg_result;

    }

  free (frame);

  return result;

}

int

main (int argc, char *argv[])

{

  if (argc <= 2)

    error (EXIT_FAILURE, 0, "need file name argument and addresses");

  int fd = open (argv[1], O_RDONLY);

  if (fd == -1)

    error (EXIT_FAILURE, errno, "cannot open input file `%s'", argv[1]);

  elf_version (EV_CURRENT);

  Elf *elf = elf_begin (fd, ELF_C_READ, NULL);

  if (elf == NULL)

    error (EXIT_FAILURE, 0, "cannot create ELF descriptor: %s",

	   elf_errmsg (-1));

  Dwarf *dwarf = dwarf_begin_elf (elf, DWARF_C_READ, NULL);

  if (dwarf == NULL)

    error (EXIT_FAILURE, 0, "cannot create DWARF descriptor: %s",

	   dwarf_errmsg (-1));

  Dwarf_CFI *cfi = dwarf_getcfi (dwarf);

  if (cfi == NULL)

    error (EXIT_FAILURE, 0, "cannot get DWARF CFI from .dwarf_frame: %s",

	   dwarf_errmsg (-1));

  int result = 0;

  int args = 2;

  do

    {

      char *endp;

      uintmax_t addr = strtoumax (argv[args], &endp, 0);

      if (endp != argv[args])

	result |= handle_address (cfi, addr);

      else

	result = 1;

    }

  while (args++ < argc - 1);

  dwarf_end (dwarf);

  elf_end (elf);

  return result;

}