OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [rescoff.c] - Blame information for rev 146

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 15 khays
/* rescoff.c -- read and write resources in Windows COFF files.
2
   Copyright 1997, 1998, 1999, 2000, 2003, 2005, 2007, 2008
3
   Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor, Cygnus Support.
5
   Rewritten by Kai Tietz, Onevision.
6
 
7
   This file is part of GNU Binutils.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22
   02110-1301, USA.  */
23
 
24
/* This file contains function that read and write Windows resources
25
   in COFF files.  */
26
 
27
#include "sysdep.h"
28
#include "bfd.h"
29
#include "bucomm.h"
30
#include "libiberty.h"
31
#include "windres.h"
32
 
33
#include <assert.h>
34
 
35
/* In order to use the address of a resource data entry, we need to
36
   get the image base of the file.  Right now we extract it from
37
   internal BFD information.  FIXME.  */
38
 
39
#include "coff/internal.h"
40
#include "libcoff.h"
41
 
42
/* Information we extract from the file.  */
43
 
44
struct coff_file_info
45
{
46
  /* File name.  */
47
  const char *filename;
48
  /* Data read from the file.  */
49
  const bfd_byte *data;
50
  /* End of data read from file.  */
51
  const bfd_byte *data_end;
52
  /* Address of the resource section minus the image base of the file.  */
53
  rc_uint_type secaddr;
54
};
55
 
56
/* A resource directory table in a COFF file.  */
57
 
58
struct __attribute__ ((__packed__)) extern_res_directory
59
{
60
  /* Characteristics.  */
61
  bfd_byte characteristics[4];
62
  /* Time stamp.  */
63
  bfd_byte time[4];
64
  /* Major version number.  */
65
  bfd_byte major[2];
66
  /* Minor version number.  */
67
  bfd_byte minor[2];
68
  /* Number of named directory entries.  */
69
  bfd_byte name_count[2];
70
  /* Number of directory entries with IDs.  */
71
  bfd_byte id_count[2];
72
};
73
 
74
/* A resource directory entry in a COFF file.  */
75
 
76
struct extern_res_entry
77
{
78
  /* Name or ID.  */
79
  bfd_byte name[4];
80
  /* Address of resource entry or subdirectory.  */
81
  bfd_byte rva[4];
82
};
83
 
84
/* A resource data entry in a COFF file.  */
85
 
86
struct extern_res_data
87
{
88
  /* Address of resource data.  This is apparently a file relative
89
     address, rather than a section offset.  */
90
  bfd_byte rva[4];
91
  /* Size of resource data.  */
92
  bfd_byte size[4];
93
  /* Code page.  */
94
  bfd_byte codepage[4];
95
  /* Reserved.  */
96
  bfd_byte reserved[4];
97
};
98
 
99
/* Local functions.  */
100
 
101
static void overrun (const struct coff_file_info *, const char *);
102
static rc_res_directory *read_coff_res_dir (windres_bfd *, const bfd_byte *,
103
                                            const struct coff_file_info *,
104
                                            const rc_res_id *, int);
105
static rc_res_resource *read_coff_data_entry (windres_bfd *, const bfd_byte *,
106
                                              const struct coff_file_info *,
107
                                              const rc_res_id *);
108
 
109
/* Read the resources in a COFF file.  */
110
 
111
rc_res_directory *
112
read_coff_rsrc (const char *filename, const char *target)
113
{
114
  rc_res_directory *ret;
115
  bfd *abfd;
116
  windres_bfd wrbfd;
117
  char **matching;
118
  asection *sec;
119
  bfd_size_type size;
120
  bfd_byte *data;
121
  struct coff_file_info finfo;
122
 
123
  if (filename == NULL)
124
    fatal (_("filename required for COFF input"));
125
 
126
  abfd = bfd_openr (filename, target);
127
  if (abfd == NULL)
128
    bfd_fatal (filename);
129
 
130
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
131
    {
132
      bfd_nonfatal (bfd_get_filename (abfd));
133
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
134
        list_matching_formats (matching);
135
      xexit (1);
136
    }
137
 
138
  sec = bfd_get_section_by_name (abfd, ".rsrc");
139
  if (sec == NULL)
140
    {
141
      fatal (_("%s: no resource section"), filename);
142
    }
143
 
144
  set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
145
  size = bfd_section_size (abfd, sec);
146
  data = (bfd_byte *) res_alloc (size);
147
 
148
  get_windres_bfd_content (&wrbfd, data, 0, size);
149
 
150
  finfo.filename = filename;
151
  finfo.data = data;
152
  finfo.data_end = data + size;
153
  finfo.secaddr = (bfd_get_section_vma (abfd, sec)
154
                   - pe_data (abfd)->pe_opthdr.ImageBase);
155
 
156
  /* Now just read in the top level resource directory.  Note that we
157
     don't free data, since we create resource entries that point into
158
     it.  If we ever want to free up the resource information we read,
159
     this will have to be cleaned up.  */
160
 
161
  ret = read_coff_res_dir (&wrbfd, data, &finfo, (const rc_res_id *) NULL, 0);
162
 
163
  bfd_close (abfd);
164
 
165
  return ret;
166
}
167
 
