loc2c-test.c

/* Simple test program for loc2c code.

   This takes the standard libdwfl switches to select what address space
   you are talking about, same as for e.g. eu-addr2line (see --help).  */

#include <config.h>
#include <assert.h>
#include <inttypes.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#if ENABLE_NLS
#include <locale.h>
#endif
#include <argp.h>
#include <elfutils/libdwfl.h>
#include <elfutils/version.h>
#include <dwarf.h>
#include <obstack.h>
#include <unistd.h>
#include <stdarg.h>
#include "loc2c.h"

#define _(msg) msg

/* Using this structure in the callback (to handle_function) allows us
   to print out the function's address */
struct dwfunc
{
  Dwfl *dwfl;
  Dwarf_Die *cu;
  Dwarf_Addr dwbias;
  char * funcname;
  uintmax_t pc;
  bool matchdebug;
};

static void __attribute__ ((noreturn, format (printf, 2, 3)))
fail (void *arg __attribute__ ((unused)), const char *fmt, ...)
{
  va_list ap;

  fprintf (stderr, "%s: ", program_invocation_short_name);

  va_start (ap, fmt);
  vfprintf (stderr, _(fmt), ap);
  va_end (ap);

  fprintf (stderr, "\n");

  exit (2);
}

static const Dwarf_Op *
get_location (Dwarf_Addr dwbias, Dwarf_Addr pc, Dwarf_Attribute *loc_attr,
	      size_t *len)
{
  Dwarf_Op *expr;

  switch (dwarf_getlocation_addr (loc_attr, pc - dwbias, &expr, len, 1))
    {
    case 1:			/* Should always happen.  */
      if (*len == 0)
	goto inaccessible;
      break;

    default:			/* Shouldn't happen.  */
    case -1:
      fail (NULL, _("dwarf_getlocation_addr (form %#x): %s"),
	    dwarf_whatform (loc_attr), dwarf_errmsg (-1));
      return NULL;

    case 0:			/* Shouldn't happen.  */
    inaccessible:
      fail (NULL, _("not accessible at this address"));
      return NULL;
    }

  return expr;
}

#define obstack_chunk_alloc malloc
#define obstack_chunk_free free

