Quelle  gendwarfksyms.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2024 Google LLC
 */

#include <fcntl.h>
#include <getopt.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include "gendwarfksyms.h"

/*
 * Options
 */

/* Print debugging information to stderr */
int debug;
/* Dump DIE contents */
int dump_dies;
/* Print debugging information about die_map changes */
int dump_die_map;
/* Print out type strings (i.e. type_map) */
int dump_types;
/* Print out expanded type strings used for symbol versions */
int dump_versions;
/* Support kABI stability features */
int stable;
/* Write a symtypes file */
int symtypes;
static const char *symtypes_file;

static void usage(void)
{
 fputs("Usage: gendwarfksyms [options] elf-object-file ... < symbol-list\n\n"
       "Options:\n"
       " -d, --debug Print debugging information\n"
       " --dump-dies Dump DWARF DIE contents\n"
       " --dump-die-map Print debugging information about die_map changes\n"
       " --dump-types Dump type strings\n"
       " --dump-versions Dump expanded type strings used for symbol versions\n"
       " -s, --stable Support kABI stability features\n"
       " -T, --symtypes file Write a symtypes file\n"
       " -h, --help Print this message\n"
       "\n",
       stderr);
}

static int process_module(Dwfl_Module *mod, void **userdata, const char *name,
     Dwarf_Addr base, void *arg)
{
 Dwarf_Addr dwbias;
 Dwarf_Die cudie;
 Dwarf_CU *cu = NULL;
 Dwarf *dbg;
 FILE *symfile = arg;
 int res;

 debug("%s", name);
 dbg = dwfl_module_getdwarf(mod, &dwbias);

 /*
 * Look for exported symbols in each CU, follow the DIE tree, and add
 * the entries to die_map.
 */
 do {
  res = dwarf_get_units(dbg, cu, &cu, NULL, NULL, &cudie, NULL);
  if (res < 0)
   error("dwarf_get_units failed: no debugging information?");
  if (res == 1)
   break; /* No more units */

  process_cu(&cudie);
 } while (cu);

 /*
 * Use die_map to expand type strings, write them to `symfile`, and
 * calculate symbol versions.
 */
 generate_symtypes_and_versions(symfile);
 die_map_free();

 return DWARF_CB_OK;
}

static const Dwfl_Callbacks callbacks = {
 .section_address = dwfl_offline_section_address,
 .find_debuginfo = dwfl_standard_find_debuginfo,
};

int main(int argc, char **argv)
{
 FILE *symfile = NULL;
 unsigned int n;
 int opt;

 static const struct option opts[] = {
  { "debug", 0, NULL, 'd' },
  { "dump-dies", 0, &dump_dies, 1 },
  { "dump-die-map", 0, &dump_die_map, 1 },
  { "dump-types", 0, &dump_types, 1 },
  { "dump-versions", 0, &dump_versions, 1 },
  { "stable", 0, NULL, 's' },
  { "symtypes", 1, NULL, 'T' },
  { "help", 0, NULL, 'h' },
  { 0, 0, NULL, 0 }
 };

 while ((opt = getopt_long(argc, argv, "dsT:h", opts, NULL)) != EOF) {
  switch (opt) {
  case 0:
   break;
  case 'd':
   debug = 1;
   break;
  case 's':
   stable = 1;
   break;
  case 'T':
   symtypes = 1;
   symtypes_file = optarg;
   break;
  case 'h':
   usage();
   return 0;
  default:
   usage();
   return 1;
  }
 }

 if (dump_die_map)
  dump_dies = 1;

 if (optind >= argc) {
  usage();
  error("no input files?");
 }

 if (!symbol_read_exports(stdin))
  return 0;

 if (symtypes_file) {
  symfile = fopen(symtypes_file, "w");
  if (!symfile)
   error("fopen failed for '%s': %s", symtypes_file,
         strerror(errno));
 }

 for (n = optind; n < argc; n++) {
  Dwfl *dwfl;
  int fd;

  fd = open(argv[n], O_RDONLY);
  if (fd == -1)
   error("open failed for '%s': %s", argv[n],
         strerror(errno));

  symbol_read_symtab(fd);
  kabi_read_rules(fd);

  dwfl = dwfl_begin(&callbacks);
  if (!dwfl)
   error("dwfl_begin failed for '%s': %s", argv[n],
         dwarf_errmsg(-1));

  if (!dwfl_report_offline(dwfl, argv[n], argv[n], fd))
   error("dwfl_report_offline failed for '%s': %s",
         argv[n], dwarf_errmsg(-1));

  dwfl_report_end(dwfl, NULL, NULL);

  if (dwfl_getmodules(dwfl, &process_module, symfile, 0))
   error("dwfl_getmodules failed for '%s'", argv[n]);

  dwfl_end(dwfl);
  kabi_free();
 }

 if (symfile)
  check(fclose(symfile));

 symbol_print_versions();
 symbol_free();

 return 0;
}