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