168
/* Give an error if we are out of bounds.  */
169
 
170
static void
171
overrun (const struct coff_file_info *finfo, const char *msg)
172
{
173
  fatal (_("%s: %s: address out of bounds"), finfo->filename, msg);
174
}
175
 
176
/* Read a resource directory.  */
177
 
178
static rc_res_directory *
179
read_coff_res_dir (windres_bfd *wrbfd, const bfd_byte *data,
180
                   const struct coff_file_info *finfo,
181
                   const rc_res_id *type, int level)
182
{
183
  const struct extern_res_directory *erd;
184
  rc_res_directory *rd;
185
  int name_count, id_count, i;
186
  rc_res_entry **pp;
187
  const struct extern_res_entry *ere;
188
 
189
  if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_directory))
190
    overrun (finfo, _("directory"));
191
 
192
  erd = (const struct extern_res_directory *) data;
193
 
194
  rd = (rc_res_directory *) res_alloc (sizeof (rc_res_directory));
195
  rd->characteristics = windres_get_32 (wrbfd, erd->characteristics, 4);
196
  rd->time = windres_get_32 (wrbfd, erd->time, 4);
197
  rd->major = windres_get_16 (wrbfd, erd->major, 2);
198
  rd->minor = windres_get_16 (wrbfd, erd->minor, 2);
199
  rd->entries = NULL;
200
 
201
  name_count = windres_get_16 (wrbfd, erd->name_count, 2);
202
  id_count = windres_get_16 (wrbfd, erd->id_count, 2);
203
 
204
  pp = &rd->entries;
205
 
206
  /* The resource directory entries immediately follow the directory
207
     table.  */
208
  ere = (const struct extern_res_entry *) (erd + 1);
209
 
210
  for (i = 0; i < name_count; i++, ere++)
211
    {
212
      rc_uint_type name, rva;
213
      rc_res_entry *re;
214
      const bfd_byte *ers;
215
      int length, j;
216
 
217
      if ((const bfd_byte *) ere >= finfo->data_end)
218
        overrun (finfo, _("named directory entry"));
219
 
220
      name = windres_get_32 (wrbfd, ere->name, 4);
221
      rva = windres_get_32 (wrbfd, ere->rva, 4);
222
 
223
      /* For some reason the high bit in NAME is set.  */
224
      name &=~ 0x80000000;
225
 
226
      if (name > (rc_uint_type) (finfo->data_end - finfo->data))
227
        overrun (finfo, _("directory entry name"));
228
 
229
      ers = finfo->data + name;
230
 
231
      re = (rc_res_entry *) res_alloc (sizeof *re);
232
      re->next = NULL;
233
      re->id.named = 1;
234
      length = windres_get_16 (wrbfd, ers, 2);
235
      re->id.u.n.length = length;
236
      re->id.u.n.name = (unichar *) res_alloc (length * sizeof (unichar));
237
      for (j = 0; j < length; j++)
238
        re->id.u.n.name[j] = windres_get_16 (wrbfd, ers + j * 2 + 2, 2);
239
 
240
      if (level == 0)
241
        type = &re->id;
242
 
243
      if ((rva & 0x80000000) != 0)
244
        {
245
          rva &=~ 0x80000000;
246
          if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
247
            overrun (finfo, _("named subdirectory"));
248
          re->subdir = 1;
249
          re->u.dir = read_coff_res_dir (wrbfd, finfo->data + rva, finfo, type,
250
                                         level + 1);
251
        }
252
      else
253
        {
254
          if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
255
            overrun (finfo, _("named resource"));
256
          re->subdir = 0;
257
          re->u.res = read_coff_data_entry (wrbfd, finfo->data + rva, finfo, type);
258
        }
259
 
260
      *pp = re;
261
      pp = &re->next;
262
    }
263
 