static void
handle_fields (struct obstack *pool,
	       struct location *head, struct location *tail,
	       Dwarf_Addr cubias, Dwarf_Die *vardie, Dwarf_Addr pc,
	       char **fields,
	       Dwarf *dwarf)
{
  Dwarf_Attribute attr_mem;

  if (dwarf_attr_integrate (vardie, DW_AT_type, &attr_mem) == NULL)
    error (2, 0, _("cannot get type of variable: %s"),
	   dwarf_errmsg (-1));

  bool store = false;
  Dwarf_Die die_mem, *die = vardie;
  while (*fields != NULL)
    {
      if (!strcmp (*fields, "="))
	{
	  store = true;
	  if (fields[1] != NULL)
	    error (2, 0, _("extra fields after ="));
	  break;
	}

      die = dwarf_formref_die (&attr_mem, &die_mem);

      const int typetag = dwarf_tag (die);
      switch (typetag)
	{
	case DW_TAG_typedef:
	case DW_TAG_const_type:
	case DW_TAG_volatile_type:
	case DW_TAG_restrict_type:
	  /* Just iterate on the referent type.  */
	  break;

	case DW_TAG_pointer_type:
	  if (**fields == '+')
	    goto subscript;
	  /* A "" field means explicit pointer dereference and we consume it.
	     Otherwise the next field implicitly gets the dereference.  */
	  if (**fields == '\0')
	    ++fields;
	  c_translate_pointer (pool, 1, cubias, die, &tail);
	  break;

	case DW_TAG_array_type:
	  if (**fields == '+')
	    {
	    subscript:;
	      char *endp = *fields + 1;
	      uintmax_t idx = strtoumax (*fields + 1, &endp, 0);
	      if (endp == NULL || endp == *fields || *endp != '\0')
		c_translate_array (pool, 1, cubias, die, &tail,
				   *fields + 1, 0);
	      else
		c_translate_array (pool, 1, cubias, die, &tail,
				   NULL, idx);
	      ++fields;
	    }
	  else
	    error (2, 0, _("bad field for array type: %s"), *fields);
	  break;

	case DW_TAG_structure_type:
	case DW_TAG_union_type:
	  switch (dwarf_child (die, &die_mem))
	    {
	    case 1:		/* No children.  */
	      error (2, 0, _("empty struct %s"),
		     dwarf_diename (die) ?: "<anonymous>");
	      break;
	    case -1:		/* Error.  */
	    default:		/* Shouldn't happen */
	      error (2, 0, _("%s %s: %s"),
		     typetag == DW_TAG_union_type ? "union" : "struct",
		     dwarf_diename (die) ?: "<anonymous>",
		     dwarf_errmsg (-1));
	      break;

	    case 0:
	      break;
	    }
	  while (dwarf_tag (die) != DW_TAG_member
		 || ({ const char *member = dwarf_diename (die);
		       member == NULL || strcmp (member, *fields); }))
	    if (dwarf_siblingof (die, &die_mem) != 0)
	      error (2, 0, _("field name %s not found"), *fields);

	  if (dwarf_attr_integrate (die, DW_AT_data_member_location,
				    &attr_mem) == NULL)
	    {
	      /* Union members don't usually have a location,
		 but just use the containing union's location.  */
	      if (typetag != DW_TAG_union_type)
		error (2, 0, _("no location for field %s: %s"),
		       *fields, dwarf_errmsg (-1));
	    }
	  else
	    {
	      /* We expect a block or a constant.  */
	      size_t locexpr_len = 0;
	      const Dwarf_Op *locexpr;
	      locexpr = get_location (cubias, pc, &attr_mem, &locexpr_len);
	      c_translate_location (pool, NULL, NULL, NULL,
				    1, cubias, pc, &attr_mem,
				    locexpr, locexpr_len,
				    &tail, NULL, NULL, dwarf);
	    }
	  ++fields;
	  break;

	case DW_TAG_base_type:
	  error (2, 0, _("field %s vs base type %s"),
		 *fields, dwarf_diename (die) ?: "<anonymous type>");
	  break;

	case -1:
	  error (2, 0, _("cannot find type: %s"), dwarf_errmsg (-1));
	  break;

	default:
	  error (2, 0, _("%s: unexpected type tag %#x"),
		 dwarf_diename (die) ?: "<anonymous type>",
		 (unsigned)dwarf_tag (die));
	  break;
	}

      /* Now iterate on the type in DIE's attribute.  */
      if (dwarf_attr_integrate (die, DW_AT_type, &attr_mem) == NULL)
	error (2, 0, _("cannot get type of field: %s"), dwarf_errmsg (-1));
    }

  /* Fetch the type DIE corresponding to the final location to be accessed.
     It must be a base type or a typedef for one.  */

  Dwarf_Die typedie_mem;
  Dwarf_Die *typedie;
  int typetag;
  while (1)
    {
      typedie = dwarf_formref_die (&attr_mem, &typedie_mem);
      if (typedie == NULL)
	error (2, 0, _("cannot get type of field: %s"), dwarf_errmsg (-1));
      typetag = dwarf_tag (typedie);
      if (typetag != DW_TAG_typedef &&
	  typetag != DW_TAG_const_type &&
	  typetag != DW_TAG_volatile_type &&
	  typetag != DW_TAG_restrict_type)
	break;
      if (dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem) == NULL)
	error (2, 0, _("cannot get type of field: %s"), dwarf_errmsg (-1));
    }

  switch (typetag)
    {
    case DW_TAG_base_type:
      if (store)
	c_translate_store (pool, 1, cubias, die, typedie, &tail, "value");
      else
	c_translate_fetch (pool, 1, cubias, die, typedie, &tail, "value");
      break;

    case DW_TAG_pointer_type:
    case DW_TAG_reference_type:
      if (store)
	error (2, 0, _("store not supported for pointer type"));
      c_translate_pointer (pool, 1, cubias, typedie, &tail);
      c_translate_addressof (pool, 1, cubias, die, typedie, &tail, "value");
      break;

    default:
      if (store)
	error (2, 0, _("store supported only for base type"));
      else
	error (2, 0, _("fetch supported only for base type or pointer"));
      break;
    }

  printf ("#define PROBEADDR %#" PRIx64 "ULL\n", pc);

  puts (store
	? "static void set_value(struct pt_regs *regs, intptr_t value)\n{"
	: "static void print_value(struct pt_regs *regs)\n"
	"{\n"
	"  intptr_t value;");

  unsigned int stack_depth;
  bool deref = c_emit_location (stdout, head, 1, &stack_depth);

  obstack_free (pool, NULL);

  printf ("  /* max expression stack depth %u */\n", stack_depth);

  puts (store ? "  return;" :
	"  printk (\" ---> %ld\\n\", (unsigned long) value);\n"
	"  return;");

  if (deref)
    puts ("\n"
	  " deref_fault:\n"
	  "  printk (\" => BAD ACCESS\\n\");");

  puts ("}");
}

