usr/src/tools/ctf/dwarf/common/dwarf_init_finish.c

   1 /*
   2
   3   Copyright (C) 2000,2002,2003,2004,2005 Silicon Graphics, Inc. All Rights Reserved.
   4   Portions Copyright (C) 2008-2010 Arxan Technologies, Inc. All Rights Reserved.
   5   Portions Copyright (C) 2009-2010 David Anderson. All Rights Reserved.
   6
   7   This program is free software; you can redistribute it and/or modify it
   8   under the terms of version 2.1 of the GNU Lesser General Public License
   9   as published by the Free Software Foundation.
  10
  11   This program is distributed in the hope that it would be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15   Further, this software is distributed without any warranty that it is
  16   free of the rightful claim of any third person regarding infringement
  17   or the like.  Any license provided herein, whether implied or
  18   otherwise, applies only to this software file.  Patent licenses, if
  19   any, provided herein do not apply to combinations of this program with
  20   other software, or any other product whatsoever.
  21
  22   You should have received a copy of the GNU Lesser General Public
  23   License along with this program; if not, write the Free Software
  24   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
  25   USA.
  26
  27   Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
  28   Mountain View, CA 94043, or:
  29
  30   http://www.sgi.com
  31
  32   For further information regarding this notice, see:
  33
  34   http://oss.sgi.com/projects/GenInfo/NoticeExplan
  35
  36 */
  37
  38 #include "config.h"
  39 #include "dwarf_incl.h"
  40
  41 #include <stdio.h>
  42 #include <sys/stat.h>
  43 #include <sys/types.h>
  44 #include <string.h>
  45 #include <stdlib.h>
  46
  47 #include "dwarf_incl.h"
  48 #include "malloc_check.h"
  49
  50 #define DWARF_DBG_ERROR(dbg,errval,retval) \
  51      _dwarf_error(dbg, error, errval); return(retval);
  52
  53 #define FALSE 0
  54 #define TRUE  1
  55
  56
  57
  58 /* This static is copied to the dbg on dbg init
  59    so that the static need not be referenced at
  60    run time, preserving better locality of
  61    reference.
  62    Value is 0 means do the string check.
  63    Value non-zero means do not do the check.
  64 */
  65 static Dwarf_Small _dwarf_assume_string_bad;
  66 static Dwarf_Small _dwarf_apply_relocs = 1;
  67
  68 /* Call this after calling dwarf_init but before doing anything else.
  69  * It applies to all objects, not just the current object.
  70  */
  71 int
  72 dwarf_set_reloc_application(int apply)
  73 {
  74     int oldval = _dwarf_apply_relocs;
  75     _dwarf_apply_relocs = apply;
  76     return oldval;
  77 }
  78
  79 int
  80 dwarf_set_stringcheck(int newval)
  81 {
  82     int oldval = _dwarf_assume_string_bad;
  83
  84     _dwarf_assume_string_bad = newval;
  85     return oldval;
  86 }
  87
  88 /* Unifies the basic duplicate/empty testing and section
  89  * data setting to one place. */
  90 static int
  91 get_basic_section_data(Dwarf_Debug dbg,
  92     struct Dwarf_Section_s *secdata,
  93     struct Dwarf_Obj_Access_Section_s *doas,
  94     Dwarf_Half section_index,
  95     Dwarf_Error* error,
  96     int duperr, int emptyerr )
  97 {
  98     if (secdata->dss_index != 0) {
  99         DWARF_DBG_ERROR(dbg, duperr, DW_DLV_ERROR);
 100     }
 101     if (doas->size == 0) {
 102         if (emptyerr == 0 ) {
 103             /* Allow empty section. */
 104             return DW_DLV_OK;
 105         }
 106         /* Know no reason to allow section */
 107         DWARF_DBG_ERROR(dbg, emptyerr, DW_DLV_ERROR);
 108     }
 109     secdata->dss_index = section_index;
 110     secdata->dss_size = doas->size;
 111     secdata->dss_addr = doas->addr;
 112     secdata->dss_link = doas->link;
 113     return DW_DLV_OK;
 114 }
 115
 116
 117 static void
 118 add_rela_data( struct Dwarf_Section_s *secdata,
 119     struct Dwarf_Obj_Access_Section_s *doas,
 120     Dwarf_Half section_index)
 121 {
 122     secdata->dss_reloc_index = section_index;
 123     secdata->dss_reloc_size = doas->size;
 124     secdata->dss_reloc_addr = doas->addr;
 125     secdata->dss_reloc_symtab = doas->link;
 126     secdata->dss_reloc_link = doas->link;
 127 }
 128
 129 /*
 130     Given an Elf ptr, set up dbg with pointers
 131     to all the Dwarf data sections.
 132     Return NULL on error.
 133
 134     This function is also responsible for determining
 135     whether the given object contains Dwarf information
 136     or not.  The test currently used is that it contains
 137     either a .debug_info or a .debug_frame section.  If
 138     not, it returns DW_DLV_NO_ENTRY causing dwarf_init() also to
 139     return DW_DLV_NO_ENTRY.  Earlier, we had thought of using only
 140     the presence/absence of .debug_info to test, but we
 141     added .debug_frame since there could be stripped objects
 142     that have only a .debug_frame section for exception
 143     processing.
 144     DW_DLV_NO_ENTRY or DW_DLV_OK or DW_DLV_ERROR
 145 */
 146 static int
 147 _dwarf_setup(Dwarf_Debug dbg, Dwarf_Error * error)
 148 {
 149     const char *scn_name = 0;
 150     int foundDwarf = 0;
 151     struct Dwarf_Obj_Access_Interface_s * obj = 0;
 152
 153     Dwarf_Endianness endianness;
 154
 155     Dwarf_Unsigned section_size = 0;
 156     Dwarf_Unsigned section_count = 0;
 157     Dwarf_Half section_index = 0;
 158     Dwarf_Addr section_addr = 0;
 159
 160     foundDwarf = FALSE;
 161
 162     dbg->de_assume_string_in_bounds = _dwarf_assume_string_bad;
 163
 164     dbg->de_same_endian = 1;
 165     dbg->de_copy_word = memcpy;
 166     obj = dbg->de_obj_file;
 167     endianness = obj->methods->get_byte_order(obj->object);
 168 #ifdef WORDS_BIGENDIAN
 169     dbg->de_big_endian_object = 1;
 170     if (endianness == DW_OBJECT_LSB ) {
 171         dbg->de_same_endian = 0;
 172         dbg->de_big_endian_object = 0;
 173         dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
 174     }
 175 #else /* little endian */
 176     dbg->de_big_endian_object = 0;
 177     if (endianness == DW_OBJECT_MSB ) {
 178         dbg->de_same_endian = 0;
 179         dbg->de_big_endian_object = 1;
 180         dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
 181     }
 182 #endif /* !WORDS_BIGENDIAN */
 183
 184
 185     /* The following de_length_size is Not Too Significant. Only used
 186        one calculation, and an approximate one at that. */
 187     dbg->de_length_size = obj->methods->get_length_size(obj->object);
 188     dbg->de_pointer_size = obj->methods->get_pointer_size(obj->object);
 189
 190     section_count = obj->methods->get_section_count(obj->object);
 191
 192     /* We can skip index 0 when considering ELF files, but not other
 193        object types. */
 194     for (section_index = 0; section_index < section_count;
 195          ++section_index) {
 196
 197         struct Dwarf_Obj_Access_Section_s doas;
 198         int res = DW_DLV_ERROR;
 199         int err;
 200
 201         res = obj->methods->get_section_info(obj->object,
 202                                              section_index,
 203                                              &doas, &err);
 204         if(res == DW_DLV_ERROR){
 205           DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
 206         }
 207
 208         section_addr = doas.addr;
 209         section_size = doas.size;
 210         scn_name = doas.name;
 211
 212         if (strncmp(scn_name, ".debug_", 7)
 213             && strcmp(scn_name, ".eh_frame")
 214             && strcmp(scn_name, ".symtab")
 215             && strcmp(scn_name, ".strtab")
 216             && strncmp(scn_name, ".rela.",6))  {
 217             continue;
 218         }
 219         else if (strcmp(scn_name, ".debug_info") == 0) {
 220             res = get_basic_section_data(dbg,&dbg->de_debug_info, &doas,
 221                   section_index,error,
 222                   DW_DLE_DEBUG_INFO_DUPLICATE,DW_DLE_DEBUG_INFO_NULL);
 223             if(res != DW_DLV_OK) {
 224                   return res;
 225             }
 226             foundDwarf = TRUE;
 227         }
 228         else if (strcmp(scn_name, ".debug_abbrev") == 0) {
 229             res = get_basic_section_data(dbg,&dbg->de_debug_abbrev, &doas,
 230                   section_index,error,
 231                   DW_DLE_DEBUG_ABBREV_DUPLICATE,DW_DLE_DEBUG_ABBREV_NULL);
 232             if(res != DW_DLV_OK) {
 233                   return res;
 234             }
 235         }
 236         else if (strcmp(scn_name, ".debug_aranges") == 0) {
 237             res = get_basic_section_data(dbg,&dbg->de_debug_aranges, &doas,
 238                   section_index,error,
 239                   DW_DLE_DEBUG_ARANGES_DUPLICATE,0);
 240             if(res != DW_DLV_OK) {
 241                   return res;
 242             }
 243         }
 244
 245         else if (strcmp(scn_name, ".debug_line") == 0) {
 246             res = get_basic_section_data(dbg,&dbg->de_debug_line, &doas,
 247                   section_index,error,
 248                   DW_DLE_DEBUG_LINE_DUPLICATE,0);
 249             if(res != DW_DLV_OK) {
 250                   return res;
 251             }
 252         }
 253         else if (strcmp(scn_name, ".debug_frame") == 0) {
 254             res = get_basic_section_data(dbg,&dbg->de_debug_frame, &doas,
 255                   section_index,error,
 256                   DW_DLE_DEBUG_FRAME_DUPLICATE,0);
 257             if(res != DW_DLV_OK) {
 258                   return res;
 259             }
 260             foundDwarf = TRUE;
 261         } else if (strcmp(scn_name, ".eh_frame") == 0) {
 262             /* gnu egcs-1.1.2 data */
 263             res = get_basic_section_data(dbg,&dbg->de_debug_frame_eh_gnu, &doas,
 264                   section_index,error,
 265                   DW_DLE_DEBUG_FRAME_DUPLICATE,0);
 266             if(res != DW_DLV_OK) {
 267                   return res;
 268             }
 269             foundDwarf = TRUE;
 270         }
 271         else if (strcmp(scn_name, ".debug_loc") == 0) {
 272             res = get_basic_section_data(dbg,&dbg->de_debug_loc, &doas,
 273                   section_index,error,
 274                   DW_DLE_DEBUG_LOC_DUPLICATE,0);
 275             if(res != DW_DLV_OK) {
 276                   return res;
 277             }
 278         }
 279         else if (strcmp(scn_name, ".debug_pubnames") == 0) {
 280             res = get_basic_section_data(dbg,&dbg->de_debug_pubnames, &doas,
 281                   section_index,error,
 282                   DW_DLE_DEBUG_PUBNAMES_DUPLICATE,0);
 283             if(res != DW_DLV_OK) {
 284                   return res;
 285             }
 286         }
 287
 288         else if (strcmp(scn_name, ".debug_str") == 0) {
 289             res = get_basic_section_data(dbg,&dbg->de_debug_str, &doas,
 290                   section_index,error,
 291                   DW_DLE_DEBUG_STR_DUPLICATE,0);
 292             if(res != DW_DLV_OK) {
 293                   return res;
 294             }
 295         }
 296         else if (strcmp(scn_name, ".debug_funcnames") == 0) {
 297             /* SGI IRIX-only. */
 298             res = get_basic_section_data(dbg,&dbg->de_debug_funcnames, &doas,
 299                   section_index,error,
 300                   DW_DLE_DEBUG_FUNCNAMES_DUPLICATE,0);
 301             if(res != DW_DLV_OK) {
 302                   return res;
 303             }
 304         }
 305         else if (strcmp(scn_name, ".debug_typenames") == 0) {
 306             /* SGI IRIX-only, created years before DWARF3. Content
 307                essentially identical to .debug_pubtypes.  */
 308             res = get_basic_section_data(dbg,&dbg->de_debug_typenames, &doas,
 309                   section_index,error,
 310                   DW_DLE_DEBUG_TYPENAMES_DUPLICATE,0);
 311             if(res != DW_DLV_OK) {
 312                   return res;
 313             }
 314         } else if (strcmp(scn_name, ".debug_pubtypes") == 0) {
 315             /* Section new in DWARF3.  */
 316             res = get_basic_section_data(dbg,&dbg->de_debug_pubtypes, &doas,
 317                   section_index,error,
 318                   DW_DLE_DEBUG_PUBTYPES_DUPLICATE,0);
 319             if(res != DW_DLV_OK) {
 320                   return res;
 321             }
 322         }
 323         else if (strcmp(scn_name, ".debug_varnames") == 0) {
 324             /* SGI IRIX-only.  */
 325             res = get_basic_section_data(dbg,&dbg->de_debug_varnames, &doas,
 326                   section_index,error,
 327                   DW_DLE_DEBUG_VARNAMES_DUPLICATE,0);
 328             if(res != DW_DLV_OK) {
 329                   return res;
 330             }
 331         }
 332         else if (strcmp(scn_name, ".debug_weaknames") == 0) {
 333             /* SGI IRIX-only. */
 334             res = get_basic_section_data(dbg,&dbg->de_debug_weaknames, &doas,
 335                   section_index,error,
 336                   DW_DLE_DEBUG_WEAKNAMES_DUPLICATE,0);
 337             if(res != DW_DLV_OK) {
 338                   return res;
 339             }
 340         } else if (strcmp(scn_name, ".debug_macinfo") == 0) {
 341             res = get_basic_section_data(dbg,&dbg->de_debug_macinfo, &doas,
 342                   section_index,error,
 343                   DW_DLE_DEBUG_MACINFO_DUPLICATE,0);
 344             if(res != DW_DLV_OK) {
 345                   return res;
 346             }
 347         }
 348         else if (strcmp(scn_name, ".debug_ranges") == 0) {
 349             res = get_basic_section_data(dbg,&dbg->de_debug_ranges, &doas,
 350                   section_index,error,
 351                   DW_DLE_DEBUG_RANGES_DUPLICATE,0);
 352             if(res != DW_DLV_OK) {
 353                   return res;
 354             }
 355             foundDwarf = TRUE;
 356         }
 357         else if (strcmp(scn_name, ".symtab") == 0) {
 358             res = get_basic_section_data(dbg,&dbg->de_elf_symtab, &doas,
 359                   section_index,error,
 360                   DW_DLE_DEBUG_SYMTAB_ERR,0);
 361             if(res != DW_DLV_OK) {
 362                   return res;
 363             }
 364         }
 365         else if (strcmp(scn_name, ".strtab")  == 0) {
 366             res = get_basic_section_data(dbg,&dbg->de_elf_strtab, &doas,
 367                   section_index,error,
 368                   DW_DLE_DEBUG_STRTAB_ERR,0);
 369             if(res != DW_DLV_OK) {
 370                   return res;
 371             }
 372         }
 373         else if (strncmp(scn_name, ".rela.debug_",12) == 0) {
 374             const char *rcn_name = scn_name + 5;
 375             if (strcmp(rcn_name, ".debug_info") == 0) {
 376                 add_rela_data(&dbg->de_debug_info,&doas,section_index);
 377             } else if (strcmp(rcn_name, ".debug_abbrev") == 0) {
 378                 add_rela_data(&dbg->de_debug_abbrev,&doas,section_index);
 379             } else if (strcmp(rcn_name, ".debug_aranges") == 0) {
 380                 add_rela_data(&dbg->de_debug_aranges,&doas,section_index);
 381             } else if (strcmp(rcn_name, ".debug_line") == 0) {
 382                 add_rela_data(&dbg->de_debug_line,&doas,section_index);
 383             } else if (strcmp(rcn_name, ".debug_frame") == 0) {
 384                 add_rela_data(&dbg->de_debug_frame,&doas,section_index);
 385             } else if (strcmp(rcn_name, ".eh_frame") == 0) {
 386                 add_rela_data(&dbg->de_debug_frame_eh_gnu,&doas,section_index);
 387             } else if (strcmp(rcn_name, ".debug_loc") == 0) {
 388                 add_rela_data(&dbg->de_debug_loc,&doas,section_index);
 389             } else if (strcmp(rcn_name, ".debug_pubnames") == 0) {
 390                 add_rela_data(&dbg->de_debug_pubnames,&doas,section_index);
 391             } else if (strcmp(rcn_name, ".debug_str") == 0) {
 392                 add_rela_data(&dbg->de_debug_str,&doas,section_index);
 393             } else if (strcmp(rcn_name, ".debug_funcnames") == 0) {
 394                 add_rela_data(&dbg->de_debug_funcnames,&doas,section_index);
 395             } else if (strcmp(rcn_name, ".debug_typenames") == 0) {
 396                 add_rela_data(&dbg->de_debug_typenames,&doas,section_index);
 397             } else if (strcmp(rcn_name, ".debug_pubtypes") == 0) {
 398                 add_rela_data(&dbg->de_debug_pubtypes,&doas,section_index);
 399             } else if (strcmp(rcn_name, ".debug_varnames") == 0) {
 400                 add_rela_data(&dbg->de_debug_varnames,&doas,section_index);
 401             } else if (strcmp(rcn_name, ".debug_weaknames") == 0) {
 402                 add_rela_data(&dbg->de_debug_weaknames,&doas,section_index);
 403             } else if (strcmp(rcn_name, ".debug_macinfo") == 0) {
 404                 add_rela_data(&dbg->de_debug_macinfo,&doas,section_index);
 405             }
 406         }
 407     }
 408     if (foundDwarf) {
 409         return DW_DLV_OK;
 410     }
 411     return DW_DLV_NO_ENTRY;
 412 }
 413
 414
 415 /*
 416     Use a Dwarf_Obj_Access_Interface to kick things off. All other
 417     init routines eventually use this one.
 418     The returned Dwarf_Debug contains a copy of *obj
 419     the callers copy of *obj may be freed whenever the caller
 420     wishes.
 421 */
 422 int
 423 dwarf_object_init(Dwarf_Obj_Access_Interface* obj, Dwarf_Handler errhand,
 424                Dwarf_Ptr errarg, Dwarf_Debug* ret_dbg,
 425                Dwarf_Error* error)
 426 {
 427     Dwarf_Debug dbg = 0;
 428     int setup_result = DW_DLV_OK;
 429
 430     dbg = _dwarf_get_debug();
 431     if (dbg == NULL) {
 432         DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
 433     }
 434     dbg->de_errhand = errhand;
 435     dbg->de_errarg = errarg;
 436     dbg->de_frame_rule_initial_value = DW_FRAME_REG_INITIAL_VALUE;
 437     dbg->de_frame_reg_rules_entry_count = DW_FRAME_LAST_REG_NUM;
 438 #ifdef HAVE_OLD_FRAME_CFA_COL
 439     /* DW_FRAME_CFA_COL is really only suitable for old libdwarf frame
 440        interfaces and its value of 0 there is only usable where
 441        (as in MIPS) register 0 has no value other than 0 so
 442        we can use the frame table column 0 for the CFA value
 443        (and rely on client software to know when 'register 0'
 444        is the cfa and when to just use a value 0 for register 0).
 445     */
 446     dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL;
 447 #else
 448     dbg->de_frame_cfa_col_number = DW_FRAME_CFA_COL3;
 449 #endif
 450     dbg->de_frame_same_value_number = DW_FRAME_SAME_VAL;
 451     dbg->de_frame_undefined_value_number  = DW_FRAME_UNDEFINED_VAL;
 452
 453     dbg->de_obj_file = obj;
 454
 455     setup_result = _dwarf_setup(dbg, error);
 456     if (setup_result != DW_DLV_OK) {
 457         /* The status we want to return  here is of _dwarf_setup,
 458            not of the  _dwarf_free_all_of_one_debug(dbg) call.
 459            So use a local status variable for the free.  */
 460         int freeresult = _dwarf_free_all_of_one_debug(dbg);
 461         if (freeresult == DW_DLV_ERROR) {
 462             DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
 463         }
 464         dwarf_malloc_check_complete("After Final free");
 465         return setup_result;
 466     }
 467
 468     dwarf_harmless_init(&dbg->de_harmless_errors,
 469         DW_HARMLESS_ERROR_CIRCULAR_LIST_DEFAULT_SIZE);
 470
 471     /* This call cannot fail: allocates nothing, releases nothing */
 472     _dwarf_setup_debug(dbg);
 473
 474
 475     *ret_dbg = dbg;
 476     return DW_DLV_OK;
 477 }
 478
 479
 480 /*
 481     A finish routine that is completely unaware of ELF.
 482
 483     Frees all memory that was not previously freed by
 484     dwarf_dealloc.
 485     Aside frmo certain categories.
 486  */
 487 int
 488 dwarf_object_finish(Dwarf_Debug dbg, Dwarf_Error * error)
 489 {
 490     int res = DW_DLV_OK;
 491
 492     res = _dwarf_free_all_of_one_debug(dbg);
 493     if (res == DW_DLV_ERROR) {
 494         DWARF_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC, DW_DLV_ERROR);
 495     }
 496     dwarf_malloc_check_complete("After Final free");
 497
 498     return res;
 499 }
 500
 501
 502 /*
 503     Load the ELF section with the specified index and set the
 504     pointer pointed to by section_data to the memory where it
 505     was loaded.
 506  */
 507 int
 508 _dwarf_load_section(Dwarf_Debug dbg,
 509     struct Dwarf_Section_s *section,
 510     Dwarf_Error * error)
 511 {
 512     int res  = DW_DLV_ERROR;
 513     int err = 0;
 514     struct Dwarf_Obj_Access_Interface_s *o = 0;
 515
 516     /* check to see if the section is already loaded */
 517     if (section->dss_data !=  NULL) {
 518         return DW_DLV_OK;
 519     }
 520     o = dbg->de_obj_file;
 521     res = o->methods->load_section(
 522         o->object, section->dss_index,
 523         &section->dss_data, &err);
 524     if(res == DW_DLV_ERROR){
 525         DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
 526     }
 527     if(_dwarf_apply_relocs == 0) {
 528         return res;
 529     }
 530     if(section->dss_reloc_size == 0) {
 531         return res;
 532     }
 533     if(!o->methods->relocate_a_section) {
 534         return res;
 535     }
 536     /*apply relocations */
 537     res = o->methods->relocate_a_section( o->object, section->dss_index,
 538         dbg, &err);
 539     if(res == DW_DLV_ERROR) {
 540         DWARF_DBG_ERROR(dbg, err, DW_DLV_ERROR);
 541     }
 542     return res;
 543 }
 544
 545 /* This is a hack so clients can verify offsets.
 546    Added April 2005 so that debugger can detect broken offsets
 547    (which happened in an IRIX  -64 executable larger than 2GB
 548     using MIPSpro 7.3.1.3 compilers. A couple .debug_pubnames
 549     offsets were wrong.).
 550 */
 551 int
 552 dwarf_get_section_max_offsets(Dwarf_Debug dbg,
 553     Dwarf_Unsigned * debug_info_size,
 554     Dwarf_Unsigned * debug_abbrev_size,
 555     Dwarf_Unsigned * debug_line_size,
 556     Dwarf_Unsigned * debug_loc_size,
 557     Dwarf_Unsigned * debug_aranges_size,
 558     Dwarf_Unsigned * debug_macinfo_size,
 559     Dwarf_Unsigned * debug_pubnames_size,
 560     Dwarf_Unsigned * debug_str_size,
 561     Dwarf_Unsigned * debug_frame_size,
 562     Dwarf_Unsigned * debug_ranges_size,
 563     Dwarf_Unsigned * debug_typenames_size)
 564 {
 565     *debug_info_size = dbg->de_debug_info.dss_size;
 566     *debug_abbrev_size = dbg->de_debug_abbrev.dss_size;
 567     *debug_line_size = dbg->de_debug_line.dss_size;
 568     *debug_loc_size = dbg->de_debug_loc.dss_size;
 569     *debug_aranges_size = dbg->de_debug_aranges.dss_size;
 570     *debug_macinfo_size = dbg->de_debug_macinfo.dss_size;
 571     *debug_pubnames_size = dbg->de_debug_pubnames.dss_size;
 572     *debug_str_size = dbg->de_debug_str.dss_size;
 573     *debug_frame_size = dbg->de_debug_frame.dss_size;
 574     *debug_ranges_size = dbg->de_debug_ranges.dss_size;
 575     *debug_typenames_size = dbg->de_debug_typenames.dss_size;
 576     return DW_DLV_OK;
 577 }