264
  for (i = 0; i < id_count; i++, ere++)
265
    {
266
      unsigned long name, rva;
267
      rc_res_entry *re;
268
 
269
      if ((const bfd_byte *) ere >= finfo->data_end)
270
        overrun (finfo, _("ID directory entry"));
271
 
272
      name = windres_get_32 (wrbfd, ere->name, 4);
273
      rva = windres_get_32 (wrbfd, ere->rva, 4);
274
 
275
      re = (rc_res_entry *) res_alloc (sizeof *re);
276
      re->next = NULL;
277
      re->id.named = 0;
278
      re->id.u.id = name;
279
 
280
      if (level == 0)
281
        type = &re->id;
282
 
283
      if ((rva & 0x80000000) != 0)
284
        {
285
          rva &=~ 0x80000000;
286
          if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
287
            overrun (finfo, _("ID subdirectory"));
288
          re->subdir = 1;
289
          re->u.dir = read_coff_res_dir (wrbfd, finfo->data + rva, finfo, type,
290
                                         level + 1);
291
        }
292
      else
293
        {
294
          if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
295
            overrun (finfo, _("ID resource"));
296
          re->subdir = 0;
297
          re->u.res = read_coff_data_entry (wrbfd, finfo->data + rva, finfo, type);
298
        }
299
 
300
      *pp = re;
301
      pp = &re->next;
302
    }
303
 
304
  return rd;
305
}
306
 
307
/* Read a resource data entry.  */
308
 
309
static rc_res_resource *
310
read_coff_data_entry (windres_bfd *wrbfd, const bfd_byte *data,
311
                      const struct coff_file_info *finfo,
312
                      const rc_res_id *type)
313
{
314
  const struct extern_res_data *erd;
315
  rc_res_resource *r;
316
  rc_uint_type size, rva;
317
  const bfd_byte *resdata;
318
 
319
  if (type == NULL)
320
    fatal (_("resource type unknown"));
321
 
322
  if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_data))
323
    overrun (finfo, _("data entry"));
324
 
325
  erd = (const struct extern_res_data *) data;
326
 
327
  size = windres_get_32 (wrbfd, erd->size, 4);
328
  rva = windres_get_32 (wrbfd, erd->rva, 4);
329
  if (rva < finfo->secaddr
330
      || rva - finfo->secaddr >= (rc_uint_type) (finfo->data_end - finfo->data))
331
    overrun (finfo, _("resource data"));
332
 
333
  resdata = finfo->data + (rva - finfo->secaddr);
334
 
335
  if (size > (rc_uint_type) (finfo->data_end - resdata))
336
    overrun (finfo, _("resource data size"));
337
 
338
  r = bin_to_res (wrbfd, *type, resdata, size);
339
 
340
  memset (&r->res_info, 0, sizeof (rc_res_res_info));
341
  r->coff_info.codepage = windres_get_32 (wrbfd, erd->codepage, 4);
342
  r->coff_info.reserved = windres_get_32 (wrbfd, erd->reserved, 4);
343
 
344
  return r;
345
}
346
 
347
/* This structure is used to build a list of bindata structures.  */
348
 
349
struct bindata_build
350
{
351
  /* The data.  */
352
  bindata *d;
353
  /* The last structure we have added to the list.  */
354
  bindata *last;
355
  /* The size of the list as a whole.  */
356
  unsigned long length;
357
};
358
 
359
struct coff_res_data_build
360
{
361
  /* The data.  */
362
  coff_res_data *d;
363
  /* The last structure we have added to the list.  */
364
  coff_res_data *last;
365
  /* The size of the list as a whole.  */
366
  unsigned long length;
367
};
368
 
369
/* This structure keeps track of information as we build the directory
370
   tree.  */
371
 
372
struct coff_write_info
373
{
374
  /* These fields are based on the BFD.  */
375
  /* The BFD itself.  */
376
  windres_bfd *wrbfd;
377
  /* Pointer to section symbol used to build RVA relocs.  */
378
  asymbol **sympp;
379
 
380
  /* These fields are computed initially, and then not changed.  */
381
  /* Length of directory tables and entries.  */
382
  unsigned long dirsize;
383
  /* Length of directory entry strings.  */
384
  unsigned long dirstrsize;
385
  /* Length of resource data entries.  */
386
  unsigned long dataentsize;
387
 
388
  /* These fields are updated as we add data.  */
389
  /* Directory tables and entries.  */
390
  struct bindata_build dirs;
391
  /* Directory entry strings.  */
392
  struct bindata_build dirstrs;
393
  /* Resource data entries.  */
394
  struct bindata_build dataents;
395
  /* Actual resource data.  */
396
  struct coff_res_data_build resources;
397
  /* Relocations.  */
398
  arelent **relocs;
399
  /* Number of relocations.  */
400
  unsigned int reloc_count;
401
};
402
 
