libdwfl/dwfl_module.c

   1 /* Maintenance of module list in libdwfl.
   2    Copyright (C) 2005, 2006, 2007 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4
   5    Red Hat elfutils is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; version 2 of the License.
   8
   9    Red Hat elfutils is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with Red Hat elfutils; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  17
  18    In addition, as a special exception, Red Hat, Inc. gives You the
  19    additional right to link the code of Red Hat elfutils with code licensed
  20    under any Open Source Initiative certified open source license
  21    (http://www.opensource.org/licenses/index.php) which requires the
  22    distribution of source code with any binary distribution and to
  23    distribute linked combinations of the two.  Non-GPL Code permitted under
  24    this exception must only link to the code of Red Hat elfutils through
  25    those well defined interfaces identified in the file named EXCEPTION
  26    found in the source code files (the "Approved Interfaces").  The files
  27    of Non-GPL Code may instantiate templates or use macros or inline
  28    functions from the Approved Interfaces without causing the resulting
  29    work to be covered by the GNU General Public License.  Only Red Hat,
  30    Inc. may make changes or additions to the list of Approved Interfaces.
  31    Red Hat's grant of this exception is conditioned upon your not adding
  32    any new exceptions.  If you wish to add a new Approved Interface or
  33    exception, please contact Red Hat.  You must obey the GNU General Public
  34    License in all respects for all of the Red Hat elfutils code and other
  35    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  36    covered by this exception.  If you modify this file, you may extend this
  37    exception to your version of the file, but you are not obligated to do
  38    so.  If you do not wish to provide this exception without modification,
  39    you must delete this exception statement from your version and license
  40    this file solely under the GPL without exception.
  41
  42    Red Hat elfutils is an included package of the Open Invention Network.
  43    An included package of the Open Invention Network is a package for which
  44    Open Invention Network licensees cross-license their patents.  No patent
  45    license is granted, either expressly or impliedly, by designation as an
  46    included package.  Should you wish to participate in the Open Invention
  47    Network licensing program, please visit www.openinventionnetwork.com
  48    <http://www.openinventionnetwork.com>.  */
  49
  50 #include "libdwflP.h"
  51 #include <search.h>
  52 #include <unistd.h>
  53
  54 static void
  55 free_cu (struct dwfl_cu *cu)
  56 {
  57   if (cu->lines != NULL)
  58     free (cu->lines);
  59   free (cu);
  60 }
  61
  62 static void
  63 nofree (void *arg __attribute__ ((unused)))
  64 {
  65 }
  66
  67 static void
  68 free_file (struct dwfl_file *file)
  69 {
  70   free (file->name);
  71   if (file->elf != NULL)
  72     {
  73       elf_end (file->elf);
  74       if (file->fd != -1)
  75         close (file->fd);
  76     }
  77 }
  78
  79 void
  80 internal_function
  81 __libdwfl_module_free (Dwfl_Module *mod)
  82 {
  83   if (mod->lazy_cu_root != NULL)
  84     tdestroy (mod->lazy_cu_root, nofree);
  85
  86   if (mod->aranges != NULL)
  87     free (mod->aranges);
  88
  89   if (mod->cu != NULL)
  90     {
  91       for (size_t i = 0; i < mod->ncu; ++i)
  92         free_cu (mod->cu[i]);
  93       free (mod->cu);
  94     }
  95
  96   if (mod->dw != NULL)
  97     INTUSE(dwarf_end) (mod->dw);
  98
  99   if (mod->ebl != NULL)
 100     ebl_closebackend (mod->ebl);
 101
 102   if (mod->debug.elf != mod->main.elf)
 103     free_file (&mod->debug);
 104   free_file (&mod->main);
 105
 106   free (mod->name);
 107   free (mod);
 108 }
 109
 110 void
 111 dwfl_report_begin_add (Dwfl *dwfl)
 112 {
 113   if (dwfl->modules != NULL)
 114     free (dwfl->modules);
 115   dwfl->modules = NULL;
 116   dwfl->nmodules = 0;
 117 }
 118 INTDEF (dwfl_report_begin_add)
 119
 120 void
 121 dwfl_report_begin (Dwfl *dwfl)
 122 {
 123   INTUSE(dwfl_report_begin_add) (dwfl);
 124
 125   for (Dwfl_Module *m = dwfl->modulelist; m != NULL; m = m->next)
 126     m->gc = true;
 127
 128   dwfl->offline_next_address = OFFLINE_REDZONE;
 129 }
 130 INTDEF (dwfl_report_begin)
 131
 132 /* Report that a module called NAME spans addresses [START, END).
 133    Returns the module handle, either existing or newly allocated,
 134    or returns a null pointer for an allocation error.  */
 135 Dwfl_Module *
 136 dwfl_report_module (Dwfl *dwfl, const char *name,
 137                     GElf_Addr start, GElf_Addr end)
 138 {
 139   Dwfl_Module **tailp = &dwfl->modulelist, **prevp = tailp;
 140   for (Dwfl_Module *m = *prevp; m != NULL; m = *(prevp = &m->next))
 141     {
 142       if (m->low_addr == start && m->high_addr == end
 143           && !strcmp (m->name, name))
 144         {
 145           /* This module is still here.  Move it to the place in the list
 146              after the last module already reported.  */
 147
 148           *prevp = m->next;
 149           m->next = *tailp;
 150           m->gc = false;
 151           *tailp = m;
 152           return m;
 153         }
 154
 155       if (! m->gc)
 156         tailp = &m->next;
 157     }
 158
 159   Dwfl_Module *mod = calloc (1, sizeof *mod);
 160   if (mod == NULL)
 161     goto nomem;
 162
 163   mod->name = strdup (name);
 164   if (mod->name == NULL)
 165     {
 166       free (mod);
 167     nomem:
 168       __libdwfl_seterrno (DWFL_E_NOMEM);
 169       return NULL;
 170     }
 171
 172   mod->low_addr = start;
 173   mod->high_addr = end;
 174   mod->dwfl = dwfl;
 175
 176   mod->next = *tailp;
 177   *tailp = mod;
 178   ++dwfl->nmodules;
 179
 180   return mod;
 181 }
 182 INTDEF (dwfl_report_module)
 183
 184
 185 static int
 186 compare_modules (const void *a, const void *b)
 187 {
 188   Dwfl_Module *const *p1 = a, *const *p2 = b;
 189   const Dwfl_Module *m1 = *p1, *m2 = *p2;
 190   if (m1 == NULL)
 191     return -1;
 192   if (m2 == NULL)
 193     return 1;
 194
 195   /* No signed difference calculation is correct here, since the
 196      terms are unsigned and could be more than INT64_MAX apart.  */
 197   if (m1->low_addr < m2->low_addr)
 198     return -1;
 199   if (m1->low_addr > m2->low_addr)
 200     return 1;
 201   return 0;
 202 }
 203
 204
 205 /* Finish reporting the current set of modules to the library.
 206    If REMOVED is not null, it's called for each module that
 207    existed before but was not included in the current report.
 208    Returns a nonzero return value from the callback.
 209    DWFL cannot be used until this function has returned zero.  */
 210 int
 211 dwfl_report_end (Dwfl *dwfl,
 212                  int (*removed) (Dwfl_Module *, void *,
 213                                  const char *, Dwarf_Addr,
 214                                  void *arg),
 215                  void *arg)
 216 {
 217   assert (dwfl->modules == NULL);
 218
 219   Dwfl_Module **tailp = &dwfl->modulelist;
 220   while (*tailp != NULL)
 221     {
 222       Dwfl_Module *m = *tailp;
 223       if (m->gc && removed != NULL)
 224         {
 225           int result = (*removed) (MODCB_ARGS (m), arg);
 226           if (result != 0)
 227             return result;
 228         }
 229       if (m->gc)
 230         {
 231           *tailp = m->next;
 232           __libdwfl_module_free (m);
 233         }
 234       else
 235         tailp = &m->next;
 236     }
 237
 238   dwfl->modules = malloc (dwfl->nmodules * sizeof dwfl->modules[0]);
 239   if (dwfl->modules == NULL && dwfl->nmodules != 0)
 240     return -1;
 241
 242   size_t i = 0;
 243   for (Dwfl_Module *m = dwfl->modulelist; m != NULL; m = m->next)
 244     {
 245       assert (! m->gc);
 246       dwfl->modules[i++] = m;
 247     }
 248   assert (i == dwfl->nmodules);
 249
 250   qsort (dwfl->modules, dwfl->nmodules, sizeof dwfl->modules[0],
 251          &compare_modules);
 252
 253   return 0;
 254 }
 255 INTDEF (dwfl_report_end)