libdw/dwarf_getmacros.c

   1 /* Get macro information.
   2    Copyright (C) 2002-2009, 2014, 2017, 2018 Red Hat, Inc.
   3    This file is part of elfutils.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of either
   7
   8      * the GNU Lesser General Public License as published by the Free
   9        Software Foundation; either version 3 of the License, or (at
  10        your option) any later version
  11
  12    or
  13
  14      * the GNU General Public License as published by the Free
  15        Software Foundation; either version 2 of the License, or (at
  16        your option) any later version
  17
  18    or both in parallel, as here.
  19
  20    elfutils is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received copies of the GNU General Public License and
  26    the GNU Lesser General Public License along with this program.  If
  27    not, see <http://www.gnu.org/licenses/>.  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include <config.h>
  31 #endif
  32
  33 #include <assert.h>
  34 #include <dwarf.h>
  35 #include <search.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include <libdwP.h>
  40
  41 static int
  42 get_offset_from (Dwarf_Die *die, int name, Dwarf_Word *retp)
  43 {
  44   /* Get the appropriate attribute.  */
  45   Dwarf_Attribute attr;
  46   if (INTUSE(dwarf_attr) (die, name, &attr) == NULL)
  47     return -1;
  48
  49   /* Offset into the corresponding section.  */
  50   return INTUSE(dwarf_formudata) (&attr, retp);
  51 }
  52
  53 static int
  54 macro_op_compare (const void *p1, const void *p2)
  55 {
  56   const Dwarf_Macro_Op_Table *t1 = (const Dwarf_Macro_Op_Table *) p1;
  57   const Dwarf_Macro_Op_Table *t2 = (const Dwarf_Macro_Op_Table *) p2;
  58
  59   if (t1->offset < t2->offset)
  60     return -1;
  61   if (t1->offset > t2->offset)
  62     return 1;
  63
  64   if (t1->sec_index < t2->sec_index)
  65     return -1;
  66   if (t1->sec_index > t2->sec_index)
  67     return 1;
  68
  69   return 0;
  70 }
  71
  72 static void
  73 build_table (Dwarf_Macro_Op_Table *table,
  74              Dwarf_Macro_Op_Proto op_protos[static 255])
  75 {
  76   unsigned ct = 0;
  77   for (unsigned i = 1; i < 256; ++i)
  78     if (op_protos[i - 1].forms != NULL)
  79       table->table[table->opcodes[i - 1] = ct++] = op_protos[i - 1];
  80     else
  81       table->opcodes[i - 1] = 0xff;
  82 }
  83
  84 #define MACRO_PROTO(NAME, ...)                                  \
  85   Dwarf_Macro_Op_Proto NAME = ({                                \
  86       static const uint8_t proto[] = {__VA_ARGS__};             \
  87       (Dwarf_Macro_Op_Proto) {sizeof proto, proto};             \
  88     })
  89
  90 enum { macinfo_data_size = offsetof (Dwarf_Macro_Op_Table, table[5]) };
  91 static unsigned char macinfo_data[macinfo_data_size]
  92         __attribute__ ((aligned (__alignof (Dwarf_Macro_Op_Table))));
  93
  94 static __attribute__ ((constructor)) void
  95 init_macinfo_table (void)
  96 {
  97   MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
  98   MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
  99   MACRO_PROTO (p_none);
 100
 101   Dwarf_Macro_Op_Proto op_protos[255] =
 102     {
 103       [DW_MACINFO_define - 1] = p_udata_str,
 104       [DW_MACINFO_undef - 1] = p_udata_str,
 105       [DW_MACINFO_vendor_ext - 1] = p_udata_str,
 106       [DW_MACINFO_start_file - 1] = p_udata_udata,
 107       [DW_MACINFO_end_file - 1] = p_none,
 108       /* If you are adding more elements to this array, increase
 109          MACINFO_DATA_SIZE above.  */
 110     };
 111
 112   Dwarf_Macro_Op_Table *macinfo_table = (void *) macinfo_data;
 113   memset (macinfo_table, 0, sizeof macinfo_data);
 114   build_table (macinfo_table, op_protos);
 115   macinfo_table->sec_index = IDX_debug_macinfo;
 116 }
 117
 118 static Dwarf_Macro_Op_Table *
 119 get_macinfo_table (Dwarf *dbg, Dwarf_Word macoff, Dwarf_Die *cudie)
 120 {
 121   assert (cudie != NULL);
 122
 123   Dwarf_Attribute attr_mem, *attr
 124     = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
 125   Dwarf_Off line_offset = (Dwarf_Off) -1;
 126   if (attr != NULL)
 127     if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
 128       return NULL;
 129
 130   Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
 131                                              macinfo_data_size, 1);
 132   memcpy (table, macinfo_data, macinfo_data_size);
 133
 134   table->offset = macoff;
 135   table->sec_index = IDX_debug_macinfo;
 136   table->line_offset = line_offset;
 137   table->is_64bit = cudie->cu->address_size == 8;
 138   table->comp_dir = __libdw_getcompdir (cudie);
 139
 140   return table;
 141 }
 142
 143 static Dwarf_Macro_Op_Table *
 144 get_table_for_offset (Dwarf *dbg, Dwarf_Word macoff,
 145                       const unsigned char *readp,
 146                       const unsigned char *const endp,
 147                       Dwarf_Die *cudie)
 148 {
 149   const unsigned char *startp = readp;
 150
 151   /* Request at least 3 bytes for header.  */
 152   if (readp + 3 > endp)
 153     {
 154     invalid_dwarf:
 155       __libdw_seterrno (DWARF_E_INVALID_DWARF);
 156       return NULL;
 157     }
 158
 159   uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
 160   if (version != 4 && version != 5)
 161     {
 162       __libdw_seterrno (DWARF_E_INVALID_VERSION);
 163       return NULL;
 164     }
 165
 166   uint8_t flags = *readp++;
 167   bool is_64bit = (flags & 0x1) != 0;
 168
 169   Dwarf_Off line_offset = (Dwarf_Off) -1;
 170   if ((flags & 0x2) != 0)
 171     {
 172       line_offset = read_addr_unaligned_inc (is_64bit ? 8 : 4, dbg, readp);
 173       if (readp > endp)
 174         goto invalid_dwarf;
 175     }
 176   else if (cudie != NULL)
 177     {
 178       Dwarf_Attribute attr_mem, *attr
 179         = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
 180       if (attr != NULL)
 181         if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
 182           return NULL;
 183     }
 184
 185   /* """The macinfo entry types defined in this standard may, but
 186      might not, be described in the table""".
 187
 188      I.e. these may be present.  It's tempting to simply skip them,
 189      but it's probably more correct to tolerate that a producer tweaks
 190      the way certain opcodes are encoded, for whatever reasons.  */
 191
 192   MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
 193   MACRO_PROTO (p_udata_strp, DW_FORM_udata, DW_FORM_strp);
 194   MACRO_PROTO (p_udata_strsup, DW_FORM_udata, DW_FORM_strp_sup);
 195   MACRO_PROTO (p_udata_strx, DW_FORM_udata, DW_FORM_strx);
 196   MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
 197   MACRO_PROTO (p_secoffset, DW_FORM_sec_offset);
 198   MACRO_PROTO (p_none);
 199
 200   Dwarf_Macro_Op_Proto op_protos[255] =
 201     {
 202       [DW_MACRO_define - 1] = p_udata_str,
 203       [DW_MACRO_undef - 1] = p_udata_str,
 204       [DW_MACRO_define_strp - 1] = p_udata_strp,
 205       [DW_MACRO_undef_strp - 1] = p_udata_strp,
 206       [DW_MACRO_start_file - 1] = p_udata_udata,
 207       [DW_MACRO_end_file - 1] = p_none,
 208       [DW_MACRO_import - 1] = p_secoffset,
 209       [DW_MACRO_define_sup - 1] = p_udata_strsup,
 210       [DW_MACRO_undef_sup - 1] = p_udata_strsup,
 211       [DW_MACRO_import_sup - 1] = p_secoffset, /* XXX - but in sup!. */
 212       [DW_MACRO_define_strx - 1] = p_udata_strx,
 213       [DW_MACRO_undef_strx - 1] = p_udata_strx,
 214     };
 215
 216   if ((flags & 0x4) != 0)
 217     {
 218       unsigned count = *readp++;
 219       for (unsigned i = 0; i < count; ++i)
 220         {
 221           unsigned opcode = *readp++;
 222
 223           Dwarf_Macro_Op_Proto e;
 224           if (readp >= endp)
 225             goto invalid;
 226           get_uleb128 (e.nforms, readp, endp);
 227           e.forms = readp;
 228           op_protos[opcode - 1] = e;
 229
 230           readp += e.nforms;
 231           if (readp > endp)
 232             {
 233             invalid:
 234               __libdw_seterrno (DWARF_E_INVALID_DWARF);
 235               return NULL;
 236             }
 237         }
 238     }
 239
 240   size_t ct = 0;
 241   for (unsigned i = 1; i < 256; ++i)
 242     if (op_protos[i - 1].forms != NULL)
 243       ++ct;
 244
 245   /* We support at most 0xfe opcodes defined in the table, as 0xff is
 246      a value that means that given opcode is not stored at all.  But
 247      that should be fine, as opcode 0 is not allocated.  */
 248   assert (ct < 0xff);
 249
 250   size_t macop_table_size = offsetof (Dwarf_Macro_Op_Table, table[ct]);
 251
 252   Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
 253                                              macop_table_size, 1);
 254
 255   *table = (Dwarf_Macro_Op_Table) {
 256     .offset = macoff,
 257     .sec_index = IDX_debug_macro,
 258     .line_offset = line_offset,
 259     .header_len = readp - startp,
 260     .version = version,
 261     .is_64bit = is_64bit,
 262
 263     /* NULL if CUDIE is NULL or DW_AT_comp_dir is absent.  */
 264     .comp_dir = __libdw_getcompdir (cudie),
 265   };
 266   build_table (table, op_protos);
 267
 268   return table;
 269 }
 270
 271 static Dwarf_Macro_Op_Table *
 272 cache_op_table (Dwarf *dbg, int sec_index, Dwarf_Off macoff,
 273                 const unsigned char *startp,
 274                 const unsigned char *const endp,
 275                 Dwarf_Die *cudie)
 276 {
 277   Dwarf_Macro_Op_Table fake = { .offset = macoff, .sec_index = sec_index };
 278   Dwarf_Macro_Op_Table **found = tfind (&fake, &dbg->macro_ops,
 279                                         macro_op_compare);
 280   if (found != NULL)
 281     return *found;
 282
 283   Dwarf_Macro_Op_Table *table = sec_index == IDX_debug_macro
 284     ? get_table_for_offset (dbg, macoff, startp, endp, cudie)
 285     : get_macinfo_table (dbg, macoff, cudie);
 286
 287   if (table == NULL)
 288     return NULL;
 289
 290   Dwarf_Macro_Op_Table **ret = tsearch (table, &dbg->macro_ops,
 291                                         macro_op_compare);
 292   if (unlikely (ret == NULL))
 293     {
 294       __libdw_seterrno (DWARF_E_NOMEM);
 295       return NULL;
 296     }
 297
 298   return *ret;
 299 }
 300
 301 static ptrdiff_t
 302 read_macros (Dwarf *dbg, int sec_index,
 303              Dwarf_Off macoff, int (*callback) (Dwarf_Macro *, void *),
 304              void *arg, ptrdiff_t offset, bool accept_0xff,
 305              Dwarf_Die *cudie)
 306 {
 307   Elf_Data *d = dbg->sectiondata[sec_index];
 308   if (unlikely (d == NULL || d->d_buf == NULL))
 309     {
 310       __libdw_seterrno (DWARF_E_NO_ENTRY);
 311       return -1;
 312     }
 313
 314   if (unlikely (macoff >= d->d_size))
 315     {
 316       __libdw_seterrno (DWARF_E_INVALID_DWARF);
 317       return -1;
 318     }
 319
 320   const unsigned char *const startp = d->d_buf + macoff;
 321   const unsigned char *const endp = d->d_buf + d->d_size;
 322
 323   Dwarf_Macro_Op_Table *table = cache_op_table (dbg, sec_index, macoff,
 324                                                 startp, endp, cudie);
 325   if (table == NULL)
 326     return -1;
 327
 328   if (offset == 0)
 329     offset = table->header_len;
 330
 331   assert (offset >= 0);
 332   assert (offset < endp - startp);
 333   const unsigned char *readp = startp + offset;
 334
 335   while (readp < endp)
 336     {
 337       unsigned int opcode = *readp++;
 338       if (opcode == 0)
 339         /* Nothing more to do.  */
 340         return 0;
 341
 342       if (unlikely (opcode == 0xff && ! accept_0xff))
 343         {
 344           /* See comment below at dwarf_getmacros for explanation of
 345              why we are doing this.  */
 346           __libdw_seterrno (DWARF_E_INVALID_OPCODE);
 347           return -1;
 348         }
 349
 350       unsigned int idx = table->opcodes[opcode - 1];
 351       if (idx == 0xff)
 352         {
 353           __libdw_seterrno (DWARF_E_INVALID_OPCODE);
 354           return -1;
 355         }
 356
 357       Dwarf_Macro_Op_Proto *proto = &table->table[idx];
 358
 359       /* A fake CU with bare minimum data to fool dwarf_formX into
 360          doing the right thing with the attributes that we put out.
 361          We pretend it is the same version as the actual table.
 362          Version 4 for the old GNU extension, version 5 for DWARF5.
 363          To handle DW_FORM_strx[1234] we set the .str_offsets_base
 364          from the given CU.
 365          XXX We will need to deal with DW_MACRO_import_sup and change
 366          out the dbg somehow for the DW_FORM_sec_offset to make sense.  */
 367       Dwarf_CU fake_cu = {
 368         .dbg = dbg,
 369         .sec_idx = sec_index,
 370         .version = table->version,
 371         .offset_size = table->is_64bit ? 8 : 4,
 372         .str_off_base = str_offsets_base_off (dbg, (cudie != NULL
 373                                                     ? cudie->cu: NULL)),
 374         .startp = (void *) startp + offset,
 375         .endp = (void *) endp,
 376       };
 377
 378       Dwarf_Attribute *attributes;
 379       Dwarf_Attribute *attributesp = NULL;
 380       Dwarf_Attribute nattributes[8];
 381       if (unlikely (proto->nforms > 8))
 382         {
 383           attributesp = malloc (sizeof (Dwarf_Attribute) * proto->nforms);
 384           if (attributesp == NULL)
 385             {
 386               __libdw_seterrno (DWARF_E_NOMEM);
 387               return -1;
 388             }
 389           attributes = attributesp;
 390         }
 391       else
 392         attributes = &nattributes[0];
 393
 394       for (Dwarf_Word i = 0; i < proto->nforms; ++i)
 395         {
 396           /* We pretend this is a DW_AT[_GNU]_macros attribute so that
 397              DW_FORM_sec_offset forms get correctly interpreted as
 398              offset into .debug_macro.  XXX Deal with DW_MACRO_import_sup
 399              (swap .dbg) for DW_FORM_sec_offset? */
 400           attributes[i].code = (fake_cu.version == 4 ? DW_AT_GNU_macros
 401                                                      : DW_AT_macros);
 402           attributes[i].form = proto->forms[i];
 403           attributes[i].valp = (void *) readp;
 404           attributes[i].cu = &fake_cu;
 405
 406           /* We don't want forms that aren't allowed because they could
 407              read from the "abbrev" like DW_FORM_implicit_const.  */
 408           if (! libdw_valid_user_form (attributes[i].form))
 409             {
 410               __libdw_seterrno (DWARF_E_INVALID_DWARF);
 411               free (attributesp);
 412               return -1;
 413             }
 414
 415           size_t len = __libdw_form_val_len (&fake_cu, proto->forms[i], readp);
 416           if (unlikely (len == (size_t) -1))
 417             {
 418               free (attributesp);
 419               return -1;
 420             }
 421
 422           readp += len;
 423         }
 424
 425       Dwarf_Macro macro = {
 426         .table = table,
 427         .opcode = opcode,
 428         .attributes = attributes,
 429       };
 430
 431       int res = callback (&macro, arg);
 432       if (unlikely (attributesp != NULL))
 433         free (attributesp);
 434
 435       if (res != DWARF_CB_OK)
 436         return readp - startp;
 437     }
 438
 439   return 0;
 440 }
 441
 442 /* Token layout:
 443
 444    - The highest bit is used for distinguishing between callers that
 445      know that opcode 0xff may have one of two incompatible meanings.
 446      The mask that we use for selecting this bit is
 447      DWARF_GETMACROS_START.
 448
 449    - The rest of the token (31 or 63 bits) encodes address inside the
 450      macro unit.
 451
 452    Besides, token value of 0 signals end of iteration and -1 is
 453    reserved for signaling errors.  That means it's impossible to
 454    represent maximum offset of a .debug_macro unit to new-style
 455    callers (which in practice decreases the permissible macro unit
 456    size by another 1 byte).  */
 457
 458 static ptrdiff_t
 459 token_from_offset (ptrdiff_t offset, bool accept_0xff)
 460 {
 461   if (offset == -1 || offset == 0)
 462     return offset;
 463
 464   /* Make sure the offset didn't overflow into the flag bit.  */
 465   if ((offset & DWARF_GETMACROS_START) != 0)
 466     {
 467       __libdw_seterrno (DWARF_E_TOO_BIG);
 468       return -1;
 469     }
 470
 471   if (accept_0xff)
 472     offset |= DWARF_GETMACROS_START;
 473
 474   return offset;
 475 }
 476
 477 static ptrdiff_t
 478 offset_from_token (ptrdiff_t token, bool *accept_0xffp)
 479 {
 480   *accept_0xffp = (token & DWARF_GETMACROS_START) != 0;
 481   token &= ~DWARF_GETMACROS_START;
 482
 483   return token;
 484 }
 485
 486 static ptrdiff_t
 487 gnu_macros_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 488                           int (*callback) (Dwarf_Macro *, void *),
 489                           void *arg, ptrdiff_t offset, bool accept_0xff,
 490                           Dwarf_Die *cudie)
 491 {
 492   assert (offset >= 0);
 493
 494   if (macoff >= dbg->sectiondata[IDX_debug_macro]->d_size)
 495     {
 496       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 497       return -1;
 498     }
 499
 500   return read_macros (dbg, IDX_debug_macro, macoff,
 501                       callback, arg, offset, accept_0xff, cudie);
 502 }
 503
 504 static ptrdiff_t
 505 macro_info_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 506                           int (*callback) (Dwarf_Macro *, void *),
 507                           void *arg, ptrdiff_t offset, Dwarf_Die *cudie)
 508 {
 509   assert (offset >= 0);
 510
 511   return read_macros (dbg, IDX_debug_macinfo, macoff,
 512                       callback, arg, offset, true, cudie);
 513 }
 514
 515 ptrdiff_t
 516 dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 517                      int (*callback) (Dwarf_Macro *, void *),
 518                      void *arg, ptrdiff_t token)
 519 {
 520   if (dbg == NULL)
 521     {
 522       __libdw_seterrno (DWARF_E_NO_DWARF);
 523       return -1;
 524     }
 525
 526   bool accept_0xff;
 527   ptrdiff_t offset = offset_from_token (token, &accept_0xff);
 528   assert (accept_0xff);
 529
 530   offset = gnu_macros_getmacros_off (dbg, macoff, callback, arg, offset,
 531                                      accept_0xff, NULL);
 532
 533   return token_from_offset (offset, accept_0xff);
 534 }
 535
 536 ptrdiff_t
 537 dwarf_getmacros (Dwarf_Die *cudie, int (*callback) (Dwarf_Macro *, void *),
 538                  void *arg, ptrdiff_t token)
 539 {
 540   if (cudie == NULL)
 541     {
 542       __libdw_seterrno (DWARF_E_NO_DWARF);
 543       return -1;
 544     }
 545
 546   /* This function might be called from a code that expects to see
 547      DW_MACINFO_* opcodes, not DW_MACRO_{GNU_,}* ones.  It is fine to
 548      serve most DW_MACRO_{GNU_,}* opcodes to such code, because those
 549      whose values are the same as DW_MACINFO_* ones also have the same
 550      behavior.  It is not very likely that a .debug_macro section
 551      would only use the part of opcode space that it shares with
 552      .debug_macinfo, but it is possible.  Serving the opcodes that are
 553      only valid in DW_MACRO_{GNU_,}* domain is OK as well, because
 554      clients in general need to be ready that newer standards define
 555      more opcodes, and have coping mechanisms for unfamiliar opcodes.
 556
 557      The one exception to the above rule is opcode 0xff, which has
 558      concrete semantics in .debug_macinfo, but falls into vendor block
 559      in .debug_macro, and can be assigned to do whatever.  There is
 560      some small probability that the two opcodes would look
 561      superficially similar enough that a client would be confused and
 562      misbehave as a result.  For this reason, we refuse to serve
 563      through this interface 0xff's originating from .debug_macro
 564      unless the TOKEN that we obtained indicates the call originates
 565      from a new-style caller.  See above for details on what
 566      information is encoded into tokens.  */
 567
 568   bool accept_0xff;
 569   ptrdiff_t offset = offset_from_token (token, &accept_0xff);
 570
 571   /* DW_AT_macro_info */
 572   if (dwarf_hasattr (cudie, DW_AT_macro_info))
 573     {
 574       Dwarf_Word macoff;
 575       if (get_offset_from (cudie, DW_AT_macro_info, &macoff) != 0)
 576         return -1;
 577       offset = macro_info_getmacros_off (cudie->cu->dbg, macoff,
 578                                          callback, arg, offset, cudie);
 579     }
 580   else
 581     {
 582       /* DW_AT_GNU_macros, DW_AT_macros */
 583       Dwarf_Word macoff;
 584       if (get_offset_from (cudie, DW_AT_GNU_macros, &macoff) != 0
 585           && get_offset_from (cudie, DW_AT_macros, &macoff) != 0)
 586         return -1;
 587       offset = gnu_macros_getmacros_off (cudie->cu->dbg, macoff,
 588                                          callback, arg, offset, accept_0xff,
 589                                          cudie);
 590     }
 591
 592   return token_from_offset (offset, accept_0xff);
 593 }