403
static void coff_bin_sizes (const rc_res_directory *, struct coff_write_info *);
404
static bfd_byte *coff_alloc (struct bindata_build *, rc_uint_type);
405
static void coff_to_bin
406
  (const rc_res_directory *, struct coff_write_info *);
407
static void coff_res_to_bin
408
  (const rc_res_resource *, struct coff_write_info *);
409
 
410
/* Write resources to a COFF file.  RESOURCES should already be
411
   sorted.
412
 
413
   Right now we always create a new file.  Someday we should also
414
   offer the ability to merge resources into an existing file.  This
415
   would require doing the basic work of objcopy, just modifying or
416
   adding the .rsrc section.  */
417
 
418
void
419
write_coff_file (const char *filename, const char *target,
420
                 const rc_res_directory *resources)
421
{
422
  bfd *abfd;
423
  asection *sec;
424
  struct coff_write_info cwi;
425
  windres_bfd wrbfd;
426
  bindata *d;
427
  coff_res_data *rd;
428
  unsigned long length, offset;
429
 
430
  if (filename == NULL)
431
    fatal (_("filename required for COFF output"));
432
 
433
  abfd = bfd_openw (filename, target);
434
  if (abfd == NULL)
435
    bfd_fatal (filename);
436
 
437
  if (! bfd_set_format (abfd, bfd_object))
438
    bfd_fatal ("bfd_set_format");
439
 
440
#if defined DLLTOOL_SH
441
  if (! bfd_set_arch_mach (abfd, bfd_arch_sh, 0))
442
    bfd_fatal ("bfd_set_arch_mach(sh)");
443
#elif defined DLLTOOL_MIPS
444
  if (! bfd_set_arch_mach (abfd, bfd_arch_mips, 0))
445
    bfd_fatal ("bfd_set_arch_mach(mips)");
446
#elif defined DLLTOOL_ARM
447
  if (! bfd_set_arch_mach (abfd, bfd_arch_arm, 0))
448
    bfd_fatal ("bfd_set_arch_mach(arm)");
449
#else
450
  /* FIXME: This is obviously i386 specific.  */
451
  if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
452
    bfd_fatal ("bfd_set_arch_mach(i386)");
453
#endif
454
 
455
  if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
456
    bfd_fatal ("bfd_set_file_flags");
457
 
458
  sec = bfd_make_section_with_flags (abfd, ".rsrc",
459
                                     (SEC_HAS_CONTENTS | SEC_ALLOC
460
                                      | SEC_LOAD | SEC_DATA));
461
  if (sec == NULL)
462
    bfd_fatal ("bfd_make_section");
463
 
464
  if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
465
    bfd_fatal ("bfd_set_symtab");
466
 
467
  /* Requiring this is probably a bug in BFD.  */
468
  sec->output_section = sec;
469
 
470
  /* The order of data in the .rsrc section is
471
       resource directory tables and entries
472
       resource directory strings
473
       resource data entries
474
       actual resource data
475
 
476
     We build these different types of data in different lists.  */
477
 
478
  set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD);
479
 
480
  cwi.wrbfd = &wrbfd;
481
  cwi.sympp = sec->symbol_ptr_ptr;
482
  cwi.dirsize = 0;
483
  cwi.dirstrsize = 0;
484
  cwi.dataentsize = 0;
485
  cwi.dirs.d = NULL;
486
  cwi.dirs.last = NULL;
487
  cwi.dirs.length = 0;
488
  cwi.dirstrs.d = NULL;
489
  cwi.dirstrs.last = NULL;
490
  cwi.dirstrs.length = 0;
491
  cwi.dataents.d = NULL;
492
  cwi.dataents.last = NULL;
493
  cwi.dataents.length = 0;
494
  cwi.resources.d = NULL;
495
  cwi.resources.last = NULL;
496
  cwi.resources.length = 0;
497
  cwi.relocs = NULL;
498
  cwi.reloc_count = 0;
499
 
500
  /* Work out the sizes of the resource directory entries, so that we
501
     know the various offsets we will need.  */
502
  coff_bin_sizes (resources, &cwi);
503
 