static void
handle_variable (Dwarf_Die *lscopes, int lnscopes, int out,
		 Dwarf_Addr cubias, Dwarf_Die *vardie, Dwarf_Addr pc,
		 Dwarf_Op *cfa_ops, char **fields,
		 Dwarf *dwarf)
{
  struct obstack pool;
  obstack_init (&pool);

  /* Figure out the appropriate frame base for accessing this variable.
   * XXX not handling nested functions
   */
  Dwarf_Attribute fb_attr_mem, *fb_attr = NULL;
  int inner;
  /* We start out walking the "lexical scopes" as returned by
   * as returned by dwarf_getscopes for the address, starting with the
   * 'out' scope that the variable was found in.
   */
  Dwarf_Die *scopes = lscopes;
  int nscopes = lnscopes;
  for (inner = out; inner < nscopes && fb_attr == NULL; ++inner)
    {
      switch (dwarf_tag (&scopes[inner]))
	{
	default:
	  continue;
	case DW_TAG_subprogram:
	case DW_TAG_entry_point:
	  fb_attr = dwarf_attr_integrate (&scopes[inner],
					  DW_AT_frame_base,
					  &fb_attr_mem);
	  break;
	case DW_TAG_inlined_subroutine:
	  /* Unless we already are going through the "pyshical die tree",
	   * we now need to start walking the die tree where this
	   * subroutine is inlined to find the appropriate frame base. */
          if (out != -1)
	    {
	      nscopes = dwarf_getscopes_die (&scopes[inner], &scopes);
	      if (nscopes == -1)
		error (2, 0, _("cannot get die scopes inlined_subroutine: %s"),
		       dwarf_errmsg (-1));
	      inner = 0; // zero is current scope, for look will increase.
	      out = -1;
	    }
	  break;
	}
    }

  struct location *head, *tail = NULL;

  Dwarf_Attribute attr_mem;
  if (dwarf_attr_integrate (vardie, DW_AT_const_value, &attr_mem) != NULL)
    /* There is no location expression, but a constant value instead.  */
    head = tail = c_translate_constant (&pool, &fail, NULL, NULL,
					1, cubias, &attr_mem, dwarf);
  else
    {
      if (dwarf_attr_integrate (vardie, DW_AT_location, &attr_mem) == NULL)
	error (2, 0, _("cannot get location of variable: %s"),
	       dwarf_errmsg (-1));

      size_t locexpr_len = 0;
      const Dwarf_Op *locexpr = get_location (cubias, pc,
					      &attr_mem, &locexpr_len);

      head = c_translate_location (&pool, &fail, NULL, NULL,
				   1, cubias, pc, &attr_mem,
				   locexpr, locexpr_len,
				   &tail, fb_attr, cfa_ops, dwarf);
    }

  handle_fields (&pool, head, tail, cubias, vardie, pc, fields, dwarf);
}

static void
paddr (const char *prefix, Dwarf_Addr addr, Dwfl_Line *line)
{
  const char *src;
  int lineno, linecol;
  if (line != NULL
      && (src = dwfl_lineinfo (line, &addr, &lineno, &linecol,
			       NULL, NULL)) != NULL)
    {
      if (linecol != 0)
	printf ("%s%#" PRIx64 " (%s:%d:%d)",
		prefix, addr, src, lineno, linecol);
      else
	printf ("%s%#" PRIx64 " (%s:%d)",
		prefix, addr, src, lineno);
    }
  else
    printf ("%s%#" PRIx64, prefix, addr);
}

