[BACK]Return to elf-attrs.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd

Annotation of src/external/gpl3/binutils.old/dist/bfd/elf-attrs.c, Revision 1.7

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

CVSweb <webmaster@jp.NetBSD.org>