504
  /* Force the directory strings to be 32 bit aligned.  Every other
505
     structure is 32 bit aligned anyhow.  */
506
  cwi.dirstrsize = (cwi.dirstrsize + 3) &~ 3;
507
 
508
  /* Actually convert the resources to binary.  */
509
  coff_to_bin (resources, &cwi);
510
 
511
  /* Add another 2 bytes to the directory strings if needed for
512
     alignment.  */
513
  if ((cwi.dirstrs.length & 3) != 0)
514
    {
515
      bfd_byte *ex;
516
 
517
      ex = coff_alloc (&cwi.dirstrs, 2);
518
      ex[0] = 0;
519
      ex[1] = 0;
520
    }
521
 
522
  /* Make sure that the data we built came out to the same size as we
523
     calculated initially.  */
524
  assert (cwi.dirs.length == cwi.dirsize);
525
  assert (cwi.dirstrs.length == cwi.dirstrsize);
526
  assert (cwi.dataents.length == cwi.dataentsize);
527
 
528
  length = (cwi.dirsize
529
            + cwi.dirstrsize
530
            + cwi.dataentsize
531
            + cwi.resources.length);
532
 
533
  if (! bfd_set_section_size (abfd, sec, length))
534
    bfd_fatal ("bfd_set_section_size");
535
 
536
  bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
537
 
538
  offset = 0;
539
  for (d = cwi.dirs.d; d != NULL; d = d->next)
540
    {
541
      if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
542
        bfd_fatal ("bfd_set_section_contents");
543
      offset += d->length;
544
    }
545
  for (d = cwi.dirstrs.d; d != NULL; d = d->next)
546
    {
547
      set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
548
      offset += d->length;
549
    }
550
  for (d = cwi.dataents.d; d != NULL; d = d->next)
551
    {
552
      set_windres_bfd_content (&wrbfd, d->data, offset, d->length);
553
      offset += d->length;
554
    }
555
  for (rd = cwi.resources.d; rd != NULL; rd = rd->next)
556
    {
557
      res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res);
558
      offset += rd->length;
559
    }
560
 
561
  assert (offset == length);
562
 
563
  if (! bfd_close (abfd))
564
    bfd_fatal ("bfd_close");
565
 
566
  /* We allocated the relocs array using malloc.  */
567
  free (cwi.relocs);
568
}
569
 
570
/* Work out the sizes of the various fixed size resource directory
571
   entries.  This updates fields in CWI.  */
572
 
573
static void
574
coff_bin_sizes (const rc_res_directory *resdir,
575
                struct coff_write_info *cwi)
576
{
577
  const rc_res_entry *re;
578
 
579
  cwi->dirsize += sizeof (struct extern_res_directory);
580
 
581
  for (re = resdir->entries; re != NULL; re = re->next)
582
    {
583
      cwi->dirsize += sizeof (struct extern_res_entry);
584
 
585
      if (re->id.named)
586
        cwi->dirstrsize += re->id.u.n.length * 2 + 2;
587
 
588
      if (re->subdir)
589
        coff_bin_sizes (re->u.dir, cwi);
590
      else
591
        cwi->dataentsize += sizeof (struct extern_res_data);
592
    }
593
}
594
 
595
/* Allocate data for a particular list.  */
596
 
597
static bfd_byte *
598
coff_alloc (struct bindata_build *bb, rc_uint_type size)
599
{
600
  bindata *d;
601
 
602
  d = (bindata *) reswr_alloc (sizeof (bindata));
603
 
604
  d->next = NULL;
605
  d->data = (bfd_byte *) reswr_alloc (size);
606
  d->length = size;
607
 
608
  if (bb->d == NULL)
609
    bb->d = d;
610
  else
611
    bb->last->next = d;
612
  bb->last = d;
613
  bb->length += size;
614
 
615
  return d->data;
616
}
617
 
618
/* Convert the resource directory RESDIR to binary.  */
619
 