static void
print_type (Dwarf_Die *typedie, char space)
{
  if (typedie == NULL)
    printf ("%c<no type>", space);
  else
    {
      const char *name = dwarf_diename (typedie);
      if (name != NULL)
	printf ("%c%s", space, name);
      else
	{
	  Dwarf_Attribute attr_mem;
	  Dwarf_Die die_mem;
	  Dwarf_Die *die = dwarf_formref_die
	    (dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem), &die_mem);
	  int tag = dwarf_tag (typedie);
	  switch (tag)
	  {
	  case DW_TAG_pointer_type:
	    print_type (die, space);
	    putchar ('*');
	    break;
	  case DW_TAG_array_type:
	    print_type (die, space);
	    printf ("[]");
	    break;
	  case DW_TAG_const_type:
	    print_type (die, space);
	    printf (" const");
	    break;
	  case DW_TAG_volatile_type:
	    print_type (die, space);
	    printf (" volatile");
	    break;
	  case DW_TAG_restrict_type:
	    print_type (die, space);
	    printf (" restrict");
	    break;
	  default:
	    printf ("%c<unknown %#x>", space, (unsigned)tag);
	    break;
	  }
	}
    }
}

static void
print_vars (int indent, Dwarf_Die *die)
{
  Dwarf_Die child;
  Dwarf_Attribute attr_mem;
  Dwarf_Die typedie_mem;
  Dwarf_Die *typedie;
  if (dwarf_child (die, &child) == 0)
    do
      switch (dwarf_tag (&child))
	{
	case DW_TAG_variable:
	case DW_TAG_formal_parameter:
	  printf ("%*s%-30s[%6" PRIx64 "]", indent, "",
		  dwarf_diename (&child),
		  (uint64_t) dwarf_dieoffset (&child));
	  typedie = dwarf_formref_die
	    (dwarf_attr_integrate (&child, DW_AT_type, &attr_mem),
	     &typedie_mem);
	  print_type (typedie, '\t');
	  puts ("");
	  break;
	default:
	  break;
	}
    while (dwarf_siblingof (&child, &child) == 0);
}

static int
handle_function (Dwarf_Die *funcdie, void *arg)
{
  struct dwfunc *a = arg;
  Dwarf_Addr entrypc;
  int result;
  int i = 0;
  Dwarf_Addr *bkpts = NULL;
  if (arg == NULL)
    error (2, 0, "Error, dwfl structure empty");
  const char *name = dwarf_diename (funcdie);
  if (name == NULL)
    error (2, 0, "Error, dwarf_diename returned NULL from Dwarf_die");
  if (dwarf_entrypc (funcdie, &entrypc) == 0)
    {
      entrypc += a->dwbias;
      result = dwarf_entry_breakpoints (funcdie, &bkpts);
      if (a->funcname == NULL)
	{
	  printf ("%-35s  %#.16" PRIx64, name, entrypc);
	  /* error check the result is greater than 0 */
	  if (result > 0)
	    {
	      /* the formatting changes as a looka-head if we
		 need different ending whitespace chars the
		 location is a combination of the address +
		 the offset (bias) */
	      for (i = 0; i < result; i++)
		printf (" %#.16" PRIx64 "%s", bkpts[i] + a->dwbias,
			i == result - 1 ? "\n" : "");
	      free (bkpts);
	    }
	}
      else if (a->funcname != NULL && (!strcmp (a->funcname, name)))
	{
	  if (!a->matchdebug)
	    {
	      entrypc += a->dwbias;
	      a->pc = entrypc;
	      free (bkpts);
	      return DWARF_CB_ABORT;
	    }
	  else if (result == 1 && a->matchdebug)
	    {
	      a->pc = (bkpts[0] + a->dwbias);
	      free (bkpts);
	      return DWARF_CB_ABORT;
	    }
	  else if (result > 1 && a->matchdebug)
	    {
	      printf ("Function: %-35s has multiple breakpoints: ", name);
	      for (i = 0; i < result; i++)
		printf (" %#.16" PRIx64 "%s", bkpts[i] + a->dwbias,
			i == result - 1 ? "\n" : "");
	      free (bkpts);
	      return DWARF_CB_ABORT;
	    }
	  else
	    {
	      error (2, 0, "Error, dwarf_entry_breakpoints returned an error( %s )\n",
		     dwarf_errmsg (result));
	    }
	}
    }
  return 0;
}

