contrib/elftoolchain/libdwarf/libdwarf_info.c

   1 /*-
   2  * Copyright (c) 2007 John Birrell (jb@freebsd.org)
   3  * Copyright (c) 2010,2011,2014 Kai Wang
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include "_libdwarf.h"
  29
  30 ELFTC_VCSID("$Id: libdwarf_info.c 3136 2014-12-24 16:04:38Z kaiwang27 $");
  31
  32 int
  33 _dwarf_info_first_cu(Dwarf_Debug dbg, Dwarf_Error *error)
  34 {
  35         Dwarf_CU cu;
  36         int ret;
  37
  38         assert(dbg->dbg_cu_current == NULL);
  39         cu = STAILQ_FIRST(&dbg->dbg_cu);
  40         if (cu != NULL) {
  41                 dbg->dbg_cu_current = cu;
  42                 return (DW_DLE_NONE);
  43         }
  44
  45         if (dbg->dbg_info_loaded)
  46                 return (DW_DLE_NO_ENTRY);
  47
  48         dbg->dbg_info_off = 0;
  49         ret = _dwarf_info_load(dbg, 0, 1, error);
  50         if (ret != DW_DLE_NONE)
  51                 return (ret);
  52
  53         dbg->dbg_cu_current = STAILQ_FIRST(&dbg->dbg_cu);
  54
  55         return (DW_DLE_NONE);
  56 }
  57
  58 int
  59 _dwarf_info_first_tu(Dwarf_Debug dbg, Dwarf_Error *error)
  60 {
  61         Dwarf_CU tu;
  62         int ret;
  63
  64         assert(dbg->dbg_tu_current == NULL);
  65         tu = STAILQ_FIRST(&dbg->dbg_tu);
  66         if (tu != NULL) {
  67                 dbg->dbg_tu_current = tu;
  68                 return (DW_DLE_NONE);
  69         }
  70
  71         if (dbg->dbg_types_loaded)
  72                 return (DW_DLE_NO_ENTRY);
  73
  74         dbg->dbg_types_off = 0;
  75         ret = _dwarf_info_load(dbg, 0, 0, error);
  76         if (ret != DW_DLE_NONE)
  77                 return (ret);
  78
  79         dbg->dbg_tu_current = STAILQ_FIRST(&dbg->dbg_tu);
  80
  81         return (DW_DLE_NONE);
  82 }
  83
  84 int
  85 _dwarf_info_next_cu(Dwarf_Debug dbg, Dwarf_Error *error)
  86 {
  87         Dwarf_CU cu;
  88         int ret;
  89
  90         assert(dbg->dbg_cu_current != NULL);
  91         cu = STAILQ_NEXT(dbg->dbg_cu_current, cu_next);
  92         if (cu != NULL) {
  93                 dbg->dbg_cu_current = cu;
  94                 return (DW_DLE_NONE);
  95         }
  96
  97         if (dbg->dbg_info_loaded) {
  98                 dbg->dbg_cu_current = NULL;
  99                 return (DW_DLE_NO_ENTRY);
 100         }
 101
 102         ret = _dwarf_info_load(dbg, 0, 1, error);
 103         if (ret != DW_DLE_NONE)
 104                 return (ret);
 105
 106         dbg->dbg_cu_current = STAILQ_NEXT(dbg->dbg_cu_current, cu_next);
 107
 108         return (DW_DLE_NONE);
 109 }
 110
 111 int
 112 _dwarf_info_next_tu(Dwarf_Debug dbg, Dwarf_Error *error)
 113 {
 114         Dwarf_CU cu;
 115         int ret;
 116
 117         assert(dbg->dbg_tu_current != NULL);
 118         cu = STAILQ_NEXT(dbg->dbg_tu_current, cu_next);
 119         if (cu != NULL) {
 120                 dbg->dbg_tu_current = cu;
 121                 return (DW_DLE_NONE);
 122         }
 123
 124         if (dbg->dbg_types_loaded) {
 125                 dbg->dbg_tu_current = NULL;
 126                 return (DW_DLE_NO_ENTRY);
 127         }
 128
 129         ret = _dwarf_info_load(dbg, 0, 0, error);
 130         if (ret != DW_DLE_NONE)
 131                 return (ret);
 132
 133         dbg->dbg_tu_current = STAILQ_NEXT(dbg->dbg_tu_current, cu_next);
 134
 135         return (DW_DLE_NONE);
 136 }
 137
 138 int
 139 _dwarf_info_load(Dwarf_Debug dbg, Dwarf_Bool load_all, Dwarf_Bool is_info,
 140     Dwarf_Error *error)
 141 {
 142         Dwarf_CU cu;
 143         Dwarf_Section *ds;
 144         int dwarf_size, ret;
 145         uint64_t length;
 146         uint64_t next_offset;
 147         uint64_t offset;
 148
 149         ret = DW_DLE_NONE;
 150
 151         if (is_info) {
 152                 if (dbg->dbg_info_loaded)
 153                         return (ret);
 154                 offset = dbg->dbg_info_off;
 155                 ds = dbg->dbg_info_sec;
 156                 if (ds == NULL)
 157                         return (DW_DLE_NO_ENTRY);
 158         } else {
 159                 if (dbg->dbg_types_loaded)
 160                         return (ret);
 161                 offset = dbg->dbg_types_off;
 162                 ds = dbg->dbg_types_sec;
 163                 if (ds == NULL)
 164                         return (DW_DLE_NO_ENTRY);
 165         }
 166
 167         while (offset < ds->ds_size) {
 168                 if ((cu = calloc(1, sizeof(struct _Dwarf_CU))) == NULL) {
 169                         DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 170                         return (DW_DLE_MEMORY);
 171                 }
 172
 173                 cu->cu_dbg = dbg;
 174                 cu->cu_is_info = is_info;
 175                 cu->cu_offset = offset;
 176
 177                 length = dbg->read(ds->ds_data, &offset, 4);
 178                 if (length == 0xffffffff) {
 179                         length = dbg->read(ds->ds_data, &offset, 8);
 180                         dwarf_size = 8;
 181                 } else
 182                         dwarf_size = 4;
 183                 cu->cu_dwarf_size = dwarf_size;
 184
 185                 /*
 186                  * Check if there is enough ELF data for this CU. This assumes
 187                  * that libelf gives us the entire section in one Elf_Data
 188                  * object.
 189                  */
 190                 if (length > ds->ds_size - offset) {
 191                         free(cu);
 192                         DWARF_SET_ERROR(dbg, error, DW_DLE_CU_LENGTH_ERROR);
 193                         return (DW_DLE_CU_LENGTH_ERROR);
 194                 }
 195
 196                 /* Compute the offset to the next compilation unit: */
 197                 next_offset = offset + length;
 198                 if (is_info)
 199                         dbg->dbg_info_off = next_offset;
 200                 else
 201                         dbg->dbg_types_off = next_offset;
 202
 203                 /* Initialise the compilation unit. */
 204                 cu->cu_length            = length;
 205                 cu->cu_length_size       = (dwarf_size == 4 ? 4 : 12);
 206                 cu->cu_version           = dbg->read(ds->ds_data, &offset, 2);
 207                 cu->cu_abbrev_offset     = dbg->read(ds->ds_data, &offset,
 208                     dwarf_size);
 209                 cu->cu_abbrev_offset_cur = cu->cu_abbrev_offset;
 210                 cu->cu_pointer_size      = dbg->read(ds->ds_data, &offset, 1);
 211                 cu->cu_next_offset       = next_offset;
 212
 213                 /* .debug_types extra fields. */
 214                 if (!is_info) {
 215                         memcpy(cu->cu_type_sig.signature,
 216                             (char *) ds->ds_data + offset, 8);
 217                         offset += 8;
 218                         cu->cu_type_offset = dbg->read(ds->ds_data, &offset,
 219                             dwarf_size);
 220                 }
 221
 222                 /* Add the compilation unit to the list. */
 223                 if (is_info)
 224                         STAILQ_INSERT_TAIL(&dbg->dbg_cu, cu, cu_next);
 225                 else
 226                         STAILQ_INSERT_TAIL(&dbg->dbg_tu, cu, cu_next);
 227
 228                 if (cu->cu_version < 2 || cu->cu_version > 4) {
 229                         DWARF_SET_ERROR(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
 230                         ret = DW_DLE_VERSION_STAMP_ERROR;
 231                         break;
 232                 }
 233
 234                 cu->cu_1st_offset = offset;
 235
 236                 offset = next_offset;
 237
 238                 if (!load_all)
 239                         break;
 240         }
 241
 242         if (is_info) {
 243                 if ((Dwarf_Unsigned) dbg->dbg_info_off >= ds->ds_size)
 244                         dbg->dbg_info_loaded = 1;
 245         } else {
 246                 if ((Dwarf_Unsigned) dbg->dbg_types_off >= ds->ds_size)
 247                         dbg->dbg_types_loaded = 1;
 248         }
 249
 250         return (ret);
 251 }
 252
 253 void
 254 _dwarf_info_cleanup(Dwarf_Debug dbg)
 255 {
 256         Dwarf_CU cu, tcu;
 257
 258         assert(dbg != NULL && dbg->dbg_mode == DW_DLC_READ);
 259
 260         STAILQ_FOREACH_SAFE(cu, &dbg->dbg_cu, cu_next, tcu) {
 261                 STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
 262                 _dwarf_abbrev_cleanup(cu);
 263                 if (cu->cu_lineinfo != NULL) {
 264                         _dwarf_lineno_cleanup(cu->cu_lineinfo);
 265                         cu->cu_lineinfo = NULL;
 266                 }
 267                 free(cu);
 268         }
 269
 270         _dwarf_type_unit_cleanup(dbg);
 271 }
 272
 273 void
 274 _dwarf_type_unit_cleanup(Dwarf_Debug dbg)
 275 {
 276         Dwarf_CU cu, tcu;
 277
 278         assert(dbg != NULL && dbg->dbg_mode == DW_DLC_READ);
 279
 280         STAILQ_FOREACH_SAFE(cu, &dbg->dbg_tu, cu_next, tcu) {
 281                 STAILQ_REMOVE(&dbg->dbg_tu, cu, _Dwarf_CU, cu_next);
 282                 _dwarf_abbrev_cleanup(cu);
 283                 free(cu);
 284         }
 285 }
 286
 287 int
 288 _dwarf_info_gen(Dwarf_P_Debug dbg, Dwarf_Error *error)
 289 {
 290         Dwarf_P_Section ds;
 291         Dwarf_Rel_Section drs;
 292         Dwarf_Unsigned offset;
 293         Dwarf_CU cu;
 294         int ret;
 295
 296         assert(dbg != NULL && dbg->write_alloc != NULL);
 297
 298         if (dbg->dbgp_root_die == NULL)
 299                 return (DW_DLE_NONE);
 300
 301         /* Create the single CU for this debugging object. */
 302         if ((cu = calloc(1, sizeof(struct _Dwarf_CU))) == NULL) {
 303                 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
 304                 return (DW_DLE_MEMORY);
 305         }
 306         cu->cu_dbg = dbg;
 307         cu->cu_version = 2;     /* DWARF2 */
 308         cu->cu_pointer_size = dbg->dbg_pointer_size;
 309         STAILQ_INSERT_TAIL(&dbg->dbg_cu, cu, cu_next);
 310
 311         /* Create .debug_info section. */
 312         if ((ret = _dwarf_section_init(dbg, &dbg->dbgp_info, ".debug_info", 0,
 313             error)) != DW_DLE_NONE)
 314                 goto gen_fail1;
 315         ds = dbg->dbgp_info;
 316
 317         /* Create relocation section for .debug_init */
 318         if ((ret = _dwarf_reloc_section_init(dbg, &drs, ds, error)) !=
 319             DW_DLE_NONE)
 320                 goto gen_fail0;
 321
 322         /* Length placeholder. (We only use 32-bit DWARF format) */
 323         RCHECK(WRITE_VALUE(cu->cu_length, 4));
 324
 325         /* Write CU version */
 326         RCHECK(WRITE_VALUE(cu->cu_version, 2));
 327
 328         /*
 329          * Write abbrev offset. (always 0, we only support single CU)
 330          * Also generate a relocation entry for this offset.
 331          */
 332         RCHECK(_dwarf_reloc_entry_add(dbg, drs, ds, dwarf_drt_data_reloc, 4,
 333             ds->ds_size, 0, cu->cu_abbrev_offset, ".debug_abbrev", error));
 334
 335         /* Pointer size. */
 336         RCHECK(WRITE_VALUE(cu->cu_pointer_size, 1));
 337
 338         /* Transform the DIE(s) of this CU. */
 339         RCHECK(_dwarf_die_gen(dbg, cu, drs, error));
 340
 341         /* Now we can fill in the length of this CU. */
 342         cu->cu_length = ds->ds_size - 4;
 343         offset = 0;
 344         dbg->write(ds->ds_data, &offset, cu->cu_length, 4);
 345
 346         /* Inform application the creation of .debug_info ELF section. */
 347         RCHECK(_dwarf_section_callback(dbg, ds, SHT_PROGBITS, 0, 0, 0, error));
 348
 349         /*
 350          * Inform application the creation of relocation section for
 351          * .debug_info.
 352          */
 353         RCHECK(_dwarf_reloc_section_finalize(dbg, drs, error));
 354
 355         return (DW_DLE_NONE);
 356
 357 gen_fail:
 358         _dwarf_reloc_section_free(dbg, &drs);
 359
 360 gen_fail0:
 361         _dwarf_section_free(dbg, &dbg->dbgp_info);
 362
 363 gen_fail1:
 364         STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
 365         free(cu);
 366
 367         return (ret);
 368 }
 369
 370 void
 371 _dwarf_info_pro_cleanup(Dwarf_P_Debug dbg)
 372 {
 373         Dwarf_CU cu;
 374
 375         assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE);
 376
 377         cu = STAILQ_FIRST(&dbg->dbg_cu);
 378         if (cu != NULL) {
 379                 STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
 380                 _dwarf_abbrev_cleanup(cu);
 381                 free(cu);
 382         }
 383 }