620
static void
621
coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi)
622
{
623
  struct extern_res_directory *erd;
624
  int ci, cn;
625
  const rc_res_entry *e;
626
  struct extern_res_entry *ere;
627
 
628
  /* Write out the directory table.  */
629
 
630
  erd = ((struct extern_res_directory *)
631
         coff_alloc (&cwi->dirs, sizeof (*erd)));
632
 
633
  windres_put_32 (cwi->wrbfd, erd->characteristics, resdir->characteristics);
634
  windres_put_32 (cwi->wrbfd, erd->time, resdir->time);
635
  windres_put_16 (cwi->wrbfd, erd->major, resdir->major);
636
  windres_put_16 (cwi->wrbfd, erd->minor, resdir->minor);
637
 
638
  ci = 0;
639
  cn = 0;
640
  for (e = resdir->entries; e != NULL; e = e->next)
641
    {
642
      if (e->id.named)
643
        ++cn;
644
      else
645
        ++ci;
646
    }
647
 
648
  windres_put_16 (cwi->wrbfd, erd->name_count, cn);
649
  windres_put_16 (cwi->wrbfd, erd->id_count, ci);
650
 
651
  /* Write out the data entries.  Note that we allocate space for all
652
     the entries before writing them out.  That permits a recursive
653
     call to work correctly when writing out subdirectories.  */
654
 
655
  ere = ((struct extern_res_entry *)
656
         coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere)));
657
  for (e = resdir->entries; e != NULL; e = e->next, ere++)
658
    {
659
      if (! e->id.named)
660
        windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id);
661
      else
662
        {
663
          bfd_byte *str;
664
          rc_uint_type i;
665
 
666
          /* For some reason existing files seem to have the high bit
667
             set on the address of the name, although that is not
668
             documented.  */
669
          windres_put_32 (cwi->wrbfd, ere->name,
670
                     0x80000000 | (cwi->dirsize + cwi->dirstrs.length));
671
 
672
          str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
673
          windres_put_16 (cwi->wrbfd, str, e->id.u.n.length);
674
          for (i = 0; i < e->id.u.n.length; i++)
675
            windres_put_16 (cwi->wrbfd, str + (i + 1) * sizeof (unichar), e->id.u.n.name[i]);
676
        }
677
 
678
      if (e->subdir)
679
        {
680
          windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length);
681
          coff_to_bin (e->u.dir, cwi);
682
        }
683
      else
684
        {
685
          windres_put_32 (cwi->wrbfd, ere->rva,
686
                     cwi->dirsize + cwi->dirstrsize + cwi->dataents.length);
687
 
688
          coff_res_to_bin (e->u.res, cwi);
689
        }
690
    }
691
}
692
 
693
/* Convert the resource RES to binary.  */
694
 
695
static void
696
coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi)
697
{
698
  arelent *r;
699
  struct extern_res_data *erd;
700
  coff_res_data *d;
701
 
702
  /* For some reason, although every other address is a section
703
     offset, the address of the resource data itself is an RVA.  That
704
     means that we need to generate a relocation for it.  We allocate
705
     the relocs array using malloc so that we can use realloc.  FIXME:
706
     This relocation handling is correct for the i386, but probably
707
     not for any other target.  */
708
 
709
  r = (arelent *) reswr_alloc (sizeof (arelent));
710
  r->sym_ptr_ptr = cwi->sympp;
711
  r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
712
  r->addend = 0;
713
  r->howto = bfd_reloc_type_lookup (WR_BFD (cwi->wrbfd), BFD_RELOC_RVA);
714
  if (r->howto == NULL)
715
    bfd_fatal (_("can't get BFD_RELOC_RVA relocation type"));
716
 
717
  cwi->relocs = xrealloc (cwi->relocs,
718
                          (cwi->reloc_count + 2) * sizeof (arelent *));
719
  cwi->relocs[cwi->reloc_count] = r;
720
  cwi->relocs[cwi->reloc_count + 1] = NULL;
721
  ++cwi->reloc_count;
722
 
723
  erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
724
 
725
  windres_put_32 (cwi->wrbfd, erd->rva,
726
             (cwi->dirsize
727
              + cwi->dirstrsize
728
              + cwi->dataentsize
729
              + cwi->resources.length));
730
  windres_put_32 (cwi->wrbfd, erd->codepage, res->coff_info.codepage);
731
  windres_put_32 (cwi->wrbfd, erd->reserved, res->coff_info.reserved);
732
 
733
  d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data));
734
  d->length = res_to_bin (NULL, (rc_uint_type) 0, res);
735
  d->res = res;
736
  d->next = NULL;
737
 
738
  if (cwi->resources.d == NULL)
739
    cwi->resources.d = d;
740
  else
741
    cwi->resources.last->next = d;
742
 
743
  cwi->resources.last = d;
744
  cwi->resources.length += (d->length + 3) & ~3;
745
 
746
  windres_put_32 (cwi->wrbfd, erd->size, d->length);
747
 
748
  /* Force the next resource to have 32 bit alignment.  */
749
  d->length = (d->length + 3) & ~3;
750
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.