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>