Automatic date update in version.in
[external/binutils.git] / bfd / pef.c
1 /* PEF support for BFD.
2    Copyright (C) 1999-2019 Free Software Foundation, Inc.
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 /* PEF (Preferred Executable Format) is the binary file format for late
22    classic Mac OS versions (before Darwin).  It is supported by both m68k
23    and PowerPc.  It is also called CFM (Code Fragment Manager).  */
24
25 #include "sysdep.h"
26 #include "safe-ctype.h"
27 #include "pef.h"
28 #include "pef-traceback.h"
29 #include "bfd.h"
30 #include "libbfd.h"
31 #include "libiberty.h"
32
33 #ifndef BFD_IO_FUNCS
34 #define BFD_IO_FUNCS 0
35 #endif
36
37 #define bfd_pef_close_and_cleanup                   _bfd_generic_close_and_cleanup
38 #define bfd_pef_bfd_free_cached_info                _bfd_generic_bfd_free_cached_info
39 #define bfd_pef_new_section_hook                    _bfd_generic_new_section_hook
40 #define bfd_pef_bfd_is_local_label_name             bfd_generic_is_local_label_name
41 #define bfd_pef_bfd_is_target_special_symbol        _bfd_bool_bfd_asymbol_false
42 #define bfd_pef_get_lineno                          _bfd_nosymbols_get_lineno
43 #define bfd_pef_find_nearest_line                   _bfd_nosymbols_find_nearest_line
44 #define bfd_pef_find_line                           _bfd_nosymbols_find_line
45 #define bfd_pef_find_inliner_info                   _bfd_nosymbols_find_inliner_info
46 #define bfd_pef_get_symbol_version_string           _bfd_nosymbols_get_symbol_version_string
47 #define bfd_pef_bfd_make_debug_symbol               _bfd_nosymbols_bfd_make_debug_symbol
48 #define bfd_pef_read_minisymbols                    _bfd_generic_read_minisymbols
49 #define bfd_pef_minisymbol_to_symbol                _bfd_generic_minisymbol_to_symbol
50 #define bfd_pef_set_arch_mach                       _bfd_generic_set_arch_mach
51 #define bfd_pef_get_section_contents                _bfd_generic_get_section_contents
52 #define bfd_pef_set_section_contents                _bfd_generic_set_section_contents
53 #define bfd_pef_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
54 #define bfd_pef_bfd_relax_section                   bfd_generic_relax_section
55 #define bfd_pef_bfd_gc_sections                     bfd_generic_gc_sections
56 #define bfd_pef_bfd_lookup_section_flags            bfd_generic_lookup_section_flags
57 #define bfd_pef_bfd_merge_sections                  bfd_generic_merge_sections
58 #define bfd_pef_bfd_is_group_section                bfd_generic_is_group_section
59 #define bfd_pef_bfd_discard_group                   bfd_generic_discard_group
60 #define bfd_pef_section_already_linked              _bfd_generic_section_already_linked
61 #define bfd_pef_bfd_define_common_symbol            bfd_generic_define_common_symbol
62 #define bfd_pef_bfd_link_hide_symbol                _bfd_generic_link_hide_symbol
63 #define bfd_pef_bfd_define_start_stop               bfd_generic_define_start_stop
64 #define bfd_pef_bfd_link_hash_table_create          _bfd_generic_link_hash_table_create
65 #define bfd_pef_bfd_link_add_symbols                _bfd_generic_link_add_symbols
66 #define bfd_pef_bfd_link_just_syms                  _bfd_generic_link_just_syms
67 #define bfd_pef_bfd_copy_link_hash_symbol_type \
68   _bfd_generic_copy_link_hash_symbol_type
69 #define bfd_pef_bfd_final_link                      _bfd_generic_final_link
70 #define bfd_pef_bfd_link_split_section              _bfd_generic_link_split_section
71 #define bfd_pef_get_section_contents_in_window      _bfd_generic_get_section_contents_in_window
72 #define bfd_pef_bfd_link_check_relocs               _bfd_generic_link_check_relocs
73
74 static int
75 bfd_pef_parse_traceback_table (bfd *abfd,
76                                asection *section,
77                                unsigned char *buf,
78                                size_t len,
79                                size_t pos,
80                                asymbol *sym,
81                                FILE *file)
82 {
83   struct traceback_table table;
84   size_t offset;
85   const char *s;
86   asymbol tmpsymbol;
87
88   if (sym == NULL)
89     sym = & tmpsymbol;
90
91   sym->name = NULL;
92   sym->value = 0;
93   sym->the_bfd = abfd;
94   sym->section = section;
95   sym->flags = 0;
96   sym->udata.i = 0;
97
98   /* memcpy is fine since all fields are unsigned char.  */
99   if ((pos + 8) > len)
100     return -1;
101   memcpy (&table, buf + pos, 8);
102
103   /* Calling code relies on returned symbols having a name and
104      correct offset.  */
105   if ((table.lang != TB_C) && (table.lang != TB_CPLUSPLUS))
106     return -1;
107
108   if (! (table.flags2 & TB_NAME_PRESENT))
109     return -1;
110
111   if (! (table.flags1 & TB_HAS_TBOFF))
112     return -1;
113
114   offset = 8;
115
116   if ((table.flags5 & TB_FLOATPARAMS) || (table.fixedparams))
117     offset += 4;
118
119   if (table.flags1 & TB_HAS_TBOFF)
120     {
121       struct traceback_table_tboff off;
122
123       if ((pos + offset + 4) > len)
124         return -1;
125       off.tb_offset = bfd_getb32 (buf + pos + offset);
126       offset += 4;
127
128       /* Need to subtract 4 because the offset includes the 0x0L
129          preceding the table.  */
130       if (file != NULL)
131         fprintf (file, " [offset = 0x%lx]", off.tb_offset);
132
133       if ((file == NULL) && ((off.tb_offset + 4) > (pos + offset)))
134         return -1;
135
136       sym->value = pos - off.tb_offset - 4;
137     }
138
139   if (table.flags2 & TB_INT_HNDL)
140     offset += 4;
141
142   if (table.flags1 & TB_HAS_CTL)
143     {
144       struct traceback_table_anchors anchors;
145
146       if ((pos + offset + 4) > len)
147         return -1;
148       anchors.ctl_info = bfd_getb32 (buf + pos + offset);
149       offset += 4;
150
151       if (anchors.ctl_info > 1024)
152         return -1;
153
154       offset += anchors.ctl_info * 4;
155     }
156
157   if (table.flags2 & TB_NAME_PRESENT)
158     {
159       struct traceback_table_routine name;
160       char *namebuf;
161
162       if ((pos + offset + 2) > len)
163         return -1;
164       name.name_len = bfd_getb16 (buf + pos + offset);
165       offset += 2;
166
167       if (name.name_len > 4096)
168         return -1;
169
170       if ((pos + offset + name.name_len) > len)
171         return -1;
172
173       namebuf = bfd_alloc (abfd, name.name_len + 1);
174       if (namebuf == NULL)
175         return -1;
176
177       memcpy (namebuf, buf + pos + offset, name.name_len);
178       namebuf[name.name_len] = '\0';
179
180       /* Strip leading period inserted by compiler.  */
181       if (namebuf[0] == '.')
182         memmove (namebuf, namebuf + 1, name.name_len + 1);
183
184       sym->name = namebuf;
185
186       for (s = sym->name; (*s != '\0'); s++)
187         if (! ISPRINT (*s))
188           return -1;
189
190       offset += name.name_len;
191     }
192
193   if (table.flags2 & TB_USES_ALLOCA)
194     offset += 4;
195
196   if (table.flags4 & TB_HAS_VEC_INFO)
197     offset += 4;
198
199   if (file != NULL)
200     fprintf (file, " [length = 0x%lx]", (unsigned long) offset);
201
202   return offset;
203 }
204
205 static void
206 bfd_pef_print_symbol (bfd *abfd,
207                       void * afile,
208                       asymbol *symbol,
209                       bfd_print_symbol_type how)
210 {
211   FILE *file = (FILE *) afile;
212
213   switch (how)
214     {
215     case bfd_print_symbol_name:
216       fprintf (file, "%s", symbol->name);
217       break;
218     default:
219       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
220       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
221       if (CONST_STRNEQ (symbol->name, "__traceback_"))
222         {
223           unsigned char *buf = xmalloc (symbol->udata.i);
224           size_t offset = symbol->value + 4;
225           size_t len = symbol->udata.i;
226           int ret;
227
228           bfd_get_section_contents (abfd, symbol->section, buf, offset, len);
229           ret = bfd_pef_parse_traceback_table (abfd, symbol->section, buf,
230                                                len, 0, NULL, file);
231           if (ret < 0)
232             fprintf (file, " [ERROR]");
233           free (buf);
234         }
235     }
236 }
237
238 static void
239 bfd_pef_convert_architecture (unsigned long architecture,
240                               enum bfd_architecture *type,
241                               unsigned long *subtype)
242 {
243   const unsigned long ARCH_POWERPC = 0x70777063; /* 'pwpc'.  */
244   const unsigned long ARCH_M68K = 0x6d36386b; /* 'm68k'.  */
245
246   *subtype = bfd_arch_unknown;
247   *type = bfd_arch_unknown;
248
249   if (architecture == ARCH_POWERPC)
250     *type = bfd_arch_powerpc;
251   else if (architecture == ARCH_M68K)
252     *type = bfd_arch_m68k;
253 }
254
255 static bfd_boolean
256 bfd_pef_mkobject (bfd *abfd ATTRIBUTE_UNUSED)
257 {
258   return TRUE;
259 }
260
261 static const char *bfd_pef_section_name (bfd_pef_section *section)
262 {
263   switch (section->section_kind)
264     {
265     case BFD_PEF_SECTION_CODE: return "code";
266     case BFD_PEF_SECTION_UNPACKED_DATA: return "unpacked-data";
267     case BFD_PEF_SECTION_PACKED_DATA: return "packed-data";
268     case BFD_PEF_SECTION_CONSTANT: return "constant";
269     case BFD_PEF_SECTION_LOADER: return "loader";
270     case BFD_PEF_SECTION_DEBUG: return "debug";
271     case BFD_PEF_SECTION_EXEC_DATA: return "exec-data";
272     case BFD_PEF_SECTION_EXCEPTION: return "exception";
273     case BFD_PEF_SECTION_TRACEBACK: return "traceback";
274     default: return "unknown";
275     }
276 }
277
278 static unsigned long bfd_pef_section_flags (bfd_pef_section *section)
279 {
280   switch (section->section_kind)
281     {
282     case BFD_PEF_SECTION_CODE:
283       return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
284     case BFD_PEF_SECTION_UNPACKED_DATA:
285     case BFD_PEF_SECTION_PACKED_DATA:
286     case BFD_PEF_SECTION_CONSTANT:
287     case BFD_PEF_SECTION_LOADER:
288     case BFD_PEF_SECTION_DEBUG:
289     case BFD_PEF_SECTION_EXEC_DATA:
290     case BFD_PEF_SECTION_EXCEPTION:
291     case BFD_PEF_SECTION_TRACEBACK:
292     default:
293       return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
294     }
295 }
296
297 static asection *
298 bfd_pef_make_bfd_section (bfd *abfd, bfd_pef_section *section)
299 {
300   asection *bfdsec;
301   const char *name = bfd_pef_section_name (section);
302
303   bfdsec = bfd_make_section_anyway (abfd, name);
304   if (bfdsec == NULL)
305     return NULL;
306
307   bfdsec->vma = section->default_address + section->container_offset;
308   bfdsec->lma = section->default_address + section->container_offset;
309   bfdsec->size = section->container_length;
310   bfdsec->filepos = section->container_offset;
311   bfdsec->alignment_power = section->alignment;
312
313   bfdsec->flags = bfd_pef_section_flags (section);
314
315   return bfdsec;
316 }
317
318 int
319 bfd_pef_parse_loader_header (bfd *abfd ATTRIBUTE_UNUSED,
320                              unsigned char *buf,
321                              size_t len,
322                              bfd_pef_loader_header *header)
323 {
324   BFD_ASSERT (len == 56);
325
326   header->main_section = bfd_getb32 (buf);
327   header->main_offset = bfd_getb32 (buf + 4);
328   header->init_section = bfd_getb32 (buf + 8);
329   header->init_offset = bfd_getb32 (buf + 12);
330   header->term_section = bfd_getb32 (buf + 16);
331   header->term_offset = bfd_getb32 (buf + 20);
332   header->imported_library_count = bfd_getb32 (buf + 24);
333   header->total_imported_symbol_count = bfd_getb32 (buf + 28);
334   header->reloc_section_count = bfd_getb32 (buf + 32);
335   header->reloc_instr_offset = bfd_getb32 (buf + 36);
336   header->loader_strings_offset = bfd_getb32 (buf + 40);
337   header->export_hash_offset = bfd_getb32 (buf + 44);
338   header->export_hash_table_power = bfd_getb32 (buf + 48);
339   header->exported_symbol_count = bfd_getb32 (buf + 52);
340
341   return 0;
342 }
343
344 int
345 bfd_pef_parse_imported_library (bfd *abfd ATTRIBUTE_UNUSED,
346                                 unsigned char *buf,
347                                 size_t len,
348                                 bfd_pef_imported_library *header)
349 {
350   BFD_ASSERT (len == 24);
351
352   header->name_offset = bfd_getb32 (buf);
353   header->old_implementation_version = bfd_getb32 (buf + 4);
354   header->current_version = bfd_getb32 (buf + 8);
355   header->imported_symbol_count = bfd_getb32 (buf + 12);
356   header->first_imported_symbol = bfd_getb32 (buf + 16);
357   header->options = buf[20];
358   header->reserved_a = buf[21];
359   header->reserved_b = bfd_getb16 (buf + 22);
360
361   return 0;
362 }
363
364 int
365 bfd_pef_parse_imported_symbol (bfd *abfd ATTRIBUTE_UNUSED,
366                                unsigned char *buf,
367                                size_t len,
368                                bfd_pef_imported_symbol *symbol)
369 {
370   unsigned long value;
371
372   BFD_ASSERT (len == 4);
373
374   value = bfd_getb32 (buf);
375   symbol->symbol_class = value >> 24;
376   symbol->name = value & 0x00ffffff;
377
378   return 0;
379 }
380
381 int
382 bfd_pef_scan_section (bfd *abfd, bfd_pef_section *section)
383 {
384   unsigned char buf[28];
385
386   bfd_seek (abfd, section->header_offset, SEEK_SET);
387   if (bfd_bread ((void *) buf, 28, abfd) != 28)
388     return -1;
389
390   section->name_offset = bfd_h_get_32 (abfd, buf);
391   section->default_address = bfd_h_get_32 (abfd, buf + 4);
392   section->total_length = bfd_h_get_32 (abfd, buf + 8);
393   section->unpacked_length = bfd_h_get_32 (abfd, buf + 12);
394   section->container_length = bfd_h_get_32 (abfd, buf + 16);
395   section->container_offset = bfd_h_get_32 (abfd, buf + 20);
396   section->section_kind = buf[24];
397   section->share_kind = buf[25];
398   section->alignment = buf[26];
399   section->reserved = buf[27];
400
401   section->bfd_section = bfd_pef_make_bfd_section (abfd, section);
402   if (section->bfd_section == NULL)
403     return -1;
404
405   return 0;
406 }
407
408 void
409 bfd_pef_print_loader_header (bfd *abfd ATTRIBUTE_UNUSED,
410                              bfd_pef_loader_header *header,
411                              FILE *file)
412 {
413   fprintf (file, "main_section: %ld\n", header->main_section);
414   fprintf (file, "main_offset: %lu\n", header->main_offset);
415   fprintf (file, "init_section: %ld\n", header->init_section);
416   fprintf (file, "init_offset: %lu\n", header->init_offset);
417   fprintf (file, "term_section: %ld\n", header->term_section);
418   fprintf (file, "term_offset: %lu\n", header->term_offset);
419   fprintf (file, "imported_library_count: %lu\n",
420            header->imported_library_count);
421   fprintf (file, "total_imported_symbol_count: %lu\n",
422            header->total_imported_symbol_count);
423   fprintf (file, "reloc_section_count: %lu\n", header->reloc_section_count);
424   fprintf (file, "reloc_instr_offset: %lu\n", header->reloc_instr_offset);
425   fprintf (file, "loader_strings_offset: %lu\n",
426            header->loader_strings_offset);
427   fprintf (file, "export_hash_offset: %lu\n", header->export_hash_offset);
428   fprintf (file, "export_hash_table_power: %lu\n",
429            header->export_hash_table_power);
430   fprintf (file, "exported_symbol_count: %lu\n",
431            header->exported_symbol_count);
432 }
433
434 int
435 bfd_pef_print_loader_section (bfd *abfd, FILE *file)
436 {
437   bfd_pef_loader_header header;
438   asection *loadersec = NULL;
439   unsigned char *loaderbuf = NULL;
440   size_t loaderlen = 0;
441
442   loadersec = bfd_get_section_by_name (abfd, "loader");
443   if (loadersec == NULL)
444     return -1;
445
446   loaderlen = loadersec->size;
447   loaderbuf = bfd_malloc (loaderlen);
448
449   if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0
450       || bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen
451       || loaderlen < 56
452       || bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header) < 0)
453     {
454       free (loaderbuf);
455       return -1;
456     }
457
458   bfd_pef_print_loader_header (abfd, &header, file);
459   return 0;
460 }
461
462 int
463 bfd_pef_scan_start_address (bfd *abfd)
464 {
465   bfd_pef_loader_header header;
466   asection *section;
467
468   asection *loadersec = NULL;
469   unsigned char *loaderbuf = NULL;
470   size_t loaderlen = 0;
471   int ret;
472
473   loadersec = bfd_get_section_by_name (abfd, "loader");
474   if (loadersec == NULL)
475     goto end;
476
477   loaderlen = loadersec->size;
478   loaderbuf = bfd_malloc (loaderlen);
479   if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0)
480     goto error;
481   if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen)
482     goto error;
483
484   if (loaderlen < 56)
485     goto error;
486   ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header);
487   if (ret < 0)
488     goto error;
489
490   if (header.main_section < 0)
491     goto end;
492
493   for (section = abfd->sections; section != NULL; section = section->next)
494     if ((long) (section->index + 1) == header.main_section)
495       break;
496
497   if (section == NULL)
498     goto error;
499
500   abfd->start_address = section->vma + header.main_offset;
501
502  end:
503   if (loaderbuf != NULL)
504     free (loaderbuf);
505   return 0;
506
507  error:
508   if (loaderbuf != NULL)
509     free (loaderbuf);
510   return -1;
511 }
512
513 int
514 bfd_pef_scan (bfd *abfd,
515               bfd_pef_header *header,
516               bfd_pef_data_struct *mdata)
517 {
518   unsigned int i;
519   enum bfd_architecture cputype;
520   unsigned long cpusubtype;
521
522   mdata->header = *header;
523
524   bfd_pef_convert_architecture (header->architecture, &cputype, &cpusubtype);
525   if (cputype == bfd_arch_unknown)
526     {
527       _bfd_error_handler (_("bfd_pef_scan: unknown architecture 0x%lx"),
528                           header->architecture);
529       return -1;
530     }
531   bfd_set_arch_mach (abfd, cputype, cpusubtype);
532
533   mdata->header = *header;
534
535   abfd->flags = (abfd->xvec->object_flags
536                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
537
538   if (header->section_count != 0)
539     {
540       mdata->sections = bfd_alloc (abfd, header->section_count * sizeof (bfd_pef_section));
541
542       if (mdata->sections == NULL)
543         return -1;
544
545       for (i = 0; i < header->section_count; i++)
546         {
547           bfd_pef_section *cur = &mdata->sections[i];
548           cur->header_offset = 40 + (i * 28);
549           if (bfd_pef_scan_section (abfd, cur) < 0)
550             return -1;
551         }
552     }
553
554   if (bfd_pef_scan_start_address (abfd) < 0)
555     return -1;
556
557   abfd->tdata.pef_data = mdata;
558
559   return 0;
560 }
561
562 static int
563 bfd_pef_read_header (bfd *abfd, bfd_pef_header *header)
564 {
565   unsigned char buf[40];
566
567   bfd_seek (abfd, 0, SEEK_SET);
568
569   if (bfd_bread ((void *) buf, 40, abfd) != 40)
570     return -1;
571
572   header->tag1 = bfd_getb32 (buf);
573   header->tag2 = bfd_getb32 (buf + 4);
574   header->architecture = bfd_getb32 (buf + 8);
575   header->format_version = bfd_getb32 (buf + 12);
576   header->timestamp = bfd_getb32 (buf + 16);
577   header->old_definition_version = bfd_getb32 (buf + 20);
578   header->old_implementation_version = bfd_getb32 (buf + 24);
579   header->current_version = bfd_getb32 (buf + 28);
580   header->section_count = bfd_getb32 (buf + 32) + 1;
581   header->instantiated_section_count = bfd_getb32 (buf + 34);
582   header->reserved = bfd_getb32 (buf + 36);
583
584   return 0;
585 }
586
587 static const bfd_target *
588 bfd_pef_object_p (bfd *abfd)
589 {
590   bfd_pef_header header;
591   bfd_pef_data_struct *mdata;
592
593   if (bfd_pef_read_header (abfd, &header) != 0)
594     goto wrong;
595
596   if (header.tag1 != BFD_PEF_TAG1 || header.tag2 != BFD_PEF_TAG2)
597     goto wrong;
598
599   mdata = (bfd_pef_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
600   if (mdata == NULL)
601     goto fail;
602
603   if (bfd_pef_scan (abfd, &header, mdata))
604     goto wrong;
605
606   return abfd->xvec;
607
608  wrong:
609   bfd_set_error (bfd_error_wrong_format);
610
611  fail:
612   return NULL;
613 }
614
615 static int
616 bfd_pef_parse_traceback_tables (bfd *abfd,
617                                 asection *sec,
618                                 unsigned char *buf,
619                                 size_t len,
620                                 long *nsym,
621                                 asymbol **csym)
622 {
623   char *name;
624
625   asymbol function;
626   asymbol traceback;
627
628   const char *const tbprefix = "__traceback_";
629   size_t tbnamelen;
630
631   size_t pos = 0;
632   unsigned long count = 0;
633   int ret;
634
635   for (;;)
636     {
637       /* We're reading symbols two at a time.  */
638       if (csym && ((csym[count] == NULL) || (csym[count + 1] == NULL)))
639         break;
640
641       pos += 3;
642       pos -= (pos % 4);
643
644       while ((pos + 4) <= len)
645         {
646           if (bfd_getb32 (buf + pos) == 0)
647             break;
648           pos += 4;
649         }
650
651       if ((pos + 4) > len)
652         break;
653
654       ret = bfd_pef_parse_traceback_table (abfd, sec, buf, len, pos + 4,
655                                            &function, 0);
656       if (ret < 0)
657         {
658           /* Skip over 0x0L to advance to next possible traceback table.  */
659           pos += 4;
660           continue;
661         }
662
663       BFD_ASSERT (function.name != NULL);
664
665       /* Don't bother to compute the name if we are just
666          counting symbols.  */
667       if (csym)
668         {
669           tbnamelen = strlen (tbprefix) + strlen (function.name);
670           name = bfd_alloc (abfd, tbnamelen + 1);
671           if (name == NULL)
672             {
673               bfd_release (abfd, (void *) function.name);
674               function.name = NULL;
675               break;
676             }
677           snprintf (name, tbnamelen + 1, "%s%s", tbprefix, function.name);
678           traceback.name = name;
679           traceback.value = pos;
680           traceback.the_bfd = abfd;
681           traceback.section = sec;
682           traceback.flags = 0;
683           traceback.udata.i = ret;
684
685           *(csym[count]) = function;
686           *(csym[count + 1]) = traceback;
687         }
688
689       pos += ret;
690       count += 2;
691     }
692
693   *nsym = count;
694   return 0;
695 }
696
697 static int
698 bfd_pef_parse_function_stub (bfd *abfd ATTRIBUTE_UNUSED,
699                              unsigned char *buf,
700                              size_t len,
701                              unsigned long *offset)
702 {
703   BFD_ASSERT (len == 24);
704
705   if ((bfd_getb32 (buf) & 0xffff0000) != 0x81820000)
706     return -1;
707   if (bfd_getb32 (buf + 4) != 0x90410014)
708     return -1;
709   if (bfd_getb32 (buf + 8) != 0x800c0000)
710     return -1;
711   if (bfd_getb32 (buf + 12) != 0x804c0004)
712     return -1;
713   if (bfd_getb32 (buf + 16) != 0x7c0903a6)
714     return -1;
715   if (bfd_getb32 (buf + 20) != 0x4e800420)
716     return -1;
717
718   if (offset != NULL)
719     *offset = (bfd_getb32 (buf) & 0x0000ffff) / 4;
720
721   return 0;
722 }
723
724 static int
725 bfd_pef_parse_function_stubs (bfd *abfd,
726                               asection *codesec,
727                               unsigned char *codebuf,
728                               size_t codelen,
729                               unsigned char *loaderbuf,
730                               size_t loaderlen,
731                               unsigned long *nsym,
732                               asymbol **csym)
733 {
734   const char *const sprefix = "__stub_";
735   size_t codepos = 0;
736   unsigned long count = 0;
737   bfd_pef_loader_header header;
738   bfd_pef_imported_library *libraries = NULL;
739   bfd_pef_imported_symbol *imports = NULL;
740   unsigned long i;
741   int ret;
742
743   if (loaderlen < 56)
744     goto error;
745
746   ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header);
747   if (ret < 0)
748     goto error;
749
750   libraries = bfd_malloc
751     (header.imported_library_count * sizeof (bfd_pef_imported_library));
752   imports = bfd_malloc
753     (header.total_imported_symbol_count * sizeof (bfd_pef_imported_symbol));
754
755   if (loaderlen < (56 + (header.imported_library_count * 24)))
756     goto error;
757   for (i = 0; i < header.imported_library_count; i++)
758     {
759       ret = bfd_pef_parse_imported_library
760         (abfd, loaderbuf + 56 + (i * 24), 24, &libraries[i]);
761       if (ret < 0)
762         goto error;
763     }
764
765   if (loaderlen < (56 + (header.imported_library_count * 24)
766                    + (header.total_imported_symbol_count * 4)))
767     goto error;
768   for (i = 0; i < header.total_imported_symbol_count; i++)
769     {
770       ret = (bfd_pef_parse_imported_symbol
771              (abfd,
772               loaderbuf + 56 + (header.imported_library_count * 24) + (i * 4),
773               4, &imports[i]));
774       if (ret < 0)
775         goto error;
776     }
777
778   codepos = 0;
779
780   for (;;)
781     {
782       asymbol sym;
783       const char *symname;
784       char *name;
785       unsigned long sym_index;
786
787       if (csym && (csym[count] == NULL))
788         break;
789
790       codepos += 3;
791       codepos -= (codepos % 4);
792
793       while ((codepos + 4) <= codelen)
794         {
795           if ((bfd_getb32 (codebuf + codepos) & 0xffff0000) == 0x81820000)
796             break;
797           codepos += 4;
798         }
799
800       if ((codepos + 4) > codelen)
801         break;
802
803       ret = bfd_pef_parse_function_stub (abfd, codebuf + codepos, 24, &sym_index);
804       if (ret < 0)
805         {
806           codepos += 24;
807           continue;
808         }
809
810       if (sym_index >= header.total_imported_symbol_count)
811         {
812           codepos += 24;
813           continue;
814         }
815
816       {
817         size_t max, namelen;
818         const char *s;
819
820         if (loaderlen < (header.loader_strings_offset + imports[sym_index].name))
821           goto error;
822
823         max = loaderlen - (header.loader_strings_offset + imports[sym_index].name);
824         symname = (char *) loaderbuf;
825         symname += header.loader_strings_offset + imports[sym_index].name;
826         namelen = 0;
827         for (s = symname; s < (symname + max); s++)
828           {
829             if (*s == '\0')
830               break;
831             if (! ISPRINT (*s))
832               goto error;
833             namelen++;
834           }
835         if (*s != '\0')
836           goto error;
837
838         name = bfd_alloc (abfd, strlen (sprefix) + namelen + 1);
839         if (name == NULL)
840           break;
841
842         snprintf (name, strlen (sprefix) + namelen + 1, "%s%s",
843                   sprefix, symname);
844         sym.name = name;
845       }
846
847       sym.value = codepos;
848       sym.the_bfd = abfd;
849       sym.section = codesec;
850       sym.flags = 0;
851       sym.udata.i = 0;
852
853       codepos += 24;
854
855       if (csym != NULL)
856         *(csym[count]) = sym;
857
858       count++;
859     }
860
861   goto end;
862
863  end:
864   if (libraries != NULL)
865     free (libraries);
866   if (imports != NULL)
867     free (imports);
868   *nsym = count;
869   return 0;
870
871  error:
872   if (libraries != NULL)
873     free (libraries);
874   if (imports != NULL)
875     free (imports);
876   *nsym = count;
877   return -1;
878 }
879
880 static long
881 bfd_pef_parse_symbols (bfd *abfd, asymbol **csym)
882 {
883   unsigned long count = 0;
884
885   asection *codesec = NULL;
886   unsigned char *codebuf = NULL;
887   size_t codelen = 0;
888
889   asection *loadersec = NULL;
890   unsigned char *loaderbuf = NULL;
891   size_t loaderlen = 0;
892
893   codesec = bfd_get_section_by_name (abfd, "code");
894   if (codesec != NULL)
895     {
896       codelen = codesec->size;
897       codebuf = bfd_malloc (codelen);
898       if (bfd_seek (abfd, codesec->filepos, SEEK_SET) < 0)
899         goto end;
900       if (bfd_bread ((void *) codebuf, codelen, abfd) != codelen)
901         goto end;
902     }
903
904   loadersec = bfd_get_section_by_name (abfd, "loader");
905   if (loadersec != NULL)
906     {
907       loaderlen = loadersec->size;
908       loaderbuf = bfd_malloc (loaderlen);
909       if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0)
910         goto end;
911       if (bfd_bread ((void *) loaderbuf, loaderlen, abfd) != loaderlen)
912         goto end;
913     }
914
915   count = 0;
916   if (codesec != NULL)
917     {
918       long ncount = 0;
919       bfd_pef_parse_traceback_tables (abfd, codesec, codebuf, codelen,
920                                       &ncount, csym);
921       count += ncount;
922     }
923
924   if ((codesec != NULL) && (loadersec != NULL))
925     {
926       unsigned long ncount = 0;
927       bfd_pef_parse_function_stubs
928         (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, &ncount,
929          (csym != NULL) ? (csym + count) : NULL);
930       count += ncount;
931     }
932
933   if (csym != NULL)
934     csym[count] = NULL;
935
936  end:
937   if (codebuf != NULL)
938     free (codebuf);
939
940   if (loaderbuf != NULL)
941     free (loaderbuf);
942
943   return count;
944 }
945
946 static long
947 bfd_pef_count_symbols (bfd *abfd)
948 {
949   return bfd_pef_parse_symbols (abfd, NULL);
950 }
951
952 static long
953 bfd_pef_get_symtab_upper_bound (bfd *abfd)
954 {
955   long nsyms = bfd_pef_count_symbols (abfd);
956
957   if (nsyms < 0)
958     return nsyms;
959   return ((nsyms + 1) * sizeof (asymbol *));
960 }
961
962 static long
963 bfd_pef_canonicalize_symtab (bfd *abfd, asymbol **alocation)
964 {
965   long i;
966   asymbol *syms;
967   long ret;
968   long nsyms = bfd_pef_count_symbols (abfd);
969
970   if (nsyms < 0)
971     return nsyms;
972
973   syms = bfd_alloc (abfd, nsyms * sizeof (asymbol));
974   if (syms == NULL)
975     return -1;
976
977   for (i = 0; i < nsyms; i++)
978     alocation[i] = &syms[i];
979
980   alocation[nsyms] = NULL;
981
982   ret = bfd_pef_parse_symbols (abfd, alocation);
983   if (ret != nsyms)
984     return 0;
985
986   return ret;
987 }
988
989 #define bfd_pef_make_empty_symbol _bfd_generic_make_empty_symbol
990
991 static void
992 bfd_pef_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
993                          asymbol *symbol,
994                          symbol_info *ret)
995 {
996   bfd_symbol_info (symbol, ret);
997 }
998
999 static int
1000 bfd_pef_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
1001                         struct bfd_link_info *info ATTRIBUTE_UNUSED)
1002 {
1003   return 0;
1004 }
1005
1006 const bfd_target pef_vec =
1007 {
1008   "pef",                        /* Name.  */
1009   bfd_target_pef_flavour,       /* Flavour.  */
1010   BFD_ENDIAN_BIG,               /* Byteorder.  */
1011   BFD_ENDIAN_BIG,               /* Header_byteorder.  */
1012   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1013    HAS_LINENO | HAS_DEBUG |
1014    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1015   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
1016    | SEC_ROM | SEC_HAS_CONTENTS), /* Section_flags.  */
1017   0,                            /* Symbol_leading_char.  */
1018   ' ',                          /* AR_pad_char.  */
1019   16,                           /* AR_max_namelen.  */
1020   0,                            /* match priority.  */
1021   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1022   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1023   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1024   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1025   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1026   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
1027   {                             /* bfd_check_format.  */
1028     _bfd_dummy_target,
1029     bfd_pef_object_p,           /* bfd_check_format.  */
1030     _bfd_dummy_target,
1031     _bfd_dummy_target,
1032   },
1033   {                             /* bfd_set_format.  */
1034     _bfd_bool_bfd_false_error,
1035     bfd_pef_mkobject,
1036     _bfd_bool_bfd_false_error,
1037     _bfd_bool_bfd_false_error,
1038   },
1039   {                             /* bfd_write_contents.  */
1040     _bfd_bool_bfd_false_error,
1041     _bfd_bool_bfd_true,
1042     _bfd_bool_bfd_false_error,
1043     _bfd_bool_bfd_false_error,
1044   },
1045
1046   BFD_JUMP_TABLE_GENERIC (bfd_pef),
1047   BFD_JUMP_TABLE_COPY (_bfd_generic),
1048   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1049   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1050   BFD_JUMP_TABLE_SYMBOLS (bfd_pef),
1051   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1052   BFD_JUMP_TABLE_WRITE (bfd_pef),
1053   BFD_JUMP_TABLE_LINK (bfd_pef),
1054   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1055
1056   NULL,
1057
1058   NULL
1059 };
1060
1061 #define bfd_pef_xlib_close_and_cleanup              _bfd_generic_close_and_cleanup
1062 #define bfd_pef_xlib_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
1063 #define bfd_pef_xlib_new_section_hook               _bfd_generic_new_section_hook
1064 #define bfd_pef_xlib_get_section_contents           _bfd_generic_get_section_contents
1065 #define bfd_pef_xlib_set_section_contents           _bfd_generic_set_section_contents
1066 #define bfd_pef_xlib_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
1067 #define bfd_pef_xlib_set_section_contents_in_window _bfd_generic_set_section_contents_in_window
1068
1069 static int
1070 bfd_pef_xlib_read_header (bfd *abfd, bfd_pef_xlib_header *header)
1071 {
1072   unsigned char buf[80];
1073
1074   bfd_seek (abfd, 0, SEEK_SET);
1075
1076   if (bfd_bread ((void *) buf, sizeof buf, abfd) != sizeof buf)
1077     return -1;
1078
1079   header->tag1 = bfd_getb32 (buf);
1080   header->tag2 = bfd_getb32 (buf + 4);
1081   header->current_format = bfd_getb32 (buf + 8);
1082   header->container_strings_offset = bfd_getb32 (buf + 12);
1083   header->export_hash_offset = bfd_getb32 (buf + 16);
1084   header->export_key_offset = bfd_getb32 (buf + 20);
1085   header->export_symbol_offset = bfd_getb32 (buf + 24);
1086   header->export_names_offset = bfd_getb32 (buf + 28);
1087   header->export_hash_table_power = bfd_getb32 (buf + 32);
1088   header->exported_symbol_count = bfd_getb32 (buf + 36);
1089   header->frag_name_offset = bfd_getb32 (buf + 40);
1090   header->frag_name_length = bfd_getb32 (buf + 44);
1091   header->dylib_path_offset = bfd_getb32 (buf + 48);
1092   header->dylib_path_length = bfd_getb32 (buf + 52);
1093   header->cpu_family = bfd_getb32 (buf + 56);
1094   header->cpu_model = bfd_getb32 (buf + 60);
1095   header->date_time_stamp = bfd_getb32 (buf + 64);
1096   header->current_version = bfd_getb32 (buf + 68);
1097   header->old_definition_version = bfd_getb32 (buf + 72);
1098   header->old_implementation_version = bfd_getb32 (buf + 76);
1099
1100   return 0;
1101 }
1102
1103 static int
1104 bfd_pef_xlib_scan (bfd *abfd, bfd_pef_xlib_header *header)
1105 {
1106   bfd_pef_xlib_data_struct *mdata = NULL;
1107
1108   mdata = bfd_alloc (abfd, sizeof (* mdata));
1109   if (mdata == NULL)
1110     return -1;
1111
1112   mdata->header = *header;
1113
1114   abfd->flags = (abfd->xvec->object_flags
1115                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
1116
1117   abfd->tdata.pef_xlib_data = mdata;
1118
1119   return 0;
1120 }
1121
1122 static const bfd_target *
1123 bfd_pef_xlib_object_p (bfd *abfd)
1124 {
1125   bfd_pef_xlib_header header;
1126
1127   if (bfd_pef_xlib_read_header (abfd, &header) != 0)
1128     {
1129       bfd_set_error (bfd_error_wrong_format);
1130       return NULL;
1131     }
1132
1133   if ((header.tag1 != BFD_PEF_XLIB_TAG1)
1134       || ((header.tag2 != BFD_PEF_VLIB_TAG2)
1135           && (header.tag2 != BFD_PEF_BLIB_TAG2)))
1136     {
1137       bfd_set_error (bfd_error_wrong_format);
1138       return NULL;
1139     }
1140
1141   if (bfd_pef_xlib_scan (abfd, &header) != 0)
1142     {
1143       bfd_set_error (bfd_error_wrong_format);
1144       return NULL;
1145     }
1146
1147   return abfd->xvec;
1148 }
1149
1150 const bfd_target pef_xlib_vec =
1151 {
1152   "pef-xlib",                   /* Name.  */
1153   bfd_target_pef_xlib_flavour,  /* Flavour.  */
1154   BFD_ENDIAN_BIG,               /* Byteorder */
1155   BFD_ENDIAN_BIG,               /* Header_byteorder.  */
1156   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1157    HAS_LINENO | HAS_DEBUG |
1158    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1159   (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA
1160    | SEC_ROM | SEC_HAS_CONTENTS),/* Section_flags.  */
1161   0,                            /* Symbol_leading_char.  */
1162   ' ',                          /* AR_pad_char.  */
1163   16,                           /* AR_max_namelen.  */
1164   0,                            /* match priority.  */
1165   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1166   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1167   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
1168   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1169   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1170   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
1171   {                             /* bfd_check_format.  */
1172     _bfd_dummy_target,
1173     bfd_pef_xlib_object_p,      /* bfd_check_format.  */
1174     _bfd_dummy_target,
1175     _bfd_dummy_target,
1176   },
1177   {                             /* bfd_set_format.  */
1178     _bfd_bool_bfd_false_error,
1179     bfd_pef_mkobject,
1180     _bfd_bool_bfd_false_error,
1181     _bfd_bool_bfd_false_error,
1182   },
1183   {                             /* bfd_write_contents.  */
1184     _bfd_bool_bfd_false_error,
1185     _bfd_bool_bfd_true,
1186     _bfd_bool_bfd_false_error,
1187     _bfd_bool_bfd_false_error,
1188   },
1189
1190   BFD_JUMP_TABLE_GENERIC (bfd_pef_xlib),
1191   BFD_JUMP_TABLE_COPY (_bfd_generic),
1192   BFD_JUMP_TABLE_CORE (_bfd_nocore),
1193   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1194   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
1195   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1196   BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
1197   BFD_JUMP_TABLE_LINK (_bfd_nolink),
1198   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1199
1200   NULL,
1201
1202   NULL
1203 };