#define INDENT 4

int
main (int argc, char **argv)
{
  /* We use no threads here which can interfere with handling a stream.  */
  (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);

#if ENABLE_NLS
  /* Set locale.  */
  (void) setlocale (LC_ALL, "");
#endif

  const struct argp_child argp_children[] =
    {
      { .argp = dwfl_standard_argp () },
      { .argp = NULL }
    };
  const struct argp argp =
    {
      .children = argp_children,
      .args_doc = "ADDRESS\n\
FUNCTIONNAME\n\
ADDRESS VARIABLE [FIELD...]\n\
FUNCTIONNAME VARIABLE [FIELD...]\n\
ADDRESS VARIABLE [FIELD...] =",
      .doc = "Process DWARF locations visible with PC at ADDRESS.\v\
ADDRESS must be in %i format (i.e. \"0x...\").\n\
FUNCTIONNAME must be exact or prepended with '@' character to specify \
 breakpoint entry.\n\
In the first and second form, display the scope entries containing \
 ADDRESS or FUNCTIONNAME, and the variables/parameters visible there, \
 with their type names. Hex numbers within \"[...]\" are DIE offsets.\n\
In the third and fourth form, emit a C code fragment to access a \
 variable. Each FIELD argument is the name of a member of an aggregate \
 type (or pointer to one);\
 \"+INDEX\" to index into an array type (or offset a pointer type);\
 or \"\" (an empty argument) to dereference a pointer type.\n\
In the fifth form, the access is a store rather than a fetch."

    };
  Dwfl *dwfl = NULL;
  int argi;
  (void) argp_parse (&argp, argc, argv, 0, &argi, &dwfl);
  assert (dwfl != NULL);
  struct dwfunc a = { .dwfl = dwfl, .funcname = NULL,
		      .pc = 0, .matchdebug = 0 };
  if (argi == argc)
    {
      printf ("%-35s  %-18s %s\n",
	      "Function", "Address", "Debug Entry Address(s)");
      while ((a.cu = dwfl_nextcu(a.dwfl, a.cu, &a.dwbias)) != NULL)
	dwarf_getfuncs (a.cu, &handle_function, &a.dwfl, 0);
      return 0;
    }

  char *endp;
  uintmax_t pc = strtoumax (argv[argi], &endp, 0);
  if (endp == argv[argi])
    {
      a.funcname = argv[argi];
      /* We need to check and adjust for a possible '@' character */
      if (a.funcname[0] == '@')
	{
	  a.funcname++;
	  a.matchdebug = 1;
	}
      
      while ((a.cu = dwfl_nextcu(a.dwfl, a.cu, &a.dwbias)) != NULL)
	dwarf_getfuncs (a.cu, &handle_function, &a.dwfl, 0);
      /* If a.pc isn't set, that means the function specified wasn't found */
      if (!a.pc)
	error (EXIT_FAILURE, 0, "function: '%s' not found\n", argv[argi]);
      pc = a.pc;
    }

  Dwarf_Addr cubias;
  Dwarf_Die *cudie = dwfl_addrdie (dwfl, pc, &cubias);
  if (cudie == NULL)
    error (EXIT_FAILURE, 0, "dwfl_addrdie: %s", dwfl_errmsg (-1));

  Dwarf_Die *scopes;
  int n = dwarf_getscopes (cudie, pc - cubias, &scopes);
  if (n < 0)
    error (EXIT_FAILURE, 0, "dwarf_getscopes: %s", dwarf_errmsg (-1));
  else if (n == 0)
    error (EXIT_FAILURE, 0, "%#" PRIx64 ": not in any scope\n", pc);

  if (++argi == argc)
    {
      int indent = 0;
      while (n-- > 0)
	{
	  Dwarf_Die *const die = &scopes[n];

	  indent += INDENT;
	  printf ("%*s[%6" PRIx64 "] %s (%#x)", indent, "",
		  dwarf_dieoffset (die),
		  dwarf_diename (die) ?: "<unnamed>",
		  (unsigned)dwarf_tag (die));

	  Dwarf_Addr lowpc, highpc;
	  if (dwarf_lowpc (die, &lowpc) == 0
	      && dwarf_highpc (die, &highpc) == 0)
	    {
	      lowpc += cubias;
	      highpc += cubias;
	      Dwfl_Line *loline = dwfl_getsrc (dwfl, lowpc);
	      Dwfl_Line *hiline = dwfl_getsrc (dwfl, highpc);
	      paddr (": ", lowpc, loline);
	      if (highpc != lowpc)
		paddr (" .. ", lowpc, hiline == loline ? NULL : hiline);
	    }
	  puts ("");

	  print_vars (indent + INDENT, die);
	}
    }
  else
    {
      char *spec = argv[argi++];

      if (!strcmp (spec, "return"))
	{
	  int i;
	  for (i = 0; i < n; ++i)
	    if (dwarf_tag (&scopes[i]) == DW_TAG_subprogram)
	      {
		const Dwarf_Op *locexpr;
		Dwfl_Module *mod = dwfl_addrmodule (dwfl, pc);
		Dwarf_Addr bias;
		Dwarf *dwarf = dwfl_module_getdwarf (mod, &bias);
		int locexpr_len = dwfl_module_return_value_location
		  (mod, &scopes[i], &locexpr);
		if (locexpr_len < 0)
		  error (EXIT_FAILURE, 0,
			 "dwfl_module_return_value_location: %s",
			 dwfl_errmsg (-1));
		struct obstack pool;
		obstack_init (&pool);
		struct location *head, *tail = NULL;
		head = c_translate_location (&pool, &fail, NULL, NULL,
					     1, cubias, pc, NULL,
					     locexpr, locexpr_len,
					     &tail, NULL, NULL, dwarf);
		handle_fields (&pool, head, tail, cubias, &scopes[i], pc,
			       &argv[argi], dwarf);
		free (scopes);
		dwfl_end (dwfl);
		return 0;
	      }
	  error (EXIT_FAILURE, 0, "no subprogram to have a return value!");
	}

      int lineno = 0, colno = 0, shadow = 0;
      char *at = strchr (spec, '@');
      if (at != NULL)
	{
	  *at++ = '\0';
	  if (sscanf (at, "%*[^:]:%i:%i", &lineno, &colno) < 1)
	    lineno = 0;
	}
      else
	{
	  int len;
	  if (sscanf (spec, "%*[^+]%n+%i", &len, &shadow) == 2)
	    spec[len] = '\0';
	}

      Dwarf_Die vardie;
      int out = dwarf_getscopevar (scopes, n, spec, shadow, at, lineno, colno,
				   &vardie);
      if (out == -2)
	error (0, 0, "no match for %s (+%d, %s:%d:%d)",
	       spec, shadow, at, lineno, colno);
      else if (out < 0)
	error (0, 0, "dwarf_getscopevar: %s (+%d, %s:%d:%d): %s",
	       spec, shadow, at, lineno, colno, dwarf_errmsg (-1));
      else
	{
	  Dwarf_Op *cfa_ops = NULL;

	  size_t cfa_nops;
	  Dwarf_Addr bias;
	  Dwfl_Module *module = dwfl_addrmodule (dwfl, pc);
	  Dwarf *dwarf = NULL;
	  if (module != NULL)
	    {
	      // Try debug_frame first, then fall back on eh_frame.
	      Dwarf_CFI *cfi = dwfl_module_dwarf_cfi (module, &bias);
	      if (cfi != NULL)
		{
		  Dwarf_Frame *frame = NULL;
		  if (dwarf_cfi_addrframe (cfi, pc - bias, &frame) == 0)
		    dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops);
		}
	      if (cfa_ops == NULL)
		{
		  cfi = dwfl_module_eh_cfi (module, &bias);
		  if (cfi != NULL)
		    {
		      Dwarf_Frame *frame = NULL;
		      if (dwarf_cfi_addrframe (cfi, pc - bias, &frame) == 0)
			dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops);
		    }
		}
	      dwarf = dwfl_module_getdwarf (module, &bias);
	    }

	  handle_variable (scopes, n, out, cubias, &vardie, pc, cfa_ops,
			   &argv[argi], dwarf);
	}
    }

  free (scopes);

  dwfl_end (dwfl);

  return 0;
}

/* vim: set sw=2 ts=8 cino=>4,n-2,{2,^-2,t0,(0,u0,w1,M1 : */