1/* rescoff.c -- read and write resources in Windows COFF files. 2 Copyright 1997, 1998, 1999, 2000, 2003, 2007 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 2 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 44struct 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 58struct __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 76struct 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 86struct 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 101static void overrun (const struct coff_file_info *, const char *); 102static rc_res_directory *read_coff_res_dir (windres_bfd *, const bfd_byte *, 103 const struct coff_file_info *, 104 const rc_res_id *, int); 105static 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 111rc_res_directory * 112read_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 170static void 171overrun (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 178static rc_res_directory * 179read_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 309static rc_res_resource * 310read_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 349struct 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 359struct 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 372struct 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 403static void coff_bin_sizes (const rc_res_directory *, struct coff_write_info *); 404static bfd_byte *coff_alloc (struct bindata_build *, rc_uint_type); 405static void coff_to_bin 406 (const rc_res_directory *, struct coff_write_info *); 407static 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 418void 419write_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 (abfd, ".rsrc"); 459 if (sec == NULL) 460 bfd_fatal ("bfd_make_section"); 461 462 if (! bfd_set_section_flags (abfd, sec, 463 (SEC_HAS_CONTENTS | SEC_ALLOC 464 | SEC_LOAD | SEC_DATA))) 465 bfd_fatal ("bfd_set_section_flags"); 466 467 if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1)) 468 bfd_fatal ("bfd_set_symtab"); 469 470 /* Requiring this is probably a bug in BFD. */ 471 sec->output_section = sec; 472 473 /* The order of data in the .rsrc section is 474 resource directory tables and entries 475 resource directory strings 476 resource data entries 477 actual resource data 478 479 We build these different types of data in different lists. */ 480 481 set_windres_bfd (&wrbfd, abfd, sec, WR_KIND_BFD); 482 483 cwi.wrbfd = &wrbfd; 484 cwi.sympp = sec->symbol_ptr_ptr; 485 cwi.dirsize = 0; 486 cwi.dirstrsize = 0; 487 cwi.dataentsize = 0; 488 cwi.dirs.d = NULL; 489 cwi.dirs.last = NULL; 490 cwi.dirs.length = 0; 491 cwi.dirstrs.d = NULL; 492 cwi.dirstrs.last = NULL; 493 cwi.dirstrs.length = 0; 494 cwi.dataents.d = NULL; 495 cwi.dataents.last = NULL; 496 cwi.dataents.length = 0; 497 cwi.resources.d = NULL; 498 cwi.resources.last = NULL; 499 cwi.resources.length = 0; 500 cwi.relocs = NULL; 501 cwi.reloc_count = 0; 502 503 /* Work out the sizes of the resource directory entries, so that we 504 know the various offsets we will need. */ 505 coff_bin_sizes (resources, &cwi); 506 507 /* Force the directory strings to be 32 bit aligned. Every other 508 structure is 32 bit aligned anyhow. */ 509 cwi.dirstrsize = (cwi.dirstrsize + 3) &~ 3; 510 511 /* Actually convert the resources to binary. */ 512 coff_to_bin (resources, &cwi); 513 514 /* Add another 2 bytes to the directory strings if needed for 515 alignment. */ 516 if ((cwi.dirstrs.length & 3) != 0) 517 { 518 bfd_byte *ex; 519 520 ex = coff_alloc (&cwi.dirstrs, 2); 521 ex[0] = 0; 522 ex[1] = 0; 523 } 524 525 /* Make sure that the data we built came out to the same size as we 526 calculated initially. */ 527 assert (cwi.dirs.length == cwi.dirsize); 528 assert (cwi.dirstrs.length == cwi.dirstrsize); 529 assert (cwi.dataents.length == cwi.dataentsize); 530 531 length = (cwi.dirsize 532 + cwi.dirstrsize 533 + cwi.dataentsize 534 + cwi.resources.length); 535 536 if (! bfd_set_section_size (abfd, sec, length)) 537 bfd_fatal ("bfd_set_section_size"); 538 539 bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count); 540 541 offset = 0; 542 for (d = cwi.dirs.d; d != NULL; d = d->next) 543 { 544 if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length)) 545 bfd_fatal ("bfd_set_section_contents"); 546 offset += d->length; 547 } 548 for (d = cwi.dirstrs.d; d != NULL; d = d->next) 549 { 550 set_windres_bfd_content (&wrbfd, d->data, offset, d->length); 551 offset += d->length; 552 } 553 for (d = cwi.dataents.d; d != NULL; d = d->next) 554 { 555 set_windres_bfd_content (&wrbfd, d->data, offset, d->length); 556 offset += d->length; 557 } 558 for (rd = cwi.resources.d; rd != NULL; rd = rd->next) 559 { 560 res_to_bin (cwi.wrbfd, (rc_uint_type) offset, rd->res); 561 offset += rd->length; 562 } 563 564 assert (offset == length); 565 566 if (! bfd_close (abfd)) 567 bfd_fatal ("bfd_close"); 568 569 /* We allocated the relocs array using malloc. */ 570 free (cwi.relocs); 571} 572 573/* Work out the sizes of the various fixed size resource directory 574 entries. This updates fields in CWI. */ 575 576static void 577coff_bin_sizes (const rc_res_directory *resdir, 578 struct coff_write_info *cwi) 579{ 580 const rc_res_entry *re; 581 582 cwi->dirsize += sizeof (struct extern_res_directory); 583 584 for (re = resdir->entries; re != NULL; re = re->next) 585 { 586 cwi->dirsize += sizeof (struct extern_res_entry); 587 588 if (re->id.named) 589 cwi->dirstrsize += re->id.u.n.length * 2 + 2; 590 591 if (re->subdir) 592 coff_bin_sizes (re->u.dir, cwi); 593 else 594 cwi->dataentsize += sizeof (struct extern_res_data); 595 } 596} 597 598/* Allocate data for a particular list. */ 599 600static bfd_byte * 601coff_alloc (struct bindata_build *bb, rc_uint_type size) 602{ 603 bindata *d; 604 605 d = (bindata *) reswr_alloc (sizeof (bindata)); 606 607 d->next = NULL; 608 d->data = (bfd_byte *) reswr_alloc (size); 609 d->length = size; 610 611 if (bb->d == NULL) 612 bb->d = d; 613 else 614 bb->last->next = d; 615 bb->last = d; 616 bb->length += size; 617 618 return d->data; 619} 620 621/* Convert the resource directory RESDIR to binary. */ 622 623static void 624coff_to_bin (const rc_res_directory *resdir, struct coff_write_info *cwi) 625{ 626 struct extern_res_directory *erd; 627 int ci, cn; 628 const rc_res_entry *e; 629 struct extern_res_entry *ere; 630 631 /* Write out the directory table. */ 632 633 erd = ((struct extern_res_directory *) 634 coff_alloc (&cwi->dirs, sizeof (*erd))); 635 636 windres_put_32 (cwi->wrbfd, erd->characteristics, resdir->characteristics); 637 windres_put_32 (cwi->wrbfd, erd->time, resdir->time); 638 windres_put_16 (cwi->wrbfd, erd->major, resdir->major); 639 windres_put_16 (cwi->wrbfd, erd->minor, resdir->minor); 640 641 ci = 0; 642 cn = 0; 643 for (e = resdir->entries; e != NULL; e = e->next) 644 { 645 if (e->id.named) 646 ++cn; 647 else 648 ++ci; 649 } 650 651 windres_put_16 (cwi->wrbfd, erd->name_count, cn); 652 windres_put_16 (cwi->wrbfd, erd->id_count, ci); 653 654 /* Write out the data entries. Note that we allocate space for all 655 the entries before writing them out. That permits a recursive 656 call to work correctly when writing out subdirectories. */ 657 658 ere = ((struct extern_res_entry *) 659 coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere))); 660 for (e = resdir->entries; e != NULL; e = e->next, ere++) 661 { 662 if (! e->id.named) 663 windres_put_32 (cwi->wrbfd, ere->name, e->id.u.id); 664 else 665 { 666 bfd_byte *str; 667 rc_uint_type i; 668 669 /* For some reason existing files seem to have the high bit 670 set on the address of the name, although that is not 671 documented. */ 672 windres_put_32 (cwi->wrbfd, ere->name, 673 0x80000000 | (cwi->dirsize + cwi->dirstrs.length)); 674 675 str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2); 676 windres_put_16 (cwi->wrbfd, str, e->id.u.n.length); 677 for (i = 0; i < e->id.u.n.length; i++) 678 windres_put_16 (cwi->wrbfd, str + (i + 1) * sizeof (unichar), e->id.u.n.name[i]); 679 } 680 681 if (e->subdir) 682 { 683 windres_put_32 (cwi->wrbfd, ere->rva, 0x80000000 | cwi->dirs.length); 684 coff_to_bin (e->u.dir, cwi); 685 } 686 else 687 { 688 windres_put_32 (cwi->wrbfd, ere->rva, 689 cwi->dirsize + cwi->dirstrsize + cwi->dataents.length); 690 691 coff_res_to_bin (e->u.res, cwi); 692 } 693 } 694} 695 696/* Convert the resource RES to binary. */ 697 698static void 699coff_res_to_bin (const rc_res_resource *res, struct coff_write_info *cwi) 700{ 701 arelent *r; 702 struct extern_res_data *erd; 703 coff_res_data *d; 704 705 /* For some reason, although every other address is a section 706 offset, the address of the resource data itself is an RVA. That 707 means that we need to generate a relocation for it. We allocate 708 the relocs array using malloc so that we can use realloc. FIXME: 709 This relocation handling is correct for the i386, but probably 710 not for any other target. */ 711 712 r = (arelent *) reswr_alloc (sizeof (arelent)); 713 r->sym_ptr_ptr = cwi->sympp; 714 r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length; 715 r->addend = 0; 716 r->howto = bfd_reloc_type_lookup (WR_BFD (cwi->wrbfd), BFD_RELOC_RVA); 717 if (r->howto == NULL) 718 bfd_fatal (_("can't get BFD_RELOC_RVA relocation type")); 719 720 cwi->relocs = xrealloc (cwi->relocs, 721 (cwi->reloc_count + 2) * sizeof (arelent *)); 722 cwi->relocs[cwi->reloc_count] = r; 723 cwi->relocs[cwi->reloc_count + 1] = NULL; 724 ++cwi->reloc_count; 725 726 erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd)); 727 728 windres_put_32 (cwi->wrbfd, erd->rva, 729 (cwi->dirsize 730 + cwi->dirstrsize 731 + cwi->dataentsize 732 + cwi->resources.length)); 733 windres_put_32 (cwi->wrbfd, erd->codepage, res->coff_info.codepage); 734 windres_put_32 (cwi->wrbfd, erd->reserved, res->coff_info.reserved); 735 736 d = (coff_res_data *) reswr_alloc (sizeof (coff_res_data)); 737 d->length = res_to_bin (NULL, (rc_uint_type) 0, res); 738 d->res = res; 739 d->next = NULL; 740 741 if (cwi->resources.d == NULL) 742 cwi->resources.d = d; 743 else 744 cwi->resources.last->next = d; 745 746 cwi->resources.last = d; 747 cwi->resources.length += (d->length + 3) & ~3; 748 749 windres_put_32 (cwi->wrbfd, erd->size, d->length); 750 751 /* Force the next resource to have 32 bit alignment. */ 752 d->length = (d->length + 3) & ~3; 753} 754