bfd/elf-attrs.c

   1 /* ELF attributes support (based on ARM EABI attributes).
   2    Copyright 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libiberty.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27
  28 /* Return the number of bytes needed by I in uleb128 format.  */
  29 static int
  30 uleb128_size (unsigned int i)
  31 {
  32   int size;
  33   size = 1;
  34   while (i >= 0x80)
  35     {
  36       i >>= 7;
  37       size++;
  38     }
  39   return size;
  40 }
  41
  42 /* Return TRUE if the attribute has the default value (0/"").  */
  43 static bfd_boolean
  44 is_default_attr (obj_attribute *attr)
  45 {
  46   if ((attr->type & 1) && attr->i != 0)
  47     return FALSE;
  48   if ((attr->type & 2) && attr->s && *attr->s)
  49     return FALSE;
  50
  51   return TRUE;
  52 }
  53
  54 /* Return the size of a single attribute.  */
  55 static bfd_vma
  56 obj_attr_size (int tag, obj_attribute *attr)
  57 {
  58   bfd_vma size;
  59
  60   if (is_default_attr (attr))
  61     return 0;
  62
  63   size = uleb128_size (tag);
  64   if (attr->type & 1)
  65     size += uleb128_size (attr->i);
  66   if (attr->type & 2)
  67     size += strlen ((char *)attr->s) + 1;
  68   return size;
  69 }
  70
  71 /* Return the vendor name for a given object attributes section.  */
  72 static const char *
  73 vendor_obj_attr_name (bfd *abfd, int vendor)
  74 {
  75   return (vendor == OBJ_ATTR_PROC
  76           ? get_elf_backend_data (abfd)->obj_attrs_vendor
  77           : "gnu");
  78 }
  79
  80 /* Return the size of the object attributes section for VENDOR
  81    (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes
  82    for that vendor to record and the vendor is OBJ_ATTR_GNU.  */
  83 static bfd_vma
  84 vendor_obj_attr_size (bfd *abfd, int vendor)
  85 {
  86   bfd_vma size;
  87   obj_attribute *attr;
  88   obj_attribute_list *list;
  89   int i;
  90   const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
  91
  92   if (!vendor_name)
  93     return 0;
  94
  95   attr = elf_known_obj_attributes (abfd)[vendor];
  96   size = 0;
  97   for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
  98     size += obj_attr_size (i, &attr[i]);
  99
 100   for (list = elf_other_obj_attributes (abfd)[vendor];
 101        list;
 102        list = list->next)
 103     size += obj_attr_size (list->tag, &list->attr);
 104
 105   /* <size> <vendor_name> NUL 0x1 <size> */
 106   return ((size || vendor == OBJ_ATTR_PROC)
 107           ? size + 10 + strlen (vendor_name)
 108           : 0);
 109 }
 110
 111 /* Return the size of the object attributes section.  */
 112 bfd_vma
 113 bfd_elf_obj_attr_size (bfd *abfd)
 114 {
 115   bfd_vma size;
 116
 117   size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
 118   size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);
 119
 120   /* 'A' <sections for each vendor> */
 121   return (size ? size + 1 : 0);
 122 }
 123
 124 /* Write VAL in uleb128 format to P, returning a pointer to the
 125    following byte.  */
 126 static bfd_byte *
 127 write_uleb128 (bfd_byte *p, unsigned int val)
 128 {
 129   bfd_byte c;
 130   do
 131     {
 132       c = val & 0x7f;
 133       val >>= 7;
 134       if (val)
 135         c |= 0x80;
 136       *(p++) = c;
 137     }
 138   while (val);
 139   return p;
 140 }
 141
 142 /* Write attribute ATTR to butter P, and return a pointer to the following
 143    byte.  */
 144 static bfd_byte *
 145 write_obj_attribute (bfd_byte *p, int tag, obj_attribute *attr)
 146 {
 147   /* Suppress default entries.  */
 148   if (is_default_attr (attr))
 149     return p;
 150
 151   p = write_uleb128 (p, tag);
 152   if (attr->type & 1)
 153     p = write_uleb128 (p, attr->i);
 154   if (attr->type & 2)
 155     {
 156       int len;
 157
 158       len = strlen (attr->s) + 1;
 159       memcpy (p, attr->s, len);
 160       p += len;
 161     }
 162
 163   return p;
 164 }
 165
 166 /* Write the contents of the object attributes section (length SIZE)
 167    for VENDOR to CONTENTS.  */
 168 static void
 169 vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
 170                               int vendor)
 171 {
 172   bfd_byte *p;
 173   obj_attribute *attr;
 174   obj_attribute_list *list;
 175   int i;
 176   const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
 177   size_t vendor_length = strlen (vendor_name) + 1;
 178
 179   p = contents;
 180   bfd_put_32 (abfd, size, p);
 181   p += 4;
 182   memcpy (p, vendor_name, vendor_length);
 183   p += vendor_length;
 184   *(p++) = Tag_File;
 185   bfd_put_32 (abfd, size - 4 - vendor_length, p);
 186   p += 4;
 187
 188   attr = elf_known_obj_attributes (abfd)[vendor];
 189   for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
 190     p = write_obj_attribute (p, i, &attr[i]);
 191
 192   for (list = elf_other_obj_attributes (abfd)[vendor];
 193        list;
 194        list = list->next)
 195     p = write_obj_attribute (p, list->tag, &list->attr);
 196 }
 197
 198 /* Write the contents of the object attributes section to CONTENTS.  */
 199 void
 200 bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
 201 {
 202   bfd_byte *p;
 203   int vendor;
 204   bfd_vma my_size;
 205
 206   p = contents;
 207   *(p++) = 'A';
 208   my_size = 1;
 209   for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
 210     {
 211       bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
 212       if (vendor_size)
 213         vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
 214       p += vendor_size;
 215       my_size += vendor_size;
 216     }
 217
 218   if (size != my_size)
 219     abort ();
 220 }
 221
 222 /* Allocate/find an object attribute.  */
 223 static obj_attribute *
 224 elf_new_obj_attr (bfd *abfd, int vendor, int tag)
 225 {
 226   obj_attribute *attr;
 227   obj_attribute_list *list;
 228   obj_attribute_list *p;
 229   obj_attribute_list **lastp;
 230
 231
 232   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
 233     {
 234       /* Knwon tags are preallocated.  */
 235       attr = &elf_known_obj_attributes (abfd)[vendor][tag];
 236     }
 237   else
 238     {
 239       /* Create a new tag.  */
 240       list = (obj_attribute_list *)
 241         bfd_alloc (abfd, sizeof (obj_attribute_list));
 242       memset (list, 0, sizeof (obj_attribute_list));
 243       list->tag = tag;
 244       /* Keep the tag list in order.  */
 245       lastp = &elf_other_obj_attributes (abfd)[vendor];
 246       for (p = *lastp; p; p = p->next)
 247         {
 248           if (tag < p->tag)
 249             break;
 250           lastp = &p->next;
 251         }
 252       list->next = *lastp;
 253       *lastp = list;
 254       attr = &list->attr;
 255     }
 256
 257   return attr;
 258 }
 259
 260 /* Return the value of an integer object attribute.  */
 261 int
 262 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag)
 263 {
 264   obj_attribute_list *p;
 265
 266   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
 267     {
 268       /* Knwon tags are preallocated.  */
 269       return elf_known_obj_attributes (abfd)[vendor][tag].i;
 270     }
 271   else
 272     {
 273       for (p = elf_other_obj_attributes (abfd)[vendor];
 274            p;
 275            p = p->next)
 276         {
 277           if (tag == p->tag)
 278             return p->attr.i;
 279           if (tag < p->tag)
 280             break;
 281         }
 282       return 0;
 283     }
 284 }
 285
 286 /* Add an integer object attribute.  */
 287 void
 288 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i)
 289 {
 290   obj_attribute *attr;
 291
 292   attr = elf_new_obj_attr (abfd, vendor, tag);
 293   attr->type = 1;
 294   attr->i = i;
 295 }
 296
 297 /* Duplicate an object attribute string value.  */
 298 char *
 299 _bfd_elf_attr_strdup (bfd *abfd, const char * s)
 300 {
 301   char * p;
 302   int len;
 303
 304   len = strlen (s) + 1;
 305   p = (char *) bfd_alloc (abfd, len);
 306   return memcpy (p, s, len);
 307 }
 308
 309 /* Add a string object attribute.  */
 310 void
 311 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, int tag, const char *s)
 312 {
 313   obj_attribute *attr;
 314
 315   attr = elf_new_obj_attr (abfd, vendor, tag);
 316   attr->type = 2;
 317   attr->s = _bfd_elf_attr_strdup (abfd, s);
 318 }
 319
 320 /* Add a Tag_compatibility object attribute.  */
 321 void
 322 bfd_elf_add_obj_attr_compat (bfd *abfd, int vendor, unsigned int i,
 323                              const char *s)
 324 {
 325   obj_attribute_list *list;
 326   obj_attribute_list *p;
 327   obj_attribute_list **lastp;
 328
 329   list = (obj_attribute_list *)
 330     bfd_alloc (abfd, sizeof (obj_attribute_list));
 331   memset (list, 0, sizeof (obj_attribute_list));
 332   list->tag = Tag_compatibility;
 333   list->attr.type = 3;
 334   list->attr.i = i;
 335   list->attr.s = _bfd_elf_attr_strdup (abfd, s);
 336
 337   lastp = &elf_other_obj_attributes (abfd)[vendor];
 338   for (p = *lastp; p; p = p->next)
 339     {
 340       int cmp;
 341       if (p->tag != Tag_compatibility)
 342         break;
 343       cmp = strcmp(s, p->attr.s);
 344       if (cmp < 0 || (cmp == 0 && i < p->attr.i))
 345         break;
 346       lastp = &p->next;
 347     }
 348   list->next = *lastp;
 349   *lastp = list;
 350 }
 351
 352 /* Copy the object attributes from IBFD to OBFD.  */
 353 void
 354 _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
 355 {
 356   obj_attribute *in_attr;
 357   obj_attribute *out_attr;
 358   obj_attribute_list *list;
 359   int i;
 360   int vendor;
 361
 362   for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
 363     {
 364       in_attr = &elf_known_obj_attributes (ibfd)[vendor][4];
 365       out_attr = &elf_known_obj_attributes (obfd)[vendor][4];
 366       for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
 367         {
 368           out_attr->type = in_attr->type;
 369           out_attr->i = in_attr->i;
 370           if (in_attr->s && *in_attr->s)
 371             out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
 372           in_attr++;
 373           out_attr++;
 374         }
 375
 376       for (list = elf_other_obj_attributes (ibfd)[vendor];
 377            list;
 378            list = list->next)
 379         {
 380           in_attr = &list->attr;
 381           switch (in_attr->type)
 382             {
 383             case 1:
 384               bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
 385               break;
 386             case 2:
 387               bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
 388                                            in_attr->s);
 389               break;
 390             case 3:
 391               bfd_elf_add_obj_attr_compat (obfd, vendor, in_attr->i,
 392                                            in_attr->s);
 393               break;
 394             default:
 395               abort ();
 396             }
 397         }
 398     }
 399 }
 400
 401 /* Determine whether a GNU object attribute tag takes an integer, a
 402    string or both.  */
 403 static int
 404 gnu_obj_attrs_arg_type (int tag)
 405 {
 406   /* Except for Tag_compatibility, for GNU attributes we follow the
 407      same rule ARM ones > 32 follow: odd-numbered tags take strings
 408      and even-numbered tags take integers.  In addition, tag & 2 is
 409      nonzero for architecture-independent tags and zero for
 410      architecture-dependent ones.  */
 411   if (tag == Tag_compatibility)
 412     return 3;
 413   else
 414     return (tag & 1) != 0 ? 2 : 1;
 415 }
 416
 417 /* Determine what arguments an attribute tag takes.  */
 418 int
 419 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
 420 {
 421   switch (vendor)
 422     {
 423     case OBJ_ATTR_PROC:
 424       return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
 425       break;
 426     case OBJ_ATTR_GNU:
 427       return gnu_obj_attrs_arg_type (tag);
 428       break;
 429     default:
 430       abort ();
 431     }
 432 }
 433
 434 /* Parse an object attributes section.  */
 435 void
 436 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
 437 {
 438   bfd_byte *contents;
 439   bfd_byte *p;
 440   bfd_vma len;
 441   const char *std_section;
 442
 443   contents = bfd_malloc (hdr->sh_size);
 444   if (!contents)
 445     return;
 446   if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
 447                                  hdr->sh_size))
 448     {
 449       free (contents);
 450       return;
 451     }
 452   p = contents;
 453   std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
 454   if (*(p++) == 'A')
 455     {
 456       len = hdr->sh_size - 1;
 457       while (len > 0)
 458         {
 459           int namelen;
 460           bfd_vma section_len;
 461           int vendor;
 462
 463           section_len = bfd_get_32 (abfd, p);
 464           p += 4;
 465           if (section_len > len)
 466             section_len = len;
 467           len -= section_len;
 468           namelen = strlen ((char *)p) + 1;
 469           section_len -= namelen + 4;
 470           if (std_section && strcmp ((char *)p, std_section) == 0)
 471             vendor = OBJ_ATTR_PROC;
 472           else if (strcmp ((char *)p, "gnu") == 0)
 473             vendor = OBJ_ATTR_GNU;
 474           else
 475             {
 476               /* Other vendor section.  Ignore it.  */
 477               p += namelen + section_len;
 478               continue;
 479             }
 480
 481           p += namelen;
 482           while (section_len > 0)
 483             {
 484               int tag;
 485               unsigned int n;
 486               unsigned int val;
 487               bfd_vma subsection_len;
 488               bfd_byte *end;
 489
 490               tag = read_unsigned_leb128 (abfd, p, &n);
 491               p += n;
 492               subsection_len = bfd_get_32 (abfd, p);
 493               p += 4;
 494               if (subsection_len > section_len)
 495                 subsection_len = section_len;
 496               section_len -= subsection_len;
 497               subsection_len -= n + 4;
 498               end = p + subsection_len;
 499               switch (tag)
 500                 {
 501                 case Tag_File:
 502                   while (p < end)
 503                     {
 504                       int type;
 505
 506                       tag = read_unsigned_leb128 (abfd, p, &n);
 507                       p += n;
 508                       type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
 509                       switch (type)
 510                         {
 511                         case 3:
 512                           val = read_unsigned_leb128 (abfd, p, &n);
 513                           p += n;
 514                           bfd_elf_add_obj_attr_compat (abfd, vendor, val,
 515                                                        (char *)p);
 516                           p += strlen ((char *)p) + 1;
 517                           break;
 518                         case 2:
 519                           bfd_elf_add_obj_attr_string (abfd, vendor, tag,
 520                                                        (char *)p);
 521                           p += strlen ((char *)p) + 1;
 522                           break;
 523                         case 1:
 524                           val = read_unsigned_leb128 (abfd, p, &n);
 525                           p += n;
 526                           bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
 527                           break;
 528                         default:
 529                           abort ();
 530                         }
 531                     }
 532                   break;
 533                 case Tag_Section:
 534                 case Tag_Symbol:
 535                   /* Don't have anywhere convenient to attach these.
 536                      Fall through for now.  */
 537                 default:
 538                   /* Ignore things we don't kow about.  */
 539                   p += subsection_len;
 540                   subsection_len = 0;
 541                   break;
 542                 }
 543             }
 544         }
 545     }
 546   free (contents);
 547 }
 548
 549 /* Merge common object attributes from IBFD into OBFD.  Raise an error
 550    if there are conflicting attributes.  Any processor-specific
 551    attributes have already been merged.  This must be called from the
 552    bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
 553    target, along with any target-specific merging.  Because there are
 554    no common attributes other than Tag_compatibility at present, and
 555    non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
 556    is not presently called for targets without their own
 557    attributes.  */
 558
 559 bfd_boolean
 560 _bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
 561 {
 562   obj_attribute *in_attr;
 563   obj_attribute *out_attr;
 564   obj_attribute_list *in_list;
 565   obj_attribute_list *out_list;
 566   int vendor;
 567
 568   /* The only common attribute is currently Tag_compatibility,
 569      accepted in both processor and "gnu" sections.  */
 570   for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
 571     {
 572       in_list = elf_other_obj_attributes (ibfd)[vendor];
 573       out_list = elf_other_obj_attributes (ibfd)[vendor];
 574       while (in_list && in_list->tag == Tag_compatibility)
 575         {
 576           in_attr = &in_list->attr;
 577           if (in_attr->i == 0)
 578             continue;
 579           if (in_attr->i == 1 && strcmp (in_attr->s, "gnu") != 0)
 580             {
 581               _bfd_error_handler
 582                 (_("ERROR: %B: Must be processed by '%s' toolchain"),
 583                  ibfd, in_attr->s);
 584               return FALSE;
 585             }
 586           if (!out_list || out_list->tag != Tag_compatibility
 587               || strcmp (in_attr->s, out_list->attr.s) != 0)
 588             {
 589               /* Add this compatibility tag to the output.  */
 590               bfd_elf_add_proc_attr_compat (obfd, in_attr->i, in_attr->s);
 591               continue;
 592             }
 593           out_attr = &out_list->attr;
 594           /* Check all the input tags with the same identifier.  */
 595           for (;;)
 596             {
 597               if (out_list->tag != Tag_compatibility
 598                   || in_attr->i != out_attr->i
 599                   || strcmp (in_attr->s, out_attr->s) != 0)
 600                 {
 601                   _bfd_error_handler
 602                     (_("ERROR: %B: Incompatible object tag '%s':%d"),
 603                      ibfd, in_attr->s, in_attr->i);
 604                   return FALSE;
 605                 }
 606               in_list = in_list->next;
 607               if (in_list->tag != Tag_compatibility
 608                   || strcmp (in_attr->s, in_list->attr.s) != 0)
 609                 break;
 610               in_attr = &in_list->attr;
 611               out_list = out_list->next;
 612               if (out_list)
 613                 out_attr = &out_list->attr;
 614             }
 615
 616           /* Check the output doesn't have extra tags with this identifier.  */
 617           if (out_list && out_list->tag == Tag_compatibility
 618               && strcmp (in_attr->s, out_list->attr.s) == 0)
 619             {
 620               _bfd_error_handler
 621                 (_("ERROR: %B: Incompatible object tag '%s':%d"),
 622                  ibfd, in_attr->s, out_list->attr.i);
 623               return FALSE;
 624             }
 625         }
 626     }
 627
 628   return TRUE;
 629 }