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