bfd/elfnn-aarch64.c: Set st_value to zero for undefined symbols
[deliverable/binutils-gdb.git] / bfd / peXXigen.c
CommitLineData
277d1b5e 1/* Support for the generic parts of PE/PEI; the common executable parts.
b90efa5b 2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
277d1b5e
ILT
3 Written by Cygnus Solutions.
4
5e226794 5 This file is part of BFD, the Binary File Descriptor library.
277d1b5e 6
5e226794
NC
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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
5e226794 10 (at your option) any later version.
277d1b5e 11
5e226794
NC
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.
277d1b5e 16
5e226794
NC
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
cd123cb7
NC
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
277d1b5e 22
6fa957a9 23/* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
277d1b5e 24
6fa957a9 25 PE/PEI rearrangement (and code added): Donn Terry
ca09e32b 26 Softway Systems, Inc. */
277d1b5e
ILT
27
28/* Hey look, some documentation [and in a place you expect to find it]!
29
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
33
34 Another reference:
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
37
38 The *sole* difference between the pe format and the pei format is that the
39 latter has an MSDOS 2.0 .exe header on the front that prints the message
40 "This app must be run under Windows." (or some such).
41 (FIXME: Whether that statement is *really* true or not is unknown.
42 Are there more subtle differences between pe and pei formats?
43 For now assume there aren't. If you find one, then for God sakes
44 document it here!)
45
46 The Microsoft docs use the word "image" instead of "executable" because
47 the former can also refer to a DLL (shared library). Confusion can arise
48 because the `i' in `pei' also refers to "image". The `pe' format can
49 also create images (i.e. executables), it's just that to run on a win32
50 system you need to use the pei format.
51
52 FIXME: Please add more docs here so the next poor fool that has to hack
53 on this code has a chance of getting something accomplished without
ca09e32b 54 wasting too much time. */
277d1b5e 55
99ad8390
NC
56/* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
57 depending on whether we're compiling for straight PE or PE+. */
cbff5e0d
DD
58#define COFF_WITH_XX
59
277d1b5e 60#include "sysdep.h"
3db64b00 61#include "bfd.h"
277d1b5e
ILT
62#include "libbfd.h"
63#include "coff/internal.h"
5fdcb63c 64#include "bfdver.h"
5879bb8f
NC
65#ifdef HAVE_WCHAR_H
66#include <wchar.h>
67#endif
277d1b5e
ILT
68
69/* NOTE: it's strange to be including an architecture specific header
70 in what's supposed to be general (to PE/PEI) code. However, that's
71 where the definitions are, and they don't vary per architecture
72 within PE/PEI, so we get them from there. FIXME: The lack of
73 variance is an assumption which may prove to be incorrect if new
74 PE/PEI targets are created. */
99ad8390
NC
75#if defined COFF_WITH_pex64
76# include "coff/x86_64.h"
77#elif defined COFF_WITH_pep
cbff5e0d
DD
78# include "coff/ia64.h"
79#else
80# include "coff/i386.h"
81#endif
277d1b5e
ILT
82
83#include "coff/pe.h"
84#include "libcoff.h"
85#include "libpei.h"
5879bb8f 86#include "safe-ctype.h"
277d1b5e 87
99ad8390 88#if defined COFF_WITH_pep || defined COFF_WITH_pex64
cbff5e0d
DD
89# undef AOUTSZ
90# define AOUTSZ PEPAOUTSZ
91# define PEAOUTHDR PEPAOUTHDR
92#endif
93
5879bb8f
NC
94#define HighBitSet(val) ((val) & 0x80000000)
95#define SetHighBit(val) ((val) | 0x80000000)
96#define WithoutHighBit(val) ((val) & 0x7fffffff)
97
277d1b5e
ILT
98/* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
99 worked when the code was in peicode.h, but no longer work now that
100 the code is in peigen.c. PowerPC NT is said to be dead. If
101 anybody wants to revive the code, you will have to figure out how
102 to handle those issues. */
1725a96e 103\f
277d1b5e 104void
7920ce38 105_bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
277d1b5e 106{
6fa957a9
KH
107 SYMENT *ext = (SYMENT *) ext1;
108 struct internal_syment *in = (struct internal_syment *) in1;
277d1b5e 109
6fa957a9
KH
110 if (ext->e.e_name[0] == 0)
111 {
112 in->_n._n_n._n_zeroes = 0;
dc810e39 113 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
6fa957a9
KH
114 }
115 else
1725a96e 116 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
277d1b5e 117
dc810e39
AM
118 in->n_value = H_GET_32 (abfd, ext->e_value);
119 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
1725a96e 120
6fa957a9 121 if (sizeof (ext->e_type) == 2)
dc810e39 122 in->n_type = H_GET_16 (abfd, ext->e_type);
6fa957a9 123 else
dc810e39 124 in->n_type = H_GET_32 (abfd, ext->e_type);
1725a96e 125
dc810e39
AM
126 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
127 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
277d1b5e
ILT
128
129#ifndef STRICT_PE_FORMAT
6fa957a9 130 /* This is for Gnu-created DLLs. */
277d1b5e
ILT
131
132 /* The section symbols for the .idata$ sections have class 0x68
133 (C_SECTION), which MS documentation indicates is a section
134 symbol. Unfortunately, the value field in the symbol is simply a
135 copy of the .idata section's flags rather than something useful.
136 When these symbols are encountered, change the value to 0 so that
137 they will be handled somewhat correctly in the bfd code. */
138 if (in->n_sclass == C_SECTION)
139 {
383c383f 140 char namebuf[SYMNMLEN + 1];
ba775898 141 const char *name = NULL;
383c383f 142
277d1b5e
ILT
143 in->n_value = 0x0;
144
277d1b5e
ILT
145 /* Create synthetic empty sections as needed. DJ */
146 if (in->n_scnum == 0)
147 {
148 asection *sec;
1725a96e 149
383c383f
AM
150 name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
151 if (name == NULL)
201159ec
NC
152 {
153 _bfd_error_handler (_("%B: unable to find name for empty section"),
154 abfd);
155 bfd_set_error (bfd_error_invalid_target);
156 return;
157 }
158
383c383f
AM
159 sec = bfd_get_section_by_name (abfd, name);
160 if (sec != NULL)
161 in->n_scnum = sec->target_index;
277d1b5e 162 }
1725a96e 163
277d1b5e
ILT
164 if (in->n_scnum == 0)
165 {
166 int unused_section_number = 0;
167 asection *sec;
117ed4f8 168 flagword flags;
1725a96e 169
6fa957a9 170 for (sec = abfd->sections; sec; sec = sec->next)
277d1b5e 171 if (unused_section_number <= sec->target_index)
6fa957a9 172 unused_section_number = sec->target_index + 1;
277d1b5e 173
383c383f
AM
174 if (name == namebuf)
175 {
a50b1753 176 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
383c383f 177 if (name == NULL)
201159ec
NC
178 {
179 _bfd_error_handler (_("%B: out of memory creating name for empty section"),
180 abfd);
181 return;
182 }
383c383f
AM
183 strcpy ((char *) name, namebuf);
184 }
201159ec 185
117ed4f8
AM
186 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
187 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
383c383f 188 if (sec == NULL)
201159ec
NC
189 {
190 _bfd_error_handler (_("%B: unable to create fake empty section"),
191 abfd);
192 return;
193 }
277d1b5e
ILT
194
195 sec->vma = 0;
196 sec->lma = 0;
eea6121a 197 sec->size = 0;
277d1b5e
ILT
198 sec->filepos = 0;
199 sec->rel_filepos = 0;
200 sec->reloc_count = 0;
201 sec->line_filepos = 0;
202 sec->lineno_count = 0;
203 sec->userdata = NULL;
7920ce38 204 sec->next = NULL;
277d1b5e 205 sec->alignment_power = 2;
277d1b5e
ILT
206
207 sec->target_index = unused_section_number;
208
209 in->n_scnum = unused_section_number;
210 }
211 in->n_sclass = C_STAT;
277d1b5e
ILT
212 }
213#endif
214
215#ifdef coff_swap_sym_in_hook
216 /* This won't work in peigen.c, but since it's for PPC PE, it's not
9602af51 217 worth fixing. */
6fa957a9 218 coff_swap_sym_in_hook (abfd, ext1, in1);
277d1b5e
ILT
219#endif
220}
221
32ae0d80
NC
222static bfd_boolean
223abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
224{
225 bfd_vma abs_val = * (bfd_vma *) data;
226
3714081c 227 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
32ae0d80
NC
228}
229
277d1b5e 230unsigned int
7920ce38 231_bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
277d1b5e 232{
6fa957a9
KH
233 struct internal_syment *in = (struct internal_syment *) inp;
234 SYMENT *ext = (SYMENT *) extp;
1725a96e 235
6fa957a9
KH
236 if (in->_n._n_name[0] == 0)
237 {
dc810e39
AM
238 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
239 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
6fa957a9
KH
240 }
241 else
1725a96e 242 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
277d1b5e 243
32ae0d80
NC
244 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
245 symbol. This is a problem on 64-bit targets where we can generate
246 absolute symbols with values >= 1^32. We try to work around this
247 problem by finding a section whose base address is sufficient to
248 reduce the absolute value to < 1^32, and then transforming the
249 symbol into a section relative symbol. This of course is a hack. */
250 if (sizeof (in->n_value) > 4
40af4a36
NC
251 /* The strange computation of the shift amount is here in order to
252 avoid a compile time warning about the comparison always being
253 false. It does not matter if this test fails to work as expected
254 as the worst that can happen is that some absolute symbols are
255 needlessly converted into section relative symbols. */
256 && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
32ae0d80
NC
257 && in->n_scnum == -1)
258 {
259 asection * sec;
260
261 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
262 if (sec)
263 {
264 in->n_value -= sec->vma;
265 in->n_scnum = sec->target_index;
266 }
267 /* else: FIXME: The value is outside the range of any section. This
88667baf 268 happens for __image_base__ and __ImageBase and maybe some other
32ae0d80
NC
269 symbols as well. We should find a way to handle these values. */
270 }
271
dc810e39
AM
272 H_PUT_32 (abfd, in->n_value, ext->e_value);
273 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
1725a96e 274
9602af51 275 if (sizeof (ext->e_type) == 2)
dc810e39 276 H_PUT_16 (abfd, in->n_type, ext->e_type);
277d1b5e 277 else
dc810e39 278 H_PUT_32 (abfd, in->n_type, ext->e_type);
1725a96e 279
dc810e39
AM
280 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
281 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
277d1b5e
ILT
282
283 return SYMESZ;
284}
285
286void
7920ce38
NC
287_bfd_XXi_swap_aux_in (bfd * abfd,
288 void * ext1,
289 int type,
96d56e9f 290 int in_class,
7920ce38
NC
291 int indx ATTRIBUTE_UNUSED,
292 int numaux ATTRIBUTE_UNUSED,
293 void * in1)
277d1b5e 294{
6fa957a9
KH
295 AUXENT *ext = (AUXENT *) ext1;
296 union internal_auxent *in = (union internal_auxent *) in1;
297
201159ec
NC
298 /* PR 17521: Make sure that all fields in the aux structure
299 are initialised. */
300 memset (in, 0, sizeof * in);
96d56e9f 301 switch (in_class)
6fa957a9
KH
302 {
303 case C_FILE:
304 if (ext->x_file.x_fname[0] == 0)
305 {
306 in->x_file.x_n.x_zeroes = 0;
dc810e39 307 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
6fa957a9
KH
308 }
309 else
1725a96e 310 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
277d1b5e 311 return;
6fa957a9
KH
312
313 case C_STAT:
314 case C_LEAFSTAT:
315 case C_HIDDEN:
316 if (type == T_NULL)
317 {
318 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
319 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
320 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
dc810e39
AM
321 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
322 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
323 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
6fa957a9
KH
324 return;
325 }
326 break;
277d1b5e 327 }
277d1b5e 328
dc810e39
AM
329 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
330 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
277d1b5e 331
96d56e9f
NC
332 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
333 || ISTAG (in_class))
277d1b5e
ILT
334 {
335 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
336 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
337 }
338 else
339 {
340 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
dc810e39 341 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
277d1b5e 342 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
dc810e39 343 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
277d1b5e 344 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
dc810e39 345 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
277d1b5e 346 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
dc810e39 347 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
277d1b5e
ILT
348 }
349
6fa957a9
KH
350 if (ISFCN (type))
351 {
dc810e39 352 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
6fa957a9
KH
353 }
354 else
355 {
356 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
357 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
358 }
277d1b5e
ILT
359}
360
361unsigned int
7920ce38
NC
362_bfd_XXi_swap_aux_out (bfd * abfd,
363 void * inp,
364 int type,
96d56e9f 365 int in_class,
7920ce38
NC
366 int indx ATTRIBUTE_UNUSED,
367 int numaux ATTRIBUTE_UNUSED,
368 void * extp)
277d1b5e 369{
6fa957a9
KH
370 union internal_auxent *in = (union internal_auxent *) inp;
371 AUXENT *ext = (AUXENT *) extp;
372
7920ce38
NC
373 memset (ext, 0, AUXESZ);
374
96d56e9f 375 switch (in_class)
6fa957a9
KH
376 {
377 case C_FILE:
378 if (in->x_file.x_fname[0] == 0)
379 {
dc810e39
AM
380 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
381 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
6fa957a9
KH
382 }
383 else
1725a96e
NC
384 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
385
277d1b5e 386 return AUXESZ;
6fa957a9
KH
387
388 case C_STAT:
389 case C_LEAFSTAT:
390 case C_HIDDEN:
391 if (type == T_NULL)
392 {
393 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
394 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
395 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
dc810e39
AM
396 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
397 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
398 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
6fa957a9
KH
399 return AUXESZ;
400 }
401 break;
277d1b5e 402 }
277d1b5e 403
dc810e39
AM
404 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
405 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
277d1b5e 406
96d56e9f
NC
407 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
408 || ISTAG (in_class))
277d1b5e 409 {
6fa957a9
KH
410 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
411 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
277d1b5e
ILT
412 }
413 else
414 {
dc810e39
AM
415 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
416 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
417 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
418 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
419 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
420 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
421 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
422 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
277d1b5e
ILT
423 }
424
425 if (ISFCN (type))
dc810e39 426 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
277d1b5e
ILT
427 else
428 {
429 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
430 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
431 }
432
433 return AUXESZ;
434}
435
436void
7920ce38 437_bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
277d1b5e 438{
6fa957a9
KH
439 LINENO *ext = (LINENO *) ext1;
440 struct internal_lineno *in = (struct internal_lineno *) in1;
277d1b5e 441
dc810e39 442 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
6fa957a9 443 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
277d1b5e
ILT
444}
445
446unsigned int
7920ce38 447_bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
277d1b5e 448{
6fa957a9
KH
449 struct internal_lineno *in = (struct internal_lineno *) inp;
450 struct external_lineno *ext = (struct external_lineno *) outp;
dc810e39 451 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
277d1b5e
ILT
452
453 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
454 return LINESZ;
455}
456
457void
7920ce38
NC
458_bfd_XXi_swap_aouthdr_in (bfd * abfd,
459 void * aouthdr_ext1,
460 void * aouthdr_int1)
277d1b5e 461{
d13c9dc6 462 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
7920ce38 463 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
d13c9dc6
L
464 struct internal_aouthdr *aouthdr_int
465 = (struct internal_aouthdr *) aouthdr_int1;
466 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
277d1b5e 467
dc810e39
AM
468 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
469 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
470 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
471 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
472 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
473 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
277d1b5e 474 aouthdr_int->text_start =
dc810e39 475 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
36e9d67b 476
99ad8390 477#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
7920ce38 478 /* PE32+ does not have data_start member! */
277d1b5e 479 aouthdr_int->data_start =
dc810e39 480 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
d13c9dc6 481 a->BaseOfData = aouthdr_int->data_start;
fac41780 482#endif
277d1b5e 483
d13c9dc6
L
484 a->Magic = aouthdr_int->magic;
485 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
486 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
487 a->SizeOfCode = aouthdr_int->tsize ;
488 a->SizeOfInitializedData = aouthdr_int->dsize ;
489 a->SizeOfUninitializedData = aouthdr_int->bsize ;
490 a->AddressOfEntryPoint = aouthdr_int->entry;
491 a->BaseOfCode = aouthdr_int->text_start;
dc810e39
AM
492 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
493 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
494 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
277d1b5e 495 a->MajorOperatingSystemVersion =
dc810e39 496 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
277d1b5e 497 a->MinorOperatingSystemVersion =
dc810e39
AM
498 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
499 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
500 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
501 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
502 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
503 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
504 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
505 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
506 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
507 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
508 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
509 a->SizeOfStackReserve =
510 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
511 a->SizeOfStackCommit =
512 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
513 a->SizeOfHeapReserve =
514 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
515 a->SizeOfHeapCommit =
516 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
517 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
518 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
277d1b5e
ILT
519
520 {
521 int idx;
1725a96e 522
7e1e1988 523 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
36e9d67b 524 if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
7e1e1988
NC
525 {
526 (*_bfd_error_handler)
527 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
528 abfd, a->NumberOfRvaAndSizes);
86eafac0
NC
529 bfd_set_error (bfd_error_bad_value);
530
7e1e1988
NC
531 /* Paranoia: If the number is corrupt, then assume that the
532 actual entries themselves might be corrupt as well. */
533 a->NumberOfRvaAndSizes = 0;
534 }
535
ce63b7b3 536 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
277d1b5e 537 {
6fa957a9
KH
538 /* If data directory is empty, rva also should be 0. */
539 int size =
dc810e39 540 H_GET_32 (abfd, src->DataDirectory[idx][1]);
99ad8390 541
3028b4c0
DD
542 a->DataDirectory[idx].Size = size;
543
544 if (size)
1725a96e 545 a->DataDirectory[idx].VirtualAddress =
dc810e39 546 H_GET_32 (abfd, src->DataDirectory[idx][0]);
6fa957a9 547 else
3028b4c0 548 a->DataDirectory[idx].VirtualAddress = 0;
277d1b5e 549 }
36e9d67b
NC
550
551 while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
552 {
553 a->DataDirectory[idx].Size = 0;
554 a->DataDirectory[idx].VirtualAddress = 0;
555 idx ++;
556 }
277d1b5e
ILT
557 }
558
559 if (aouthdr_int->entry)
560 {
561 aouthdr_int->entry += a->ImageBase;
99ad8390 562#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
277d1b5e 563 aouthdr_int->entry &= 0xffffffff;
fac41780 564#endif
277d1b5e 565 }
1725a96e 566
9602af51 567 if (aouthdr_int->tsize)
277d1b5e
ILT
568 {
569 aouthdr_int->text_start += a->ImageBase;
99ad8390 570#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
277d1b5e 571 aouthdr_int->text_start &= 0xffffffff;
fac41780 572#endif
277d1b5e 573 }
1725a96e 574
99ad8390 575#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
7920ce38 576 /* PE32+ does not have data_start member! */
9602af51 577 if (aouthdr_int->dsize)
277d1b5e
ILT
578 {
579 aouthdr_int->data_start += a->ImageBase;
580 aouthdr_int->data_start &= 0xffffffff;
581 }
fac41780 582#endif
277d1b5e
ILT
583
584#ifdef POWERPC_LE_PE
585 /* These three fields are normally set up by ppc_relocate_section.
586 In the case of reading a file in, we can pick them up from the
587 DataDirectory. */
6c73cbb1
NC
588 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
589 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
590 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
277d1b5e 591#endif
277d1b5e
ILT
592}
593
5933bdc9
ILT
594/* A support function for below. */
595
596static void
7920ce38
NC
597add_data_entry (bfd * abfd,
598 struct internal_extra_pe_aouthdr *aout,
599 int idx,
600 char *name,
601 bfd_vma base)
277d1b5e
ILT
602{
603 asection *sec = bfd_get_section_by_name (abfd, name);
604
1725a96e 605 /* Add import directory information if it exists. */
277d1b5e
ILT
606 if ((sec != NULL)
607 && (coff_section_data (abfd, sec) != NULL)
608 && (pei_section_data (abfd, sec) != NULL))
609 {
1725a96e 610 /* If data directory is empty, rva also should be 0. */
3028b4c0
DD
611 int size = pei_section_data (abfd, sec)->virt_size;
612 aout->DataDirectory[idx].Size = size;
613
614 if (size)
6fa957a9
KH
615 {
616 aout->DataDirectory[idx].VirtualAddress =
617 (sec->vma - base) & 0xffffffff;
618 sec->flags |= SEC_DATA;
619 }
277d1b5e
ILT
620 }
621}
622
623unsigned int
7920ce38 624_bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
277d1b5e 625{
6fa957a9 626 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
cbff5e0d
DD
627 pe_data_type *pe = pe_data (abfd);
628 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
6fa957a9 629 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
fac41780 630 bfd_vma sa, fa, ib;
ca6dee30 631 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
4e1fc599 632
fac41780
JW
633 sa = extra->SectionAlignment;
634 fa = extra->FileAlignment;
635 ib = extra->ImageBase;
277d1b5e 636
6c73cbb1
NC
637 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
638 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
639 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
4e1fc599 640
9602af51 641 if (aouthdr_in->tsize)
277d1b5e
ILT
642 {
643 aouthdr_in->text_start -= ib;
99ad8390 644#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
277d1b5e 645 aouthdr_in->text_start &= 0xffffffff;
cbff5e0d 646#endif
277d1b5e 647 }
1725a96e 648
9602af51 649 if (aouthdr_in->dsize)
277d1b5e
ILT
650 {
651 aouthdr_in->data_start -= ib;
99ad8390 652#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
277d1b5e 653 aouthdr_in->data_start &= 0xffffffff;
cbff5e0d 654#endif
277d1b5e 655 }
1725a96e 656
9602af51 657 if (aouthdr_in->entry)
277d1b5e
ILT
658 {
659 aouthdr_in->entry -= ib;
99ad8390 660#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
277d1b5e 661 aouthdr_in->entry &= 0xffffffff;
cbff5e0d 662#endif
277d1b5e
ILT
663 }
664
6fa957a9
KH
665#define FA(x) (((x) + fa -1 ) & (- fa))
666#define SA(x) (((x) + sa -1 ) & (- sa))
277d1b5e 667
6fa957a9 668 /* We like to have the sizes aligned. */
277d1b5e
ILT
669 aouthdr_in->bsize = FA (aouthdr_in->bsize);
670
277d1b5e
ILT
671 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
672
8181c403 673 add_data_entry (abfd, extra, 0, ".edata", ib);
9602af51 674 add_data_entry (abfd, extra, 2, ".rsrc", ib);
8181c403 675 add_data_entry (abfd, extra, 3, ".pdata", ib);
2fbadf2c 676
c25cfdf8
NC
677 /* In theory we do not need to call add_data_entry for .idata$2 or
678 .idata$5. It will be done in bfd_coff_final_link where all the
679 required information is available. If however, we are not going
680 to perform a final link, eg because we have been invoked by objcopy
681 or strip, then we need to make sure that these Data Directory
682 entries are initialised properly.
683
684 So - we copy the input values into the output values, and then, if
685 a final link is going to be performed, it can overwrite them. */
6c73cbb1
NC
686 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
687 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
688 extra->DataDirectory[PE_TLS_TABLE] = tls;
c25cfdf8 689
6c73cbb1 690 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
c25cfdf8 691 /* Until other .idata fixes are made (pending patch), the entry for
7dee875e 692 .idata is needed for backwards compatibility. FIXME. */
c25cfdf8 693 add_data_entry (abfd, extra, 1, ".idata", ib);
4e1fc599 694
2fbadf2c
ILT
695 /* For some reason, the virtual size (which is what's set by
696 add_data_entry) for .reloc is not the same as the size recorded
697 in this slot by MSVC; it doesn't seem to cause problems (so far),
698 but since it's the best we've got, use it. It does do the right
699 thing for .pdata. */
cbff5e0d 700 if (pe->has_reloc_section)
8181c403 701 add_data_entry (abfd, extra, 5, ".reloc", ib);
277d1b5e
ILT
702
703 {
704 asection *sec;
d48bdb99 705 bfd_vma hsize = 0;
6fa957a9 706 bfd_vma dsize = 0;
d48bdb99 707 bfd_vma isize = 0;
6fa957a9 708 bfd_vma tsize = 0;
277d1b5e
ILT
709
710 for (sec = abfd->sections; sec; sec = sec->next)
711 {
7920ce38 712 int rounded = FA (sec->size);
277d1b5e 713
d48bdb99
AM
714 /* The first non-zero section filepos is the header size.
715 Sections without contents will have a filepos of 0. */
716 if (hsize == 0)
717 hsize = sec->filepos;
277d1b5e
ILT
718 if (sec->flags & SEC_DATA)
719 dsize += rounded;
720 if (sec->flags & SEC_CODE)
721 tsize += rounded;
5933bdc9
ILT
722 /* The image size is the total VIRTUAL size (which is what is
723 in the virt_size field). Files have been seen (from MSVC
724 5.0 link.exe) where the file size of the .data segment is
725 quite small compared to the virtual size. Without this
50572669
L
726 fix, strip munges the file.
727
728 FIXME: We need to handle holes between sections, which may
729 happpen when we covert from another format. We just use
730 the virtual address and virtual size of the last section
731 for the image size. */
98a96df7
CF
732 if (coff_section_data (abfd, sec) != NULL
733 && pei_section_data (abfd, sec) != NULL)
50572669
L
734 isize = (sec->vma - extra->ImageBase
735 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
277d1b5e
ILT
736 }
737
738 aouthdr_in->dsize = dsize;
739 aouthdr_in->tsize = tsize;
d48bdb99 740 extra->SizeOfHeaders = hsize;
50572669 741 extra->SizeOfImage = isize;
277d1b5e
ILT
742 }
743
dc810e39 744 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
277d1b5e 745
5fdcb63c
KT
746/* e.g. 219510000 is linker version 2.19 */
747#define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
5933bdc9
ILT
748
749 /* This piece of magic sets the "linker version" field to
750 LINKER_VERSION. */
dc810e39
AM
751 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
752 aouthdr_out->standard.vstamp);
753
754 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
755 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
756 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
757 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
277d1b5e 758 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
dc810e39 759 aouthdr_out->standard.text_start);
277d1b5e 760
99ad8390 761#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
c25cfdf8 762 /* PE32+ does not have data_start member! */
277d1b5e 763 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
dc810e39 764 aouthdr_out->standard.data_start);
fac41780 765#endif
277d1b5e 766
dc810e39
AM
767 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
768 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
769 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
770 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
771 aouthdr_out->MajorOperatingSystemVersion);
772 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
773 aouthdr_out->MinorOperatingSystemVersion);
774 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
775 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
776 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
777 aouthdr_out->MajorSubsystemVersion);
778 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
779 aouthdr_out->MinorSubsystemVersion);
780 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
781 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
782 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
783 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
784 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
785 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
fac41780 786 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
dc810e39 787 aouthdr_out->SizeOfStackReserve);
fac41780 788 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
dc810e39 789 aouthdr_out->SizeOfStackCommit);
fac41780 790 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
dc810e39 791 aouthdr_out->SizeOfHeapReserve);
fac41780 792 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
dc810e39
AM
793 aouthdr_out->SizeOfHeapCommit);
794 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
795 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
796 aouthdr_out->NumberOfRvaAndSizes);
277d1b5e
ILT
797 {
798 int idx;
1725a96e 799
36e9d67b 800 for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
277d1b5e 801 {
dc810e39
AM
802 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
803 aouthdr_out->DataDirectory[idx][0]);
804 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
805 aouthdr_out->DataDirectory[idx][1]);
277d1b5e
ILT
806 }
807 }
808
809 return AOUTSZ;
810}
811
812unsigned int
7920ce38 813_bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
277d1b5e
ILT
814{
815 int idx;
6fa957a9
KH
816 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
817 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
277d1b5e 818
441f34fa
L
819 if (pe_data (abfd)->has_reloc_section
820 || pe_data (abfd)->dont_strip_reloc)
277d1b5e
ILT
821 filehdr_in->f_flags &= ~F_RELFLG;
822
823 if (pe_data (abfd)->dll)
824 filehdr_in->f_flags |= F_DLL;
825
826 filehdr_in->pe.e_magic = DOSMAGIC;
827 filehdr_in->pe.e_cblp = 0x90;
828 filehdr_in->pe.e_cp = 0x3;
829 filehdr_in->pe.e_crlc = 0x0;
830 filehdr_in->pe.e_cparhdr = 0x4;
831 filehdr_in->pe.e_minalloc = 0x0;
832 filehdr_in->pe.e_maxalloc = 0xffff;
833 filehdr_in->pe.e_ss = 0x0;
834 filehdr_in->pe.e_sp = 0xb8;
835 filehdr_in->pe.e_csum = 0x0;
836 filehdr_in->pe.e_ip = 0x0;
837 filehdr_in->pe.e_cs = 0x0;
838 filehdr_in->pe.e_lfarlc = 0x40;
839 filehdr_in->pe.e_ovno = 0x0;
840
6fa957a9 841 for (idx = 0; idx < 4; idx++)
277d1b5e
ILT
842 filehdr_in->pe.e_res[idx] = 0x0;
843
844 filehdr_in->pe.e_oemid = 0x0;
845 filehdr_in->pe.e_oeminfo = 0x0;
846
6fa957a9 847 for (idx = 0; idx < 10; idx++)
277d1b5e
ILT
848 filehdr_in->pe.e_res2[idx] = 0x0;
849
850 filehdr_in->pe.e_lfanew = 0x80;
851
6fa957a9
KH
852 /* This next collection of data are mostly just characters. It
853 appears to be constant within the headers put on NT exes. */
277d1b5e
ILT
854 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
855 filehdr_in->pe.dos_message[1] = 0xcd09b400;
856 filehdr_in->pe.dos_message[2] = 0x4c01b821;
857 filehdr_in->pe.dos_message[3] = 0x685421cd;
858 filehdr_in->pe.dos_message[4] = 0x70207369;
859 filehdr_in->pe.dos_message[5] = 0x72676f72;
860 filehdr_in->pe.dos_message[6] = 0x63206d61;
861 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
862 filehdr_in->pe.dos_message[8] = 0x65622074;
863 filehdr_in->pe.dos_message[9] = 0x6e757220;
864 filehdr_in->pe.dos_message[10] = 0x206e6920;
865 filehdr_in->pe.dos_message[11] = 0x20534f44;
866 filehdr_in->pe.dos_message[12] = 0x65646f6d;
867 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
868 filehdr_in->pe.dos_message[14] = 0x24;
869 filehdr_in->pe.dos_message[15] = 0x0;
870 filehdr_in->pe.nt_signature = NT_SIGNATURE;
871
dc810e39
AM
872 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
873 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
277d1b5e 874
0cb112f7
CF
875 /* Only use a real timestamp if the option was chosen. */
876 if ((pe_data (abfd)->insert_timestamp))
61e2488c 877 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
0cb112f7 878
dc810e39
AM
879 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
880 filehdr_out->f_symptr);
881 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
882 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
883 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
277d1b5e 884
1725a96e 885 /* Put in extra dos header stuff. This data remains essentially
277d1b5e 886 constant, it just has to be tacked on to the beginning of all exes
1725a96e 887 for NT. */
dc810e39
AM
888 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
889 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
890 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
891 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
892 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
893 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
894 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
895 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
896 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
897 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
898 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
899 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
900 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
901 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
1725a96e
NC
902
903 for (idx = 0; idx < 4; idx++)
dc810e39 904 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
1725a96e 905
dc810e39
AM
906 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
907 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
1725a96e
NC
908
909 for (idx = 0; idx < 10; idx++)
dc810e39 910 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
1725a96e 911
dc810e39 912 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
277d1b5e 913
1725a96e 914 for (idx = 0; idx < 16; idx++)
dc810e39
AM
915 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
916 filehdr_out->dos_message[idx]);
277d1b5e 917
6fa957a9 918 /* Also put in the NT signature. */
dc810e39 919 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
277d1b5e 920
277d1b5e
ILT
921 return FILHSZ;
922}
923
924unsigned int
7920ce38 925_bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
277d1b5e 926{
6fa957a9
KH
927 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
928 FILHDR *filehdr_out = (FILHDR *) out;
277d1b5e 929
dc810e39
AM
930 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
931 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
932 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
933 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
934 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
935 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
936 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
277d1b5e
ILT
937
938 return FILHSZ;
939}
940
941unsigned int
7920ce38 942_bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
277d1b5e 943{
6fa957a9
KH
944 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
945 SCNHDR *scnhdr_ext = (SCNHDR *) out;
277d1b5e
ILT
946 unsigned int ret = SCNHSZ;
947 bfd_vma ps;
948 bfd_vma ss;
949
6fa957a9 950 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
277d1b5e
ILT
951
952 PUT_SCNHDR_VADDR (abfd,
9602af51 953 ((scnhdr_int->s_vaddr
6fa957a9 954 - pe_data (abfd)->pe_opthdr.ImageBase)
277d1b5e 955 & 0xffffffff),
dc810e39 956 scnhdr_ext->s_vaddr);
277d1b5e 957
5933bdc9
ILT
958 /* NT wants the size data to be rounded up to the next
959 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
960 sometimes). */
5933bdc9 961 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
277d1b5e 962 {
92dd4511 963 if (bfd_pei_p (abfd))
ff0c9faf
NC
964 {
965 ps = scnhdr_int->s_size;
966 ss = 0;
967 }
968 else
969 {
970 ps = 0;
971 ss = scnhdr_int->s_size;
972 }
277d1b5e
ILT
973 }
974 else
975 {
92dd4511 976 if (bfd_pei_p (abfd))
ff0c9faf
NC
977 ps = scnhdr_int->s_paddr;
978 else
979 ps = 0;
980
277d1b5e
ILT
981 ss = scnhdr_int->s_size;
982 }
983
984 PUT_SCNHDR_SIZE (abfd, ss,
dc810e39 985 scnhdr_ext->s_size);
277d1b5e 986
5933bdc9 987 /* s_paddr in PE is really the virtual size. */
dc810e39 988 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
277d1b5e
ILT
989
990 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
dc810e39 991 scnhdr_ext->s_scnptr);
277d1b5e 992 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
dc810e39 993 scnhdr_ext->s_relptr);
277d1b5e 994 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
dc810e39 995 scnhdr_ext->s_lnnoptr);
277d1b5e 996
277d1b5e 997 {
25c80428
NC
998 /* Extra flags must be set when dealing with PE. All sections should also
999 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
1000 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
1001 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1002 (this is especially important when dealing with the .idata section since
1003 the addresses for routines from .dlls must be overwritten). If .reloc
1004 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1005 (0x02000000). Also, the resource data should also be read and
1006 writable. */
1007
4e1fc599 1008 /* FIXME: Alignment is also encoded in this field, at least on PPC and
25c80428
NC
1009 ARM-WINCE. Although - how do we get the original alignment field
1010 back ? */
1011
1012 typedef struct
1013 {
1014 const char * section_name;
1015 unsigned long must_have;
1016 }
1017 pe_required_section_flags;
4e1fc599 1018
25c80428
NC
1019 pe_required_section_flags known_sections [] =
1020 {
1021 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1022 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1023 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1024 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1025 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1026 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1027 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1028 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1029 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1030 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1031 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1032 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1033 { NULL, 0}
1034 };
1035
1036 pe_required_section_flags * p;
1725a96e 1037
66bed356
DS
1038 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1039 we know exactly what this specific section wants so we remove it
1040 and then allow the must_have field to add it back in if necessary.
1041 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1042 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1043 by ld --enable-auto-import (if auto-import is actually needed),
1044 by ld --omagic, or by obcopy --writable-text. */
66bed356 1045
25c80428
NC
1046 for (p = known_sections; p->section_name; p++)
1047 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1048 {
3c9d0484
DS
1049 if (strcmp (scnhdr_int->s_name, ".text")
1050 || (bfd_get_file_flags (abfd) & WP_TEXT))
d48bdb99
AM
1051 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1052 scnhdr_int->s_flags |= p->must_have;
25c80428
NC
1053 break;
1054 }
1055
d48bdb99 1056 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
277d1b5e
ILT
1057 }
1058
cb43721d 1059 if (coff_data (abfd)->link_info
1049f94e 1060 && ! coff_data (abfd)->link_info->relocatable
cb43721d
ILT
1061 && ! coff_data (abfd)->link_info->shared
1062 && strcmp (scnhdr_int->s_name, ".text") == 0)
277d1b5e 1063 {
cb43721d 1064 /* By inference from looking at MS output, the 32 bit field
7dee875e 1065 which is the combination of the number_of_relocs and
cb43721d
ILT
1066 number_of_linenos is used for the line number count in
1067 executables. A 16-bit field won't do for cc1. The MS
1068 document says that the number of relocs is zero for
1069 executables, but the 17-th bit has been observed to be there.
1070 Overflow is not an issue: a 4G-line program will overflow a
1071 bunch of other fields long before this! */
dc810e39
AM
1072 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1073 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
277d1b5e 1074 }
277d1b5e
ILT
1075 else
1076 {
cb43721d 1077 if (scnhdr_int->s_nlnno <= 0xffff)
dc810e39 1078 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
cb43721d
ILT
1079 else
1080 {
1081 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1082 bfd_get_filename (abfd),
1083 scnhdr_int->s_nlnno);
1084 bfd_set_error (bfd_error_file_truncated);
dc810e39 1085 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
cb43721d
ILT
1086 ret = 0;
1087 }
1725a96e 1088
cd339148
NS
1089 /* Although we could encode 0xffff relocs here, we do not, to be
1090 consistent with other parts of bfd. Also it lets us warn, as
1091 we should never see 0xffff here w/o having the overflow flag
1092 set. */
1093 if (scnhdr_int->s_nreloc < 0xffff)
dc810e39 1094 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
cb43721d
ILT
1095 else
1096 {
1725a96e 1097 /* PE can deal with large #s of relocs, but not here. */
dc810e39 1098 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
3e4554a2 1099 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
dc810e39 1100 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
cb43721d 1101 }
277d1b5e
ILT
1102 }
1103 return ret;
1104}
1105
61e2488c
JT
1106void
1107_bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1108{
1109 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1110 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1111
1112 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1113 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1114 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1115 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1116 in->Type = H_GET_32(abfd, ext->Type);
1117 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1118 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1119 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1120}
1121
1122unsigned int
1123_bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1124{
1125 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1126 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1127
1128 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1129 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1130 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1131 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1132 H_PUT_32(abfd, in->Type, ext->Type);
1133 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1134 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1135 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1136
1137 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1138}
1139
1140static CODEVIEW_INFO *
1141_bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1142{
1143 char buffer[256+1];
1144
1145 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1146 return NULL;
1147
1148 if (bfd_bread (buffer, 256, abfd) < 4)
1149 return NULL;
1150
6e6e7cfc 1151 /* Ensure null termination of filename. */
61e2488c
JT
1152 buffer[256] = '\0';
1153
1154 cvinfo->CVSignature = H_GET_32(abfd, buffer);
1155 cvinfo->Age = 0;
1156
1157 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1158 && (length > sizeof (CV_INFO_PDB70)))
1159 {
1160 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1161
1162 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
6e6e7cfc
JT
1163
1164 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1165 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1166 as 16 bytes in big-endian order. */
1167 bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1168 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1169 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1170 memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1171
61e2488c
JT
1172 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1173 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1174
1175 return cvinfo;
1176 }
1177 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1178 && (length > sizeof (CV_INFO_PDB20)))
1179 {
1180 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1181 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1182 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1183 cvinfo->SignatureLength = 4;
1184 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1185
1186 return cvinfo;
1187 }
1188
1189 return NULL;
1190}
1191
1192unsigned int
1193_bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1194{
1195 unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1196 CV_INFO_PDB70 *cvinfo70;
1197 char buffer[size];
1198
1199 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1200 return 0;
1201
1202 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1203 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
6e6e7cfc
JT
1204
1205 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1206 in little-endian order, followed by 8 single bytes. */
1207 bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1208 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1209 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1210 memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1211
61e2488c
JT
1212 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1213 cvinfo70->PdbFileName[0] = '\0';
1214
1215 if (bfd_bwrite (buffer, size, abfd) != size)
1216 return 0;
1217
1218 return size;
1219}
1220
1725a96e 1221static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
7920ce38
NC
1222{
1223 N_("Export Directory [.edata (or where ever we found it)]"),
1224 N_("Import Directory [parts of .idata]"),
1225 N_("Resource Directory [.rsrc]"),
1226 N_("Exception Directory [.pdata]"),
1227 N_("Security Directory"),
1228 N_("Base Relocation Directory [.reloc]"),
1229 N_("Debug Directory"),
1230 N_("Description Directory"),
1231 N_("Special Directory"),
1232 N_("Thread Storage Directory [.tls]"),
1233 N_("Load Configuration Directory"),
1234 N_("Bound Import Directory"),
1235 N_("Import Address Table Directory"),
1236 N_("Delay Import Directory"),
6c73cbb1 1237 N_("CLR Runtime Header"),
7920ce38
NC
1238 N_("Reserved")
1239};
1725a96e 1240
277d1b5e
ILT
1241#ifdef POWERPC_LE_PE
1242/* The code for the PPC really falls in the "architecture dependent"
1243 category. However, it's not clear that anyone will ever care, so
1244 we're ignoring the issue for now; if/when PPC matters, some of this
1245 may need to go into peicode.h, or arguments passed to enable the
1246 PPC- specific code. */
1247#endif
1248
b34976b6 1249static bfd_boolean
7920ce38 1250pe_print_idata (bfd * abfd, void * vfile)
277d1b5e
ILT
1251{
1252 FILE *file = (FILE *) vfile;
a76b448c 1253 bfd_byte *data;
8181c403
AM
1254 asection *section;
1255 bfd_signed_vma adj;
277d1b5e
ILT
1256
1257#ifdef POWERPC_LE_PE
1258 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1259#endif
1260
a76b448c 1261 bfd_size_type datasize = 0;
277d1b5e 1262 bfd_size_type dataoff;
277d1b5e 1263 bfd_size_type i;
277d1b5e
ILT
1264 int onaline = 20;
1265
1266 pe_data_type *pe = pe_data (abfd);
1267 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1268
8181c403 1269 bfd_vma addr;
277d1b5e 1270
6c73cbb1 1271 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
277d1b5e 1272
6c73cbb1 1273 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
8181c403 1274 {
a76b448c
AM
1275 /* Maybe the extra header isn't there. Look for the section. */
1276 section = bfd_get_section_by_name (abfd, ".idata");
1277 if (section == NULL)
b34976b6 1278 return TRUE;
a76b448c
AM
1279
1280 addr = section->vma;
eea6121a 1281 datasize = section->size;
a76b448c 1282 if (datasize == 0)
b34976b6 1283 return TRUE;
8181c403 1284 }
a76b448c 1285 else
8181c403 1286 {
a76b448c
AM
1287 addr += extra->ImageBase;
1288 for (section = abfd->sections; section != NULL; section = section->next)
1289 {
eea6121a 1290 datasize = section->size;
a76b448c
AM
1291 if (addr >= section->vma && addr < section->vma + datasize)
1292 break;
1293 }
1294
1295 if (section == NULL)
1296 {
1297 fprintf (file,
1298 _("\nThere is an import table, but the section containing it could not be found\n"));
b34976b6 1299 return TRUE;
a76b448c 1300 }
b69c8728
JT
1301 else if (!(section->flags & SEC_HAS_CONTENTS))
1302 {
1303 fprintf (file,
1304 _("\nThere is an import table in %s, but that section has no contents\n"),
1305 section->name);
1306 return TRUE;
1307 }
8181c403 1308 }
5933bdc9 1309
8181c403
AM
1310 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1311 section->name, (unsigned long) addr);
277d1b5e 1312
8181c403 1313 dataoff = addr - section->vma;
277d1b5e
ILT
1314
1315#ifdef POWERPC_LE_PE
eea6121a 1316 if (rel_section != 0 && rel_section->size != 0)
277d1b5e
ILT
1317 {
1318 /* The toc address can be found by taking the starting address,
1319 which on the PPC locates a function descriptor. The
1320 descriptor consists of the function code starting address
1321 followed by the address of the toc. The starting address we
1322 get from the bfd, and the descriptor is supposed to be in the
1323 .reldata section. */
1324
1325 bfd_vma loadable_toc_address;
1326 bfd_vma toc_address;
1327 bfd_vma start_address;
eea6121a 1328 bfd_byte *data;
a50b2160 1329 bfd_vma offset;
8181c403 1330
eea6121a
AM
1331 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1332 {
1333 if (data != NULL)
1334 free (data);
1335 return FALSE;
1336 }
277d1b5e
ILT
1337
1338 offset = abfd->start_address - rel_section->vma;
1339
a50b2160
JJ
1340 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1341 {
1342 if (data != NULL)
1343 free (data);
1344 return FALSE;
1345 }
1346
db8503c4
AM
1347 start_address = bfd_get_32 (abfd, data + offset);
1348 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
277d1b5e
ILT
1349 toc_address = loadable_toc_address - 32768;
1350
9602af51 1351 fprintf (file,
6fa957a9
KH
1352 _("\nFunction descriptor located at the start address: %04lx\n"),
1353 (unsigned long int) (abfd->start_address));
277d1b5e
ILT
1354 fprintf (file,
1355 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1356 start_address, loadable_toc_address, toc_address);
eea6121a
AM
1357 if (data != NULL)
1358 free (data);
277d1b5e
ILT
1359 }
1360 else
1361 {
9602af51 1362 fprintf (file,
6fa957a9 1363 _("\nNo reldata section! Function descriptor not decoded.\n"));
277d1b5e
ILT
1364 }
1365#endif
1366
9602af51 1367 fprintf (file,
6fa957a9
KH
1368 _("\nThe Import Tables (interpreted %s section contents)\n"),
1369 section->name);
9602af51 1370 fprintf (file,
ca09e32b
NC
1371 _("\
1372 vma: Hint Time Forward DLL First\n\
1373 Table Stamp Chain Name Thunk\n"));
277d1b5e 1374
db8503c4 1375 /* Read the whole section. Some of the fields might be before dataoff. */
eea6121a
AM
1376 if (!bfd_malloc_and_get_section (abfd, section, &data))
1377 {
1378 if (data != NULL)
1379 free (data);
1380 return FALSE;
1381 }
277d1b5e 1382
db8503c4 1383 adj = section->vma - extra->ImageBase;
277d1b5e 1384
5e226794 1385 /* Print all image import descriptors. */
4e1fc599 1386 for (i = dataoff; i + onaline <= datasize; i += onaline)
277d1b5e
ILT
1387 {
1388 bfd_vma hint_addr;
1389 bfd_vma time_stamp;
1390 bfd_vma forward_chain;
1391 bfd_vma dll_name;
1392 bfd_vma first_thunk;
1393 int idx = 0;
1394 bfd_size_type j;
1395 char *dll;
1396
6c73cbb1 1397 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
4e1fc599
AM
1398 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1399 hint_addr = bfd_get_32 (abfd, data + i);
1400 time_stamp = bfd_get_32 (abfd, data + i + 4);
1401 forward_chain = bfd_get_32 (abfd, data + i + 8);
1402 dll_name = bfd_get_32 (abfd, data + i + 12);
1403 first_thunk = bfd_get_32 (abfd, data + i + 16);
5933bdc9
ILT
1404
1405 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
a76b448c
AM
1406 (unsigned long) hint_addr,
1407 (unsigned long) time_stamp,
1408 (unsigned long) forward_chain,
1409 (unsigned long) dll_name,
1410 (unsigned long) first_thunk);
277d1b5e
ILT
1411
1412 if (hint_addr == 0 && first_thunk == 0)
1413 break;
1414
a50b2160
JJ
1415 if (dll_name - adj >= section->size)
1416 break;
1417
8181c403 1418 dll = (char *) data + dll_name - adj;
36e9d67b
NC
1419 /* PR 17512 file: 078-12277-0.004. */
1420 bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1421 fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
277d1b5e
ILT
1422
1423 if (hint_addr != 0)
1424 {
6e7c73dd
CF
1425 bfd_byte *ft_data;
1426 asection *ft_section;
1427 bfd_vma ft_addr;
1428 bfd_size_type ft_datasize;
1429 int ft_idx;
4e1fc599 1430 int ft_allocated;
6e7c73dd 1431
5e226794 1432 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
277d1b5e 1433
8181c403 1434 idx = hint_addr - adj;
4e1fc599 1435
5e226794 1436 ft_addr = first_thunk + extra->ImageBase;
6e7c73dd 1437 ft_idx = first_thunk - adj;
4e1fc599
AM
1438 ft_data = data + ft_idx;
1439 ft_datasize = datasize - ft_idx;
1440 ft_allocated = 0;
6c73cbb1
NC
1441
1442 if (first_thunk != hint_addr)
6e7c73dd
CF
1443 {
1444 /* Find the section which contains the first thunk. */
1445 for (ft_section = abfd->sections;
1446 ft_section != NULL;
1447 ft_section = ft_section->next)
1448 {
6e7c73dd 1449 if (ft_addr >= ft_section->vma
4e1fc599 1450 && ft_addr < ft_section->vma + ft_section->size)
6e7c73dd
CF
1451 break;
1452 }
1453
1454 if (ft_section == NULL)
1455 {
1456 fprintf (file,
1457 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1458 continue;
1459 }
1460
1461 /* Now check to see if this section is the same as our current
1462 section. If it is not then we will have to load its data in. */
4e1fc599 1463 if (ft_section != section)
6e7c73dd
CF
1464 {
1465 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
4e1fc599
AM
1466 ft_datasize = ft_section->size - ft_idx;
1467 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
6e7c73dd
CF
1468 if (ft_data == NULL)
1469 continue;
1470
4e1fc599
AM
1471 /* Read ft_datasize bytes starting at offset ft_idx. */
1472 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1473 (bfd_vma) ft_idx, ft_datasize))
6e7c73dd
CF
1474 {
1475 free (ft_data);
1476 continue;
1477 }
6e7c73dd
CF
1478 ft_allocated = 1;
1479 }
1480 }
5e226794
NC
1481
1482 /* Print HintName vector entries. */
99ad8390 1483#ifdef COFF_WITH_pex64
4e1fc599 1484 for (j = 0; idx + j + 8 <= datasize; j += 8)
99ad8390 1485 {
f41e4712 1486 bfd_size_type amt;
99ad8390
NC
1487 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1488 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1489
1490 if (!member && !member_high)
1491 break;
1492
f41e4712
NC
1493 amt = member - adj;
1494
5879bb8f 1495 if (HighBitSet (member_high))
99ad8390 1496 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
5879bb8f
NC
1497 member_high, member,
1498 WithoutHighBit (member_high), member);
20ad5e28 1499 /* PR binutils/17512: Handle corrupt PE data. */
f41e4712 1500 else if (amt + 2 >= datasize)
20ad5e28 1501 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
99ad8390
NC
1502 else
1503 {
1504 int ordinal;
1505 char *member_name;
1506
f41e4712
NC
1507 ordinal = bfd_get_16 (abfd, data + amt);
1508 member_name = (char *) data + amt + 2;
1509 fprintf (file, "\t%04lx\t %4d %.*s",member, ordinal,
1510 (int) (datasize - (amt + 2)), member_name);
99ad8390
NC
1511 }
1512
1513 /* If the time stamp is not zero, the import address
1514 table holds actual addresses. */
1515 if (time_stamp != 0
1516 && first_thunk != 0
4e1fc599
AM
1517 && first_thunk != hint_addr
1518 && j + 4 <= ft_datasize)
99ad8390 1519 fprintf (file, "\t%04lx",
4e1fc599 1520 (unsigned long) bfd_get_32 (abfd, ft_data + j));
99ad8390
NC
1521 fprintf (file, "\n");
1522 }
1523#else
4e1fc599 1524 for (j = 0; idx + j + 4 <= datasize; j += 4)
277d1b5e 1525 {
f41e4712 1526 bfd_size_type amt;
277d1b5e
ILT
1527 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1528
4e1fc599 1529 /* Print single IMAGE_IMPORT_BY_NAME vector. */
277d1b5e
ILT
1530 if (member == 0)
1531 break;
5e226794 1532
f41e4712 1533 amt = member - adj;
5879bb8f 1534 if (HighBitSet (member))
5e226794 1535 fprintf (file, "\t%04lx\t %4lu <none>",
5879bb8f 1536 member, WithoutHighBit (member));
20ad5e28 1537 /* PR binutils/17512: Handle corrupt PE data. */
f41e4712 1538 else if (amt + 2 >= datasize)
20ad5e28 1539 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
277d1b5e
ILT
1540 else
1541 {
1542 int ordinal;
1543 char *member_name;
1544
f41e4712
NC
1545 ordinal = bfd_get_16 (abfd, data + amt);
1546 member_name = (char *) data + amt + 2;
1547 fprintf (file, "\t%04lx\t %4d %.*s",
1548 member, ordinal,
1549 (int) (datasize - (amt + 2)), member_name);
277d1b5e 1550 }
5e226794 1551
277d1b5e 1552 /* If the time stamp is not zero, the import address
5e226794
NC
1553 table holds actual addresses. */
1554 if (time_stamp != 0
1555 && first_thunk != 0
4e1fc599
AM
1556 && first_thunk != hint_addr
1557 && j + 4 <= ft_datasize)
277d1b5e 1558 fprintf (file, "\t%04lx",
4e1fc599 1559 (unsigned long) bfd_get_32 (abfd, ft_data + j));
277d1b5e
ILT
1560
1561 fprintf (file, "\n");
1562 }
99ad8390 1563#endif
e4cf60a8
NC
1564 if (ft_allocated)
1565 free (ft_data);
277d1b5e
ILT
1566 }
1567
9602af51 1568 fprintf (file, "\n");
277d1b5e
ILT
1569 }
1570
1571 free (data);
1572
b34976b6 1573 return TRUE;
277d1b5e
ILT
1574}
1575
b34976b6 1576static bfd_boolean
7920ce38 1577pe_print_edata (bfd * abfd, void * vfile)
277d1b5e
ILT
1578{
1579 FILE *file = (FILE *) vfile;
a76b448c 1580 bfd_byte *data;
8181c403 1581 asection *section;
a76b448c 1582 bfd_size_type datasize = 0;
277d1b5e
ILT
1583 bfd_size_type dataoff;
1584 bfd_size_type i;
b69c8728 1585 bfd_vma adj;
1725a96e
NC
1586 struct EDT_type
1587 {
7920ce38 1588 long export_flags; /* Reserved - should be zero. */
6fa957a9
KH
1589 long time_stamp;
1590 short major_ver;
1591 short minor_ver;
7920ce38
NC
1592 bfd_vma name; /* RVA - relative to image base. */
1593 long base; /* Ordinal base. */
1594 unsigned long num_functions;/* Number in the export address table. */
1595 unsigned long num_names; /* Number in the name pointer table. */
1596 bfd_vma eat_addr; /* RVA to the export address table. */
1597 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1598 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
6fa957a9 1599 } edt;
277d1b5e
ILT
1600
1601 pe_data_type *pe = pe_data (abfd);
1602 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1603
8181c403 1604 bfd_vma addr;
277d1b5e 1605
6c73cbb1 1606 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
277d1b5e 1607
6c73cbb1 1608 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
8181c403 1609 {
a76b448c
AM
1610 /* Maybe the extra header isn't there. Look for the section. */
1611 section = bfd_get_section_by_name (abfd, ".edata");
1612 if (section == NULL)
b34976b6 1613 return TRUE;
a76b448c
AM
1614
1615 addr = section->vma;
0facbdf5 1616 dataoff = 0;
eea6121a 1617 datasize = section->size;
a76b448c 1618 if (datasize == 0)
b34976b6 1619 return TRUE;
8181c403 1620 }
a76b448c 1621 else
8181c403 1622 {
a76b448c 1623 addr += extra->ImageBase;
1725a96e 1624
a76b448c 1625 for (section = abfd->sections; section != NULL; section = section->next)
0facbdf5
NC
1626 if (addr >= section->vma && addr < section->vma + section->size)
1627 break;
a76b448c
AM
1628
1629 if (section == NULL)
1630 {
1631 fprintf (file,
1632 _("\nThere is an export table, but the section containing it could not be found\n"));
b34976b6 1633 return TRUE;
a76b448c 1634 }
b69c8728
JT
1635 else if (!(section->flags & SEC_HAS_CONTENTS))
1636 {
1637 fprintf (file,
1638 _("\nThere is an export table in %s, but that section has no contents\n"),
1639 section->name);
1640 return TRUE;
1641 }
0facbdf5
NC
1642
1643 dataoff = addr - section->vma;
6c73cbb1 1644 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
0facbdf5
NC
1645 if (datasize > section->size - dataoff)
1646 {
1647 fprintf (file,
1648 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1649 section->name);
1650 return TRUE;
1651 }
277d1b5e
ILT
1652 }
1653
5a4b0ccc
NC
1654 /* PR 17512: Handle corrupt PE binaries. */
1655 if (datasize < 36)
1656 {
1657 fprintf (file,
1658 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1659 section->name, (int) datasize);
1660 return TRUE;
1661 }
1662
8181c403
AM
1663 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1664 section->name, (unsigned long) addr);
1665
a50b1753 1666 data = (bfd_byte *) bfd_malloc (datasize);
8181c403 1667 if (data == NULL)
b34976b6 1668 return FALSE;
277d1b5e 1669
7920ce38 1670 if (! bfd_get_section_contents (abfd, section, data,
dc810e39 1671 (file_ptr) dataoff, datasize))
b34976b6 1672 return FALSE;
277d1b5e 1673
6fa957a9
KH
1674 /* Go get Export Directory Table. */
1675 edt.export_flags = bfd_get_32 (abfd, data + 0);
1676 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1677 edt.major_ver = bfd_get_16 (abfd, data + 8);
1678 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1679 edt.name = bfd_get_32 (abfd, data + 12);
1680 edt.base = bfd_get_32 (abfd, data + 16);
1681 edt.num_functions = bfd_get_32 (abfd, data + 20);
1682 edt.num_names = bfd_get_32 (abfd, data + 24);
1683 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1684 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1685 edt.ot_addr = bfd_get_32 (abfd, data + 36);
277d1b5e 1686
8181c403 1687 adj = section->vma - extra->ImageBase + dataoff;
277d1b5e 1688
1725a96e 1689 /* Dump the EDT first. */
9602af51 1690 fprintf (file,
6fa957a9
KH
1691 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1692 section->name);
277d1b5e 1693
9602af51 1694 fprintf (file,
6fa957a9 1695 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
277d1b5e 1696
9602af51 1697 fprintf (file,
6fa957a9 1698 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
277d1b5e 1699
9602af51 1700 fprintf (file,
6fa957a9 1701 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
277d1b5e
ILT
1702
1703 fprintf (file,
1704 _("Name \t\t\t\t"));
ebf12fbe 1705 bfd_fprintf_vma (abfd, file, edt.name);
b69c8728
JT
1706
1707 if ((edt.name >= adj) && (edt.name < adj + datasize))
201159ec
NC
1708 fprintf (file, " %.*s\n",
1709 (int) (datasize - (edt.name - adj)),
1710 data + edt.name - adj);
b69c8728
JT
1711 else
1712 fprintf (file, "(outside .edata section)\n");
277d1b5e 1713
9602af51 1714 fprintf (file,
6fa957a9 1715 _("Ordinal Base \t\t\t%ld\n"), edt.base);
277d1b5e 1716
9602af51 1717 fprintf (file,
6fa957a9 1718 _("Number in:\n"));
277d1b5e 1719
9602af51 1720 fprintf (file,
6fa957a9
KH
1721 _("\tExport Address Table \t\t%08lx\n"),
1722 edt.num_functions);
277d1b5e 1723
9602af51 1724 fprintf (file,
6fa957a9 1725 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
277d1b5e 1726
9602af51 1727 fprintf (file,
6fa957a9 1728 _("Table Addresses\n"));
277d1b5e
ILT
1729
1730 fprintf (file,
1731 _("\tExport Address Table \t\t"));
ebf12fbe 1732 bfd_fprintf_vma (abfd, file, edt.eat_addr);
277d1b5e
ILT
1733 fprintf (file, "\n");
1734
1735 fprintf (file,
6fa957a9 1736 _("\tName Pointer Table \t\t"));
ebf12fbe 1737 bfd_fprintf_vma (abfd, file, edt.npt_addr);
277d1b5e
ILT
1738 fprintf (file, "\n");
1739
1740 fprintf (file,
1741 _("\tOrdinal Table \t\t\t"));
ebf12fbe 1742 bfd_fprintf_vma (abfd, file, edt.ot_addr);
277d1b5e
ILT
1743 fprintf (file, "\n");
1744
5933bdc9 1745 /* The next table to find is the Export Address Table. It's basically
277d1b5e
ILT
1746 a list of pointers that either locate a function in this dll, or
1747 forward the call to another dll. Something like:
1725a96e
NC
1748 typedef union
1749 {
277d1b5e
ILT
1750 long export_rva;
1751 long forwarder_rva;
7920ce38 1752 } export_address_table_entry; */
277d1b5e 1753
9602af51 1754 fprintf (file,
277d1b5e
ILT
1755 _("\nExport Address Table -- Ordinal Base %ld\n"),
1756 edt.base);
1757
bf67003b 1758 /* PR 17512: Handle corrupt PE binaries. */
36e9d67b
NC
1759 if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize
1760 /* PR 17512 file: 140-165018-0.004. */
1761 || data + edt.eat_addr - adj < data)
bf67003b
NC
1762 fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1763 (long) edt.eat_addr,
1764 (long) edt.num_functions);
1765 else for (i = 0; i < edt.num_functions; ++i)
277d1b5e
ILT
1766 {
1767 bfd_vma eat_member = bfd_get_32 (abfd,
8181c403 1768 data + edt.eat_addr + (i * 4) - adj);
277d1b5e
ILT
1769 if (eat_member == 0)
1770 continue;
1771
db8503c4 1772 if (eat_member - adj <= datasize)
277d1b5e 1773 {
db8503c4 1774 /* This rva is to a name (forwarding function) in our section. */
6fa957a9 1775 /* Should locate a function descriptor. */
5933bdc9 1776 fprintf (file,
36e9d67b 1777 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
a76b448c
AM
1778 (long) i,
1779 (long) (i + edt.base),
1780 (unsigned long) eat_member,
1781 _("Forwarder RVA"),
36e9d67b 1782 (int)(datasize - (eat_member - adj)),
a76b448c 1783 data + eat_member - adj);
277d1b5e
ILT
1784 }
1785 else
1786 {
6fa957a9 1787 /* Should locate a function descriptor in the reldata section. */
5933bdc9
ILT
1788 fprintf (file,
1789 "\t[%4ld] +base[%4ld] %04lx %s\n",
a76b448c
AM
1790 (long) i,
1791 (long) (i + edt.base),
1792 (unsigned long) eat_member,
5933bdc9 1793 _("Export RVA"));
277d1b5e
ILT
1794 }
1795 }
1796
6fa957a9
KH
1797 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1798 /* Dump them in parallel for clarity. */
9602af51 1799 fprintf (file,
6fa957a9 1800 _("\n[Ordinal/Name Pointer] Table\n"));
277d1b5e 1801
bf67003b 1802 /* PR 17512: Handle corrupt PE binaries. */
36e9d67b
NC
1803 if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1804 || (data + edt.npt_addr - adj) < data)
bf67003b
NC
1805 fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1806 (long) edt.npt_addr,
1807 (long) edt.num_names);
36e9d67b
NC
1808 /* PR 17512: file: 140-147171-0.004. */
1809 else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1810 || data + edt.ot_addr - adj < data)
bf67003b
NC
1811 fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1812 (long) edt.ot_addr,
1813 (long) edt.num_names);
1814 else for (i = 0; i < edt.num_names; ++i)
277d1b5e 1815 {
20ad5e28
NC
1816 bfd_vma name_ptr;
1817 bfd_vma ord;
9602af51 1818
20ad5e28
NC
1819 ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1820 name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
277d1b5e 1821
20ad5e28
NC
1822 if ((name_ptr - adj) >= datasize)
1823 {
1824 fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1825 (long) ord, (long) name_ptr);
1826 }
1827 else
1828 {
1829 char * name = (char *) data + name_ptr - adj;
1830
36e9d67b
NC
1831 fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1832 (int)((char *)(data + datasize) - name), name);
20ad5e28 1833 }
277d1b5e
ILT
1834 }
1835
1836 free (data);
1837
b34976b6 1838 return TRUE;
277d1b5e
ILT
1839}
1840
fac41780
JW
1841/* This really is architecture dependent. On IA-64, a .pdata entry
1842 consists of three dwords containing relative virtual addresses that
1843 specify the start and end address of the code range the entry
4e1fc599 1844 covers and the address of the corresponding unwind info data.
2b5c217d
NC
1845
1846 On ARM and SH-4, a compressed PDATA structure is used :
1847 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1848 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1849 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1850
799c00e0 1851 This is the version for uncompressed data. */
6fa957a9 1852
b34976b6 1853static bfd_boolean
7920ce38 1854pe_print_pdata (bfd * abfd, void * vfile)
277d1b5e 1855{
99ad8390
NC
1856#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1857# define PDATA_ROW_SIZE (3 * 8)
fac41780 1858#else
99ad8390 1859# define PDATA_ROW_SIZE (5 * 4)
fac41780 1860#endif
277d1b5e
ILT
1861 FILE *file = (FILE *) vfile;
1862 bfd_byte *data = 0;
1863 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1864 bfd_size_type datasize = 0;
1865 bfd_size_type i;
1866 bfd_size_type start, stop;
fac41780 1867 int onaline = PDATA_ROW_SIZE;
277d1b5e 1868
5933bdc9
ILT
1869 if (section == NULL
1870 || coff_section_data (abfd, section) == NULL
1871 || pei_section_data (abfd, section) == NULL)
b34976b6 1872 return TRUE;
277d1b5e 1873
5933bdc9 1874 stop = pei_section_data (abfd, section)->virt_size;
277d1b5e 1875 if ((stop % onaline) != 0)
6fa957a9
KH
1876 fprintf (file,
1877 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1878 (long) stop, onaline);
277d1b5e 1879
5933bdc9
ILT
1880 fprintf (file,
1881 _("\nThe Function Table (interpreted .pdata section contents)\n"));
99ad8390 1882#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
9602af51 1883 fprintf (file,
6fa957a9 1884 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
fac41780 1885#else
ca09e32b
NC
1886 fprintf (file, _("\
1887 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1888 \t\tAddress Address Handler Data Address Mask\n"));
fac41780 1889#endif
277d1b5e 1890
eea6121a 1891 datasize = section->size;
dc810e39 1892 if (datasize == 0)
b34976b6 1893 return TRUE;
277d1b5e 1894
6937bb54
NC
1895 /* PR 17512: file: 002-193900-0.004. */
1896 if (datasize < stop)
1897 {
1898 fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1899 (long) stop, (long) datasize);
1900 return FALSE;
1901 }
1902
7920ce38 1903 if (! bfd_malloc_and_get_section (abfd, section, &data))
eea6121a
AM
1904 {
1905 if (data != NULL)
1906 free (data);
1907 return FALSE;
1908 }
277d1b5e
ILT
1909
1910 start = 0;
1911
1912 for (i = start; i < stop; i += onaline)
1913 {
1914 bfd_vma begin_addr;
1915 bfd_vma end_addr;
1916 bfd_vma eh_handler;
1917 bfd_vma eh_data;
1918 bfd_vma prolog_end_addr;
c7e2358a 1919#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
5933bdc9 1920 int em_data;
c7e2358a 1921#endif
277d1b5e 1922
fac41780 1923 if (i + PDATA_ROW_SIZE > stop)
277d1b5e 1924 break;
5933bdc9 1925
6fa957a9
KH
1926 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1927 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1928 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1929 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1930 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
9602af51 1931
277d1b5e
ILT
1932 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1933 && eh_data == 0 && prolog_end_addr == 0)
1725a96e
NC
1934 /* We are probably into the padding of the section now. */
1935 break;
277d1b5e 1936
c7e2358a 1937#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
5933bdc9 1938 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
c7e2358a 1939#endif
6fa957a9
KH
1940 eh_handler &= ~(bfd_vma) 0x3;
1941 prolog_end_addr &= ~(bfd_vma) 0x3;
fac41780
JW
1942
1943 fputc (' ', file);
ebf12fbe
DK
1944 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1945 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1946 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1947 bfd_fprintf_vma (abfd, file, eh_handler);
99ad8390 1948#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
fac41780 1949 fputc (' ', file);
ebf12fbe
DK
1950 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1951 bfd_fprintf_vma (abfd, file, prolog_end_addr);
fac41780
JW
1952 fprintf (file, " %x", em_data);
1953#endif
277d1b5e
ILT
1954
1955#ifdef POWERPC_LE_PE
1956 if (eh_handler == 0 && eh_data != 0)
1957 {
6fa957a9 1958 /* Special bits here, although the meaning may be a little
7920ce38
NC
1959 mysterious. The only one I know for sure is 0x03
1960 Code Significance
1961 0x00 None
1962 0x01 Register Save Millicode
1963 0x02 Register Restore Millicode
1964 0x03 Glue Code Sequence. */
277d1b5e
ILT
1965 switch (eh_data)
1966 {
1967 case 0x01:
9602af51 1968 fprintf (file, _(" Register save millicode"));
277d1b5e
ILT
1969 break;
1970 case 0x02:
9602af51 1971 fprintf (file, _(" Register restore millicode"));
277d1b5e
ILT
1972 break;
1973 case 0x03:
9602af51 1974 fprintf (file, _(" Glue code sequence"));
277d1b5e
ILT
1975 break;
1976 default:
1977 break;
1978 }
1979 }
1980#endif
9602af51 1981 fprintf (file, "\n");
277d1b5e
ILT
1982 }
1983
1984 free (data);
1985
b34976b6 1986 return TRUE;
2b5c217d 1987#undef PDATA_ROW_SIZE
277d1b5e
ILT
1988}
1989
799c00e0
NC
1990typedef struct sym_cache
1991{
1992 int symcount;
1993 asymbol ** syms;
1994} sym_cache;
1995
1996static asymbol **
1997slurp_symtab (bfd *abfd, sym_cache *psc)
1998{
1999 asymbol ** sy = NULL;
2000 long storage;
2001
2002 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2003 {
2004 psc->symcount = 0;
2005 return NULL;
2006 }
2007
2008 storage = bfd_get_symtab_upper_bound (abfd);
2009 if (storage < 0)
2010 return NULL;
2011 if (storage)
86eafac0
NC
2012 {
2013 sy = (asymbol **) bfd_malloc (storage);
2014 if (sy == NULL)
2015 return NULL;
2016 }
799c00e0
NC
2017
2018 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2019 if (psc->symcount < 0)
2020 return NULL;
2021 return sy;
2022}
2023
2024static const char *
2025my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2026{
2027 int i;
2028
2029 if (psc->syms == 0)
2030 psc->syms = slurp_symtab (abfd, psc);
2031
2032 for (i = 0; i < psc->symcount; i++)
2033 {
2034 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2035 return psc->syms[i]->name;
2036 }
2037
2038 return NULL;
2039}
2040
2041static void
2042cleanup_syms (sym_cache *psc)
2043{
2044 psc->symcount = 0;
2045 free (psc->syms);
2046 psc->syms = NULL;
2047}
2048
2049/* This is the version for "compressed" pdata. */
2050
2051bfd_boolean
2052_bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2053{
2054# define PDATA_ROW_SIZE (2 * 4)
2055 FILE *file = (FILE *) vfile;
2056 bfd_byte *data = NULL;
2057 asection *section = bfd_get_section_by_name (abfd, ".pdata");
2058 bfd_size_type datasize = 0;
2059 bfd_size_type i;
2060 bfd_size_type start, stop;
2061 int onaline = PDATA_ROW_SIZE;
91d6fa6a 2062 struct sym_cache cache = {0, 0} ;
799c00e0
NC
2063
2064 if (section == NULL
2065 || coff_section_data (abfd, section) == NULL
2066 || pei_section_data (abfd, section) == NULL)
2067 return TRUE;
2068
2069 stop = pei_section_data (abfd, section)->virt_size;
2070 if ((stop % onaline) != 0)
2071 fprintf (file,
2072 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2073 (long) stop, onaline);
2074
2075 fprintf (file,
2076 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2077
2078 fprintf (file, _("\
2079 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2080 \t\tAddress Length Length 32b exc Handler Data\n"));
2081
2082 datasize = section->size;
2083 if (datasize == 0)
2084 return TRUE;
2085
2086 if (! bfd_malloc_and_get_section (abfd, section, &data))
2087 {
2088 if (data != NULL)
2089 free (data);
2090 return FALSE;
2091 }
2092
2093 start = 0;
2094
2095 for (i = start; i < stop; i += onaline)
2096 {
2097 bfd_vma begin_addr;
2098 bfd_vma other_data;
2099 bfd_vma prolog_length, function_length;
2100 int flag32bit, exception_flag;
799c00e0
NC
2101 asection *tsection;
2102
2103 if (i + PDATA_ROW_SIZE > stop)
2104 break;
2105
2106 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
2107 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
2108
2109 if (begin_addr == 0 && other_data == 0)
2110 /* We are probably into the padding of the section now. */
2111 break;
2112
2113 prolog_length = (other_data & 0x000000FF);
2114 function_length = (other_data & 0x3FFFFF00) >> 8;
2115 flag32bit = (int)((other_data & 0x40000000) >> 30);
2116 exception_flag = (int)((other_data & 0x80000000) >> 31);
2117
2118 fputc (' ', file);
ebf12fbe
DK
2119 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2120 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2121 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2122 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
799c00e0
NC
2123 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2124
2125 /* Get the exception handler's address and the data passed from the
2126 .text section. This is really the data that belongs with the .pdata
2127 but got "compressed" out for the ARM and SH4 architectures. */
2128 tsection = bfd_get_section_by_name (abfd, ".text");
2129 if (tsection && coff_section_data (abfd, tsection)
2130 && pei_section_data (abfd, tsection))
2131 {
4e1fc599
AM
2132 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2133 bfd_byte *tdata;
799c00e0 2134
4e1fc599
AM
2135 tdata = (bfd_byte *) bfd_malloc (8);
2136 if (tdata)
2137 {
2138 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
799c00e0
NC
2139 {
2140 bfd_vma eh, eh_data;
2141
2142 eh = bfd_get_32 (abfd, tdata);
2143 eh_data = bfd_get_32 (abfd, tdata + 4);
2144 fprintf (file, "%08x ", (unsigned int) eh);
2145 fprintf (file, "%08x", (unsigned int) eh_data);
2146 if (eh != 0)
2147 {
91d6fa6a 2148 const char *s = my_symbol_for_address (abfd, eh, &cache);
799c00e0
NC
2149
2150 if (s)
2151 fprintf (file, " (%s) ", s);
2152 }
2153 }
2154 free (tdata);
2155 }
799c00e0
NC
2156 }
2157
2158 fprintf (file, "\n");
2159 }
2160
2161 free (data);
2162
91d6fa6a 2163 cleanup_syms (& cache);
799c00e0
NC
2164
2165 return TRUE;
2166#undef PDATA_ROW_SIZE
2167}
c7c7219d 2168
799c00e0 2169\f
5933bdc9 2170#define IMAGE_REL_BASED_HIGHADJ 4
1725a96e 2171static const char * const tbl[] =
7920ce38
NC
2172{
2173 "ABSOLUTE",
2174 "HIGH",
2175 "LOW",
2176 "HIGHLOW",
2177 "HIGHADJ",
2178 "MIPS_JMPADDR",
2179 "SECTION",
2180 "REL32",
2181 "RESERVED1",
2182 "MIPS_JMPADDR16",
2183 "DIR64",
2bfd55ca 2184 "HIGH3ADJ",
7920ce38
NC
2185 "UNKNOWN", /* MUST be last. */
2186};
277d1b5e 2187
b34976b6 2188static bfd_boolean
7920ce38 2189pe_print_reloc (bfd * abfd, void * vfile)
277d1b5e
ILT
2190{
2191 FILE *file = (FILE *) vfile;
2192 bfd_byte *data = 0;
2193 asection *section = bfd_get_section_by_name (abfd, ".reloc");
513ea82e 2194 bfd_byte *p, *end;
277d1b5e 2195
b69c8728 2196 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
b34976b6 2197 return TRUE;
277d1b5e 2198
5933bdc9
ILT
2199 fprintf (file,
2200 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
277d1b5e 2201
7920ce38 2202 if (! bfd_malloc_and_get_section (abfd, section, &data))
eea6121a
AM
2203 {
2204 if (data != NULL)
2205 free (data);
2206 return FALSE;
2207 }
277d1b5e 2208
513ea82e
AM
2209 p = data;
2210 end = data + section->size;
2211 while (p + 8 <= end)
277d1b5e
ILT
2212 {
2213 int j;
2214 bfd_vma virtual_address;
2215 long number, size;
513ea82e 2216 bfd_byte *chunk_end;
277d1b5e
ILT
2217
2218 /* The .reloc section is a sequence of blocks, with a header consisting
1725a96e 2219 of two 32 bit quantities, followed by a number of 16 bit entries. */
513ea82e
AM
2220 virtual_address = bfd_get_32 (abfd, p);
2221 size = bfd_get_32 (abfd, p + 4);
2222 p += 8;
277d1b5e
ILT
2223 number = (size - 8) / 2;
2224
2225 if (size == 0)
1725a96e 2226 break;
277d1b5e
ILT
2227
2228 fprintf (file,
2229 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
0af1713e 2230 (unsigned long) virtual_address, size, (unsigned long) size, number);
277d1b5e 2231
513ea82e
AM
2232 chunk_end = p + size;
2233 if (chunk_end > end)
2234 chunk_end = end;
2235 j = 0;
2236 while (p + 2 <= chunk_end)
277d1b5e 2237 {
513ea82e 2238 unsigned short e = bfd_get_16 (abfd, p);
5933bdc9 2239 unsigned int t = (e & 0xF000) >> 12;
277d1b5e
ILT
2240 int off = e & 0x0FFF;
2241
5933bdc9
ILT
2242 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2243 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
277d1b5e 2244
5933bdc9
ILT
2245 fprintf (file,
2246 _("\treloc %4d offset %4x [%4lx] %s"),
0af1713e 2247 j, off, (unsigned long) (off + virtual_address), tbl[t]);
277d1b5e 2248
513ea82e
AM
2249 p += 2;
2250 j++;
2251
17505c5c 2252 /* HIGHADJ takes an argument, - the next record *is* the
9602af51 2253 low 16 bits of addend. */
513ea82e 2254 if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
5933bdc9 2255 {
513ea82e
AM
2256 fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2257 p += 2;
6fa957a9 2258 j++;
5933bdc9 2259 }
9602af51 2260
17505c5c 2261 fprintf (file, "\n");
277d1b5e 2262 }
277d1b5e
ILT
2263 }
2264
2265 free (data);
2266
b34976b6 2267 return TRUE;
277d1b5e 2268}
5879bb8f 2269\f
3714081c
NC
2270/* A data structure describing the regions of a .rsrc section.
2271 Some fields are filled in as the section is parsed. */
2272
2273typedef struct rsrc_regions
2274{
2275 bfd_byte * section_start;
2276 bfd_byte * section_end;
2277 bfd_byte * strings_start;
2278 bfd_byte * resource_start;
2279} rsrc_regions;
277d1b5e 2280
11a6da56 2281static bfd_byte *
3714081c
NC
2282rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2283 rsrc_regions *, bfd_vma);
11a6da56 2284
20ad5e28
NC
2285/* Print the resource entry at DATA, with the text indented by INDENT.
2286 Recusively calls rsrc_print_resource_directory to print the contents
2287 of directory entries.
2288 Returns the address of the end of the data associated with the entry
2289 or section_end + 1 upon failure. */
2290
11a6da56 2291static bfd_byte *
3714081c
NC
2292rsrc_print_resource_entries (FILE * file,
2293 bfd * abfd,
2294 unsigned int indent,
2295 bfd_boolean is_name,
2296 bfd_byte * data,
2297 rsrc_regions * regions,
2298 bfd_vma rva_bias)
11a6da56
NC
2299{
2300 unsigned long entry, addr, size;
2301
3714081c
NC
2302 if (data + 8 >= regions->section_end)
2303 return regions->section_end + 1;
11a6da56 2304
3714081c 2305 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
11a6da56 2306
20ad5e28 2307 entry = (unsigned long) bfd_get_32 (abfd, data);
11a6da56
NC
2308 if (is_name)
2309 {
5879bb8f
NC
2310 bfd_byte * name;
2311
3714081c 2312 /* Note - the documentation says that this field is an RVA value
5879bb8f
NC
2313 but windres appears to produce a section relative offset with
2314 the top bit set. Support both styles for now. */
2315 if (HighBitSet (entry))
3714081c 2316 name = regions->section_start + WithoutHighBit (entry);
5879bb8f 2317 else
3714081c 2318 name = regions->section_start + entry - rva_bias;
5879bb8f 2319
20ad5e28 2320 if (name + 2 < regions->section_end && name > regions->section_start)
11a6da56
NC
2321 {
2322 unsigned int len;
3714081c
NC
2323
2324 if (regions->strings_start == NULL)
2325 regions->strings_start = name;
2326
5879bb8f 2327 len = bfd_get_16 (abfd, name);
9373215c 2328
5879bb8f 2329 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
20ad5e28 2330
3714081c 2331 if (name + 2 + len * 2 < regions->section_end)
5879bb8f
NC
2332 {
2333 /* This strange loop is to cope with multibyte characters. */
2334 while (len --)
2335 {
20ad5e28
NC
2336 char c;
2337
5879bb8f 2338 name += 2;
20ad5e28
NC
2339 c = * name;
2340 /* Avoid printing control characters. */
2341 if (c > 0 && c < 32)
2342 fprintf (file, "^%c", c + 64);
2343 else
2344 fprintf (file, "%.1s", name);
5879bb8f
NC
2345 }
2346 }
11a6da56 2347 else
20ad5e28
NC
2348 {
2349 fprintf (file, _("<corrupt string length: %#x>\n"), len);
2350 /* PR binutils/17512: Do not try to continue decoding a
2351 corrupted resource section. It is likely to end up with
2352 reams of extraneous output. FIXME: We could probably
2353 continue if we disable the printing of strings... */
2354 return regions->section_end + 1;
2355 }
11a6da56
NC
2356 }
2357 else
20ad5e28
NC
2358 {
2359 fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2360 return regions->section_end + 1;
2361 }
11a6da56
NC
2362 }
2363 else
2364 fprintf (file, _("ID: %#08lx"), entry);
9373215c 2365
11a6da56 2366 entry = (long) bfd_get_32 (abfd, data + 4);
5879bb8f 2367 fprintf (file, _(", Value: %#08lx\n"), entry);
11a6da56 2368
5879bb8f 2369 if (HighBitSet (entry))
20ad5e28
NC
2370 {
2371 data = regions->section_start + WithoutHighBit (entry);
2372 if (data <= regions->section_start || data > regions->section_end)
2373 return regions->section_end + 1;
2374
2375 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2376 in the resource table. We need some way to detect this. */
2377 return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2378 regions, rva_bias);
2379 }
11a6da56 2380
3714081c
NC
2381 if (regions->section_start + entry + 16 >= regions->section_end)
2382 return regions->section_end + 1;
11a6da56 2383
3714081c
NC
2384 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2385 (int) (entry),
5879bb8f 2386 indent, " ",
3714081c
NC
2387 addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2388 size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2389 (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
9373215c 2390
11a6da56 2391 /* Check that the reserved entry is 0. */
3714081c 2392 if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
11a6da56 2393 /* And that the data address/size is valid too. */
3714081c
NC
2394 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2395 return regions->section_end + 1;
11a6da56 2396
3714081c
NC
2397 if (regions->resource_start == NULL)
2398 regions->resource_start = regions->section_start + (addr - rva_bias);
2399
2400 return regions->section_start + (addr - rva_bias) + size;
11a6da56
NC
2401}
2402
5879bb8f
NC
2403#define max(a,b) ((a) > (b) ? (a) : (b))
2404#define min(a,b) ((a) < (b) ? (a) : (b))
2405
11a6da56 2406static bfd_byte *
3714081c
NC
2407rsrc_print_resource_directory (FILE * file,
2408 bfd * abfd,
2409 unsigned int indent,
2410 bfd_byte * data,
2411 rsrc_regions * regions,
2412 bfd_vma rva_bias)
11a6da56
NC
2413{
2414 unsigned int num_names, num_ids;
5879bb8f 2415 bfd_byte * highest_data = data;
11a6da56 2416
3714081c
NC
2417 if (data + 16 >= regions->section_end)
2418 return regions->section_end + 1;
11a6da56 2419
3714081c 2420 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
11a6da56
NC
2421 switch (indent)
2422 {
2423 case 0: fprintf (file, "Type"); break;
2424 case 2: fprintf (file, "Name"); break;
2425 case 4: fprintf (file, "Language"); break;
20ad5e28
NC
2426 default:
2427 fprintf (file, _("<unknown directory type: %d>\n"), indent);
2428 /* FIXME: For now we end the printing here. If in the
2429 future more directory types are added to the RSRC spec
2430 then we will need to change this. */
2431 return regions->section_end + 1;
11a6da56
NC
2432 }
2433
2434 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2435 (int) bfd_get_32 (abfd, data),
2436 (long) bfd_get_32 (abfd, data + 4),
2437 (int) bfd_get_16 (abfd, data + 8),
2438 (int) bfd_get_16 (abfd, data + 10),
2439 num_names = (int) bfd_get_16 (abfd, data + 12),
2440 num_ids = (int) bfd_get_16 (abfd, data + 14));
2441 data += 16;
2442
5879bb8f 2443 while (num_names --)
11a6da56 2444 {
5879bb8f
NC
2445 bfd_byte * entry_end;
2446
2447 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
3714081c 2448 data, regions, rva_bias);
5879bb8f
NC
2449 data += 8;
2450 highest_data = max (highest_data, entry_end);
3714081c 2451 if (entry_end >= regions->section_end)
5879bb8f 2452 return entry_end;
11a6da56
NC
2453 }
2454
5879bb8f 2455 while (num_ids --)
11a6da56 2456 {
5879bb8f
NC
2457 bfd_byte * entry_end;
2458
2459 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
3714081c 2460 data, regions, rva_bias);
5879bb8f
NC
2461 data += 8;
2462 highest_data = max (highest_data, entry_end);
3714081c 2463 if (entry_end >= regions->section_end)
5879bb8f 2464 return entry_end;
11a6da56
NC
2465 }
2466
5879bb8f 2467 return max (highest_data, data);
11a6da56
NC
2468}
2469
2470/* Display the contents of a .rsrc section. We do not try to
2471 reproduce the resources, windres does that. Instead we dump
2472 the tables in a human readable format. */
2473
2474static bfd_boolean
5879bb8f 2475rsrc_print_section (bfd * abfd, void * vfile)
11a6da56
NC
2476{
2477 bfd_vma rva_bias;
2478 pe_data_type * pe;
2479 FILE * file = (FILE *) vfile;
2480 bfd_size_type datasize;
2481 asection * section;
2482 bfd_byte * data;
3714081c 2483 rsrc_regions regions;
11a6da56 2484
11a6da56 2485 pe = pe_data (abfd);
5879bb8f 2486 if (pe == NULL)
11a6da56
NC
2487 return TRUE;
2488
5879bb8f
NC
2489 section = bfd_get_section_by_name (abfd, ".rsrc");
2490 if (section == NULL)
11a6da56 2491 return TRUE;
b69c8728
JT
2492 if (!(section->flags & SEC_HAS_CONTENTS))
2493 return TRUE;
5879bb8f 2494
11a6da56
NC
2495 datasize = section->size;
2496 if (datasize == 0)
2497 return TRUE;
2498
b69c8728
JT
2499 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2500
5879bb8f 2501 if (! bfd_malloc_and_get_section (abfd, section, & data))
11a6da56
NC
2502 {
2503 if (data != NULL)
2504 free (data);
2505 return FALSE;
2506 }
3714081c
NC
2507
2508 regions.section_start = data;
2509 regions.section_end = data + datasize;
2510 regions.strings_start = NULL;
2511 regions.resource_start = NULL;
11a6da56
NC
2512
2513 fflush (file);
2514 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2515
3714081c 2516 while (data < regions.section_end)
11a6da56 2517 {
5879bb8f
NC
2518 bfd_byte * p = data;
2519
3714081c 2520 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
11a6da56 2521
3714081c 2522 if (data == regions.section_end + 1)
11a6da56
NC
2523 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2524 else
2525 {
2526 /* Align data before continuing. */
2527 int align = (1 << section->alignment_power) - 1;
5879bb8f 2528
b9e95fa2 2529 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
5879bb8f 2530 rva_bias += data - p;
11a6da56
NC
2531
2532 /* For reasons that are unclear .rsrc sections are sometimes created
2533 aligned to a 1^3 boundary even when their alignment is set at
2534 1^2. Catch that case here before we issue a spurious warning
2535 message. */
3714081c
NC
2536 if (data == (regions.section_end - 4))
2537 data = regions.section_end;
2538 else if (data < regions.section_end)
c32abae8
NC
2539 {
2540 /* If the extra data is all zeros then do not complain.
2541 This is just padding so that the section meets the
2542 page size requirements. */
6937bb54 2543 while (++ data < regions.section_end)
c32abae8
NC
2544 if (*data != 0)
2545 break;
2546 if (data < regions.section_end)
2547 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2548 }
11a6da56
NC
2549 }
2550 }
2551
3714081c 2552 if (regions.strings_start != NULL)
20ad5e28 2553 fprintf (file, " String table starts at offset: %#03x\n",
08937d80 2554 (int) (regions.strings_start - regions.section_start));
3714081c 2555 if (regions.resource_start != NULL)
20ad5e28 2556 fprintf (file, " Resources start at offset: %#03x\n",
08937d80 2557 (int) (regions.resource_start - regions.section_start));
3714081c
NC
2558
2559 free (regions.section_start);
11a6da56
NC
2560 return TRUE;
2561}
2562
61e2488c
JT
2563#define IMAGE_NUMBEROF_DEBUG_TYPES 12
2564
2565static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2566{
2567 "Unknown",
2568 "COFF",
2569 "CodeView",
2570 "FPO",
2571 "Misc",
2572 "Exception",
2573 "Fixup",
2574 "OMAP-to-SRC",
2575 "OMAP-from-SRC",
2576 "Borland",
2577 "Reserved",
2578 "CLSID",
2579};
2580
2581static bfd_boolean
2582pe_print_debugdata (bfd * abfd, void * vfile)
2583{
2584 FILE *file = (FILE *) vfile;
2585 pe_data_type *pe = pe_data (abfd);
2586 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2587 asection *section;
2588 bfd_byte *data = 0;
2589 bfd_size_type dataoff;
2590 unsigned int i;
2591
2592 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2593 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2594
2595 if (size == 0)
2596 return TRUE;
2597
2598 addr += extra->ImageBase;
2599 for (section = abfd->sections; section != NULL; section = section->next)
2600 {
2601 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2602 break;
2603 }
2604
2605 if (section == NULL)
2606 {
2607 fprintf (file,
2608 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2609 return TRUE;
2610 }
6e6e7cfc
JT
2611 else if (!(section->flags & SEC_HAS_CONTENTS))
2612 {
2613 fprintf (file,
2614 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2615 section->name);
2616 return TRUE;
2617 }
5a3f568b
NC
2618 else if (section->size < size)
2619 {
2620 fprintf (file,
2621 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2622 section->name);
2623 return FALSE;
2624 }
61e2488c
JT
2625
2626 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2627 section->name, (unsigned long) addr);
2628
2629 dataoff = addr - section->vma;
2630
a6f921c8
NC
2631 if (size > (section->size - dataoff))
2632 {
2633 fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2634 return FALSE;
2635 }
2636
61e2488c
JT
2637 fprintf (file,
2638 _("Type Size Rva Offset\n"));
2639
5a3f568b 2640 /* Read the whole section. */
61e2488c
JT
2641 if (!bfd_malloc_and_get_section (abfd, section, &data))
2642 {
2643 if (data != NULL)
2644 free (data);
2645 return FALSE;
2646 }
2647
2648 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2649 {
2650 const char *type_name;
2651 struct external_IMAGE_DEBUG_DIRECTORY *ext
2652 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2653 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2654
2655 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2656
20ad5e28 2657 if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
61e2488c
JT
2658 type_name = debug_type_names[0];
2659 else
2660 type_name = debug_type_names[idd.Type];
2661
2662 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2663 idd.Type, type_name, idd.SizeOfData,
2664 idd.AddressOfRawData, idd.PointerToRawData);
2665
2666 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2667 {
2668 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2669 char buffer[256 + 1];
2670 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2671
2672 /* The debug entry doesn't have to have to be in a section,
2673 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2674 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2675 idd.SizeOfData, cvinfo))
2676 continue;
2677
2678 for (i = 0; i < cvinfo->SignatureLength; i++)
2679 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2680
2681 fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2682 buffer[0], buffer[1], buffer[2], buffer[3],
2683 signature, cvinfo->Age);
2684 }
2685 }
2686
2687 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2688 fprintf (file,
2689 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2690
2691 return TRUE;
2692}
2693
277d1b5e
ILT
2694/* Print out the program headers. */
2695
b34976b6 2696bfd_boolean
7920ce38 2697_bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
277d1b5e
ILT
2698{
2699 FILE *file = (FILE *) vfile;
2700 int j;
2701 pe_data_type *pe = pe_data (abfd);
2702 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
fac41780 2703 const char *subsystem_name = NULL;
d13c9dc6 2704 const char *name;
277d1b5e
ILT
2705
2706 /* The MS dumpbin program reportedly ands with 0xff0f before
2707 printing the characteristics field. Not sure why. No reason to
2708 emulate it here. */
2709 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2710#undef PF
6fa957a9 2711#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
d70270c5
BF
2712 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2713 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2714 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2715 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2716 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2717 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2718 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2719 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2720 PF (IMAGE_FILE_SYSTEM, "system file");
2721 PF (IMAGE_FILE_DLL, "DLL");
2722 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
277d1b5e
ILT
2723#undef PF
2724
5933bdc9 2725 /* ctime implies '\n'. */
0b6488e2
RH
2726 {
2727 time_t t = pe->coff.timestamp;
2728 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2729 }
d13c9dc6
L
2730
2731#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2732# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2733#endif
2734#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2735# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2736#endif
2737#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2738# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2739#endif
2740
2741 switch (i->Magic)
2742 {
2743 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2744 name = "PE32";
2745 break;
2746 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2747 name = "PE32+";
2748 break;
2749 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2750 name = "ROM";
2751 break;
2752 default:
2753 name = NULL;
2754 break;
2755 }
2756 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2757 if (name)
2758 fprintf (file, "\t(%s)",name);
2759 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2760 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
0af1713e 2761 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
d13c9dc6 2762 fprintf (file, "SizeOfInitializedData\t%08lx\n",
0af1713e 2763 (unsigned long) i->SizeOfInitializedData);
d13c9dc6 2764 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
0af1713e 2765 (unsigned long) i->SizeOfUninitializedData);
d13c9dc6 2766 fprintf (file, "AddressOfEntryPoint\t");
ebf12fbe 2767 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
d13c9dc6 2768 fprintf (file, "\nBaseOfCode\t\t");
ebf12fbe 2769 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
d13c9dc6
L
2770#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2771 /* PE32+ does not have BaseOfData member! */
2772 fprintf (file, "\nBaseOfData\t\t");
ebf12fbe 2773 bfd_fprintf_vma (abfd, file, i->BaseOfData);
d13c9dc6
L
2774#endif
2775
9602af51 2776 fprintf (file, "\nImageBase\t\t");
ebf12fbe 2777 bfd_fprintf_vma (abfd, file, i->ImageBase);
9602af51 2778 fprintf (file, "\nSectionAlignment\t");
ebf12fbe 2779 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
9602af51 2780 fprintf (file, "\nFileAlignment\t\t");
ebf12fbe 2781 bfd_fprintf_vma (abfd, file, i->FileAlignment);
9602af51
KH
2782 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2783 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2784 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2785 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2786 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2787 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
0af1713e
AM
2788 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2789 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2790 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2791 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
1725a96e 2792
fac41780
JW
2793 switch (i->Subsystem)
2794 {
2795 case IMAGE_SUBSYSTEM_UNKNOWN:
2796 subsystem_name = "unspecified";
2797 break;
2798 case IMAGE_SUBSYSTEM_NATIVE:
2799 subsystem_name = "NT native";
2800 break;
2801 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2802 subsystem_name = "Windows GUI";
2803 break;
2804 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2805 subsystem_name = "Windows CUI";
2806 break;
2807 case IMAGE_SUBSYSTEM_POSIX_CUI:
2808 subsystem_name = "POSIX CUI";
2809 break;
2810 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2811 subsystem_name = "Wince CUI";
2812 break;
d9118602 2813 // These are from UEFI Platform Initialization Specification 1.1.
fac41780
JW
2814 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2815 subsystem_name = "EFI application";
2816 break;
2817 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2818 subsystem_name = "EFI boot service driver";
2819 break;
2820 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
9602af51 2821 subsystem_name = "EFI runtime driver";
fac41780 2822 break;
d9118602
L
2823 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2824 subsystem_name = "SAL runtime driver";
6c73cbb1 2825 break;
d9118602 2826 // This is from revision 8.0 of the MS PE/COFF spec
6c73cbb1
NC
2827 case IMAGE_SUBSYSTEM_XBOX:
2828 subsystem_name = "XBOX";
2829 break;
2830 // Added default case for clarity - subsystem_name is NULL anyway.
2831 default:
2832 subsystem_name = NULL;
fac41780 2833 }
1725a96e 2834
9602af51 2835 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
fac41780
JW
2836 if (subsystem_name)
2837 fprintf (file, "\t(%s)", subsystem_name);
9602af51
KH
2838 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2839 fprintf (file, "SizeOfStackReserve\t");
ebf12fbe 2840 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
9602af51 2841 fprintf (file, "\nSizeOfStackCommit\t");
ebf12fbe 2842 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
9602af51 2843 fprintf (file, "\nSizeOfHeapReserve\t");
ebf12fbe 2844 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
9602af51 2845 fprintf (file, "\nSizeOfHeapCommit\t");
ebf12fbe 2846 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
0af1713e
AM
2847 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2848 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2849 (unsigned long) i->NumberOfRvaAndSizes);
277d1b5e 2850
9602af51 2851 fprintf (file, "\nThe Data Directory\n");
277d1b5e
ILT
2852 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2853 {
2854 fprintf (file, "Entry %1x ", j);
ebf12fbe 2855 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
0af1713e 2856 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
277d1b5e
ILT
2857 fprintf (file, "%s\n", dir_names[j]);
2858 }
2859
2860 pe_print_idata (abfd, vfile);
2861 pe_print_edata (abfd, vfile);
2b5c217d
NC
2862 if (bfd_coff_have_print_pdata (abfd))
2863 bfd_coff_print_pdata (abfd, vfile);
2864 else
2865 pe_print_pdata (abfd, vfile);
277d1b5e 2866 pe_print_reloc (abfd, vfile);
61e2488c 2867 pe_print_debugdata (abfd, file);
277d1b5e 2868
5879bb8f 2869 rsrc_print_section (abfd, vfile);
9373215c 2870
b34976b6 2871 return TRUE;
277d1b5e
ILT
2872}
2873
6e6e7cfc
JT
2874static bfd_boolean
2875is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2876{
2877 bfd_vma addr = * (bfd_vma *) obj;
2878 return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2879}
2880
2881static asection *
2882find_section_by_vma (bfd *abfd, bfd_vma addr)
2883{
2884 return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2885}
2886
277d1b5e
ILT
2887/* Copy any private info we understand from the input bfd
2888 to the output bfd. */
2889
b34976b6 2890bfd_boolean
7920ce38 2891_bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
277d1b5e 2892{
4be8cddc
L
2893 pe_data_type *ipe, *ope;
2894
277d1b5e
ILT
2895 /* One day we may try to grok other private data. */
2896 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2897 || obfd->xvec->flavour != bfd_target_coff_flavour)
b34976b6 2898 return TRUE;
277d1b5e 2899
4be8cddc
L
2900 ipe = pe_data (ibfd);
2901 ope = pe_data (obfd);
4e1fc599 2902
325c681d 2903 /* pe_opthdr is copied in copy_object. */
4be8cddc
L
2904 ope->dll = ipe->dll;
2905
2906 /* Don't copy input subsystem if output is different from input. */
2907 if (obfd->xvec != ibfd->xvec)
2908 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
277d1b5e 2909
1725a96e 2910 /* For strip: if we removed .reloc, we'll make a real mess of things
5933bdc9
ILT
2911 if we don't remove this entry as well. */
2912 if (! pe_data (obfd)->has_reloc_section)
2913 {
6c73cbb1
NC
2914 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2915 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
5933bdc9 2916 }
441f34fa
L
2917
2918 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2919 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2920 won't be added. */
2921 if (! pe_data (ibfd)->has_reloc_section
2922 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2923 pe_data (obfd)->dont_strip_reloc = 1;
2924
6e6e7cfc
JT
2925 /* The file offsets contained in the debug directory need rewriting. */
2926 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2927 {
2928 bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2929 + ope->pe_opthdr.ImageBase;
2930 asection *section = find_section_by_vma (obfd, addr);
2931 bfd_byte *data;
2932
2933 if (section && bfd_malloc_and_get_section (obfd, section, &data))
2934 {
2935 unsigned int i;
2936 struct external_IMAGE_DEBUG_DIRECTORY *dd =
2937 (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2938
063bb025
NC
2939 /* PR 17512: file: 0f15796a. */
2940 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size + (addr - section->vma)
2941 > bfd_get_section_size (section))
2942 {
2943 _bfd_error_handler (_("%A: Data Directory size (%lx) exceeds space left in section (%lx)"),
2944 obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2945 bfd_get_section_size (section) - (addr - section->vma));
2946 return FALSE;
2947 }
2948
6e6e7cfc
JT
2949 for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2950 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2951 {
2952 asection *ddsection;
2953 struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
2954 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2955
2956 _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
2957
2958 if (idd.AddressOfRawData == 0)
2959 continue; /* RVA 0 means only offset is valid, not handled yet. */
2960
2961 ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
2962 if (!ddsection)
2963 continue; /* Not in a section! */
2964
2965 idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
2966 + ope->pe_opthdr.ImageBase) - ddsection->vma;
2967
2968 _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
2969 }
2970
2971 if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
86eafac0
NC
2972 {
2973 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2974 return FALSE;
2975 }
6e6e7cfc 2976 }
86eafac0
NC
2977 else if (section)
2978 {
2979 _bfd_error_handler (_("%A: Failed to read debug data section"), obfd);
2980 return FALSE;
2981 }
6e6e7cfc
JT
2982 }
2983
b34976b6 2984 return TRUE;
277d1b5e
ILT
2985}
2986
9602af51 2987/* Copy private section data. */
1725a96e 2988
b34976b6 2989bfd_boolean
7920ce38
NC
2990_bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2991 asection *isec,
2992 bfd *obfd,
2993 asection *osec)
277d1b5e
ILT
2994{
2995 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2996 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
b34976b6 2997 return TRUE;
277d1b5e
ILT
2998
2999 if (coff_section_data (ibfd, isec) != NULL
3000 && pei_section_data (ibfd, isec) != NULL)
3001 {
3002 if (coff_section_data (obfd, osec) == NULL)
3003 {
dc810e39 3004 bfd_size_type amt = sizeof (struct coff_section_tdata);
7920ce38 3005 osec->used_by_bfd = bfd_zalloc (obfd, amt);
277d1b5e 3006 if (osec->used_by_bfd == NULL)
b34976b6 3007 return FALSE;
277d1b5e 3008 }
1725a96e 3009
277d1b5e
ILT
3010 if (pei_section_data (obfd, osec) == NULL)
3011 {
dc810e39 3012 bfd_size_type amt = sizeof (struct pei_section_tdata);
7920ce38 3013 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
277d1b5e 3014 if (coff_section_data (obfd, osec)->tdata == NULL)
b34976b6 3015 return FALSE;
277d1b5e 3016 }
1725a96e 3017
277d1b5e
ILT
3018 pei_section_data (obfd, osec)->virt_size =
3019 pei_section_data (ibfd, isec)->virt_size;
5933bdc9 3020 pei_section_data (obfd, osec)->pe_flags =
6fa957a9 3021 pei_section_data (ibfd, isec)->pe_flags;
277d1b5e
ILT
3022 }
3023
b34976b6 3024 return TRUE;
277d1b5e 3025}
7d2b58d6
ILT
3026
3027void
7920ce38 3028_bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
7d2b58d6
ILT
3029{
3030 coff_get_symbol_info (abfd, symbol, ret);
7d2b58d6 3031}
2fbadf2c 3032
5174d0fb
KT
3033#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3034static int
3035sort_x64_pdata (const void *l, const void *r)
3036{
3037 const char *lp = (const char *) l;
3038 const char *rp = (const char *) r;
3039 bfd_vma vl, vr;
3040 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3041 if (vl != vr)
3042 return (vl < vr ? -1 : 1);
3043 /* We compare just begin address. */
3044 return 0;
3045}
3046#endif
5879bb8f
NC
3047\f
3048/* Functions to process a .rsrc section. */
3049
3050static unsigned int sizeof_leaves;
3051static unsigned int sizeof_strings;
3052static unsigned int sizeof_tables_and_entries;
3053
3054static bfd_byte *
3055rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3056
3057static bfd_byte *
3058rsrc_count_entries (bfd * abfd,
3059 bfd_boolean is_name,
3060 bfd_byte * datastart,
3061 bfd_byte * data,
3062 bfd_byte * dataend,
3063 bfd_vma rva_bias)
3064{
3065 unsigned long entry, addr, size;
3066
3067 if (data + 8 >= dataend)
3068 return dataend + 1;
3069
3070 if (is_name)
3071 {
3072 bfd_byte * name;
3073
3074 entry = (long) bfd_get_32 (abfd, data);
3075
3076 if (HighBitSet (entry))
3077 name = datastart + WithoutHighBit (entry);
3078 else
3079 name = datastart + entry - rva_bias;
3080
20ad5e28 3081 if (name + 2 >= dataend || name < datastart)
5879bb8f
NC
3082 return dataend + 1;
3083
3084 unsigned int len = bfd_get_16 (abfd, name);
3085 if (len == 0 || len > 256)
3086 return dataend + 1;
5879bb8f
NC
3087 }
3088
3089 entry = (long) bfd_get_32 (abfd, data + 4);
3090
3091 if (HighBitSet (entry))
20ad5e28
NC
3092 {
3093 data = datastart + WithoutHighBit (entry);
3094
3095 if (data <= datastart || data >= dataend)
3096 return dataend + 1;
3097
3098 return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3099 }
5879bb8f
NC
3100
3101 if (datastart + entry + 16 >= dataend)
3102 return dataend + 1;
3103
3104 addr = (long) bfd_get_32 (abfd, datastart + entry);
3105 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3106
5879bb8f
NC
3107 return datastart + addr - rva_bias + size;
3108}
9373215c 3109
5879bb8f
NC
3110static bfd_byte *
3111rsrc_count_directory (bfd * abfd,
3112 bfd_byte * datastart,
3113 bfd_byte * data,
3114 bfd_byte * dataend,
3115 bfd_vma rva_bias)
3116{
3117 unsigned int num_entries, num_ids;
3118 bfd_byte * highest_data = data;
3119
3120 if (data + 16 >= dataend)
3121 return dataend + 1;
3122
3123 num_entries = (int) bfd_get_16 (abfd, data + 12);
3124 num_ids = (int) bfd_get_16 (abfd, data + 14);
3125
3126 num_entries += num_ids;
3127
3128 data += 16;
5879bb8f
NC
3129
3130 while (num_entries --)
3131 {
3132 bfd_byte * entry_end;
3133
3134 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3135 datastart, data, dataend, rva_bias);
3136 data += 8;
5879bb8f
NC
3137 highest_data = max (highest_data, entry_end);
3138 if (entry_end >= dataend)
3139 break;
3140 }
3141
3142 return max (highest_data, data);
3143}
3144
3145typedef struct rsrc_dir_chain
3146{
3147 unsigned int num_entries;
3148 struct rsrc_entry * first_entry;
3149 struct rsrc_entry * last_entry;
3150} rsrc_dir_chain;
3151
3152typedef struct rsrc_directory
3153{
3154 unsigned int characteristics;
3155 unsigned int time;
3156 unsigned int major;
3157 unsigned int minor;
3158
3159 rsrc_dir_chain names;
3160 rsrc_dir_chain ids;
3161
3162 struct rsrc_entry * entry;
3163} rsrc_directory;
3164
3165typedef struct rsrc_string
3166{
3167 unsigned int len;
3168 bfd_byte * string;
3169} rsrc_string;
9373215c 3170
5879bb8f
NC
3171typedef struct rsrc_leaf
3172{
3173 unsigned int size;
3174 unsigned int codepage;
3175 bfd_byte * data;
3176} rsrc_leaf;
3177
3178typedef struct rsrc_entry
3179{
3180 bfd_boolean is_name;
3181 union
3182 {
3183 unsigned int id;
3184 struct rsrc_string name;
3185 } name_id;
3186
3187 bfd_boolean is_dir;
3188 union
3189 {
3190 struct rsrc_directory * directory;
3191 struct rsrc_leaf * leaf;
3192 } value;
3193
3194 struct rsrc_entry * next_entry;
3195 struct rsrc_directory * parent;
3196} rsrc_entry;
3197
3198static bfd_byte *
3199rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3200 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3201
3202static bfd_byte *
3203rsrc_parse_entry (bfd * abfd,
3204 bfd_boolean is_name,
3205 rsrc_entry * entry,
3206 bfd_byte * datastart,
3207 bfd_byte * data,
3208 bfd_byte * dataend,
3209 bfd_vma rva_bias,
3210 rsrc_directory * parent)
3211{
3212 unsigned long val, addr, size;
3213
3214 val = bfd_get_32 (abfd, data);
3215
3216 entry->parent = parent;
3217 entry->is_name = is_name;
3218
3219 if (is_name)
3220 {
20ad5e28
NC
3221 bfd_byte * address;
3222
5879bb8f
NC
3223 if (HighBitSet (val))
3224 {
3225 val = WithoutHighBit (val);
3226
20ad5e28 3227 address = datastart + val;
5879bb8f
NC
3228 }
3229 else
3230 {
20ad5e28 3231 address = datastart + val - rva_bias;
5879bb8f 3232 }
20ad5e28
NC
3233
3234 if (address + 3 > dataend)
3235 return dataend;
3236
3237 entry->name_id.name.len = bfd_get_16 (abfd, address);
3238 entry->name_id.name.string = address + 2;
5879bb8f
NC
3239 }
3240 else
3241 entry->name_id.id = val;
3242
3243 val = bfd_get_32 (abfd, data + 4);
3244
3245 if (HighBitSet (val))
3246 {
3247 entry->is_dir = TRUE;
3248 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3249 if (entry->value.directory == NULL)
3250 return dataend;
3251
3252 return rsrc_parse_directory (abfd, entry->value.directory,
3253 datastart,
3254 datastart + WithoutHighBit (val),
3255 dataend, rva_bias, entry);
3256 }
3257
3258 entry->is_dir = FALSE;
3259 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3260 if (entry->value.leaf == NULL)
3261 return dataend;
3262
3263 addr = bfd_get_32 (abfd, datastart + val);
3264 size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
3265 entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3266
3267 entry->value.leaf->data = bfd_malloc (size);
3268 if (entry->value.leaf->data == NULL)
3269 return dataend;
3270
3271 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3272 return datastart + (addr - rva_bias) + size;
3273}
3274
3275static bfd_byte *
3276rsrc_parse_entries (bfd * abfd,
3277 rsrc_dir_chain * chain,
3278 bfd_boolean is_name,
3279 bfd_byte * highest_data,
3280 bfd_byte * datastart,
3281 bfd_byte * data,
3282 bfd_byte * dataend,
3283 bfd_vma rva_bias,
3284 rsrc_directory * parent)
3285{
9373215c 3286 unsigned int i;
5879bb8f
NC
3287 rsrc_entry * entry;
3288
3289 if (chain->num_entries == 0)
3290 {
3291 chain->first_entry = chain->last_entry = NULL;
3292 return highest_data;
3293 }
3294
3295 entry = bfd_malloc (sizeof * entry);
3296 if (entry == NULL)
3297 return dataend;
3298
3299 chain->first_entry = entry;
3300
5879bb8f
NC
3301 for (i = chain->num_entries; i--;)
3302 {
3303 bfd_byte * entry_end;
3304
3305 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3306 data, dataend, rva_bias, parent);
3307 data += 8;
3308 highest_data = max (entry_end, highest_data);
3309 if (entry_end > dataend)
3310 return dataend;
3311
3312 if (i)
3313 {
3314 entry->next_entry = bfd_malloc (sizeof * entry);
3315 entry = entry->next_entry;
3316 if (entry == NULL)
3317 return dataend;
3318 }
3319 else
3320 entry->next_entry = NULL;
3321 }
3322
3323 chain->last_entry = entry;
3324
3325 return highest_data;
3326}
3327
3328static bfd_byte *
3329rsrc_parse_directory (bfd * abfd,
3330 rsrc_directory * table,
3331 bfd_byte * datastart,
3332 bfd_byte * data,
3333 bfd_byte * dataend,
3334 bfd_vma rva_bias,
3335 rsrc_entry * entry)
3336{
3337 bfd_byte * highest_data = data;
3338
3339 if (table == NULL)
3340 return dataend;
3341
3342 table->characteristics = bfd_get_32 (abfd, data);
3343 table->time = bfd_get_32 (abfd, data + 4);
3344 table->major = bfd_get_16 (abfd, data + 8);
3345 table->minor = bfd_get_16 (abfd, data + 10);
3346 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3347 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3348 table->entry = entry;
3349
3350 data += 16;
3351
3352 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3353 datastart, data, dataend, rva_bias, table);
3354 data += table->names.num_entries * 8;
3355
3356 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3357 datastart, data, dataend, rva_bias, table);
3358 data += table->ids.num_entries * 8;
3359
3360 return max (highest_data, data);
3361}
3362
3363typedef struct rsrc_write_data
3364{
3365 bfd * abfd;
3366 bfd_byte * datastart;
3367 bfd_byte * next_table;
3368 bfd_byte * next_leaf;
3369 bfd_byte * next_string;
3370 bfd_byte * next_data;
3371 bfd_vma rva_bias;
9373215c
PM
3372} rsrc_write_data;
3373
5879bb8f
NC
3374static void
3375rsrc_write_string (rsrc_write_data * data,
3376 rsrc_string * string)
3377{
3378 bfd_put_16 (data->abfd, string->len, data->next_string);
3379 memcpy (data->next_string + 2, string->string, string->len * 2);
3380 data->next_string += (string->len + 1) * 2;
3381}
3382
3383static inline unsigned int
3384rsrc_compute_rva (rsrc_write_data * data,
3385 bfd_byte * addr)
3386{
3387 return (addr - data->datastart) + data->rva_bias;
3388}
3389
3390static void
3391rsrc_write_leaf (rsrc_write_data * data,
3392 rsrc_leaf * leaf)
3393{
9373215c
PM
3394 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3395 data->next_leaf);
5879bb8f
NC
3396 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3397 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3398 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3399 data->next_leaf += 16;
3400
3401 memcpy (data->next_data, leaf->data, leaf->size);
3714081c
NC
3402 /* An undocumented feature of Windows resources is that each unit
3403 of raw data is 8-byte aligned... */
3404 data->next_data += ((leaf->size + 7) & ~7);
5879bb8f
NC
3405}
3406
3407static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3408
3409static void
3410rsrc_write_entry (rsrc_write_data * data,
3411 bfd_byte * where,
3412 rsrc_entry * entry)
3413{
3414 if (entry->is_name)
3415 {
3416 bfd_put_32 (data->abfd,
3417 SetHighBit (data->next_string - data->datastart),
3418 where);
3419 rsrc_write_string (data, & entry->name_id.name);
3420 }
3421 else
3422 bfd_put_32 (data->abfd, entry->name_id.id, where);
3423
3424 if (entry->is_dir)
3425 {
3426 bfd_put_32 (data->abfd,
3427 SetHighBit (data->next_table - data->datastart),
3428 where + 4);
3429 rsrc_write_directory (data, entry->value.directory);
3430 }
3431 else
3432 {
3433 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3434 rsrc_write_leaf (data, entry->value.leaf);
3435 }
3436}
3437
3714081c
NC
3438static void
3439rsrc_compute_region_sizes (rsrc_directory * dir)
3440{
3441 struct rsrc_entry * entry;
3442
3443 if (dir == NULL)
3444 return;
3445
3446 sizeof_tables_and_entries += 16;
3447
3448 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3449 {
3450 sizeof_tables_and_entries += 8;
3451
3452 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3453
3454 if (entry->is_dir)
3455 rsrc_compute_region_sizes (entry->value.directory);
3456 else
3457 sizeof_leaves += 16;
3458 }
3459
3460 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3461 {
3462 sizeof_tables_and_entries += 8;
3463
3464 if (entry->is_dir)
3465 rsrc_compute_region_sizes (entry->value.directory);
3466 else
3467 sizeof_leaves += 16;
3468 }
3469}
3470
5879bb8f
NC
3471static void
3472rsrc_write_directory (rsrc_write_data * data,
3473 rsrc_directory * dir)
3474{
3475 rsrc_entry * entry;
3476 unsigned int i;
9373215c
PM
3477 bfd_byte * next_entry;
3478 bfd_byte * nt;
5879bb8f
NC
3479
3480 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3481 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3482 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3483 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3484 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3485 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3486
3487 /* Compute where the entries and the next table will be placed. */
9373215c
PM
3488 next_entry = data->next_table + 16;
3489 data->next_table = next_entry + (dir->names.num_entries * 8)
3490 + (dir->ids.num_entries * 8);
3491 nt = data->next_table;
3492
5879bb8f
NC
3493 /* Write the entries. */
3494 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3495 i > 0 && entry != NULL;
3496 i--, entry = entry->next_entry)
3497 {
3714081c 3498 BFD_ASSERT (entry->is_name);
5879bb8f
NC
3499 rsrc_write_entry (data, next_entry, entry);
3500 next_entry += 8;
3501 }
3502 BFD_ASSERT (i == 0);
3503 BFD_ASSERT (entry == NULL);
3504
3505 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3506 i > 0 && entry != NULL;
3507 i--, entry = entry->next_entry)
3508 {
3714081c 3509 BFD_ASSERT (! entry->is_name);
5879bb8f
NC
3510 rsrc_write_entry (data, next_entry, entry);
3511 next_entry += 8;
3512 }
3513 BFD_ASSERT (i == 0);
3514 BFD_ASSERT (entry == NULL);
3515 BFD_ASSERT (nt == next_entry);
3516}
3517
9373215c 3518#if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
5879bb8f
NC
3519/* Return the length (number of units) of the first character in S,
3520 putting its 'ucs4_t' representation in *PUC. */
3521
3522static unsigned int
3523u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3524{
3525 unsigned short c = * s;
3526
3527 if (c < 0xd800 || c >= 0xe000)
3528 {
3529 *puc = c;
3530 return 1;
3531 }
3532
3533 if (c < 0xdc00)
3534 {
3535 if (n >= 2)
3536 {
3537 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3538 {
3539 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3540 return 2;
3541 }
3542 }
3543 else
3544 {
3545 /* Incomplete multibyte character. */
3546 *puc = 0xfffd;
3547 return n;
3548 }
3549 }
3550
3551 /* Invalid multibyte character. */
3552 *puc = 0xfffd;
3553 return 1;
3554}
9373215c 3555#endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
5879bb8f
NC
3556
3557/* Perform a comparison of two entries. */
3558static signed int
3559rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3560{
9373215c 3561 signed int res;
9373215c
PM
3562 bfd_byte * astring;
3563 unsigned int alen;
3564 bfd_byte * bstring;
3565 unsigned int blen;
3566
5879bb8f 3567 if (! is_name)
9373215c 3568 return a->name_id.id - b->name_id.id;
5879bb8f
NC
3569
3570 /* We have to perform a case insenstive, unicode string comparison... */
9373215c
PM
3571 astring = a->name_id.name.string;
3572 alen = a->name_id.name.len;
3573 bstring = b->name_id.name.string;
3574 blen = b->name_id.name.len;
5879bb8f 3575
9373215c
PM
3576#if defined __CYGWIN__ || defined __MINGW32__
3577 /* Under Windows hosts (both Cygwin and Mingw types),
3578 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3579 function however goes by different names in the two environments... */
3580
3581#undef rscpcmp
5879bb8f 3582#ifdef __CYGWIN__
9373215c
PM
3583#define rscpcmp wcsncasecmp
3584#endif
3585#ifdef __MINGW32__
3586#define rscpcmp wcsnicmp
3587#endif
3588
3589 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3590 min (alen, blen));
5879bb8f 3591
9373215c 3592#elif defined HAVE_WCHAR_H
3f10b67a
PM
3593 {
3594 unsigned int i;
3595 res = 0;
3596 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3597 {
3598 wchar_t awc;
3599 wchar_t bwc;
3600
3601 /* Convert UTF-16 unicode characters into wchar_t characters so
3602 that we can then perform a case insensitive comparison. */
3603 int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3604 int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3605
3606 if (Alen != Blen)
3607 return Alen - Blen;
3608 res = wcsncasecmp (& awc, & bwc, 1);
3609 if (res)
3610 break;
3611 }
3612 }
5879bb8f 3613#else
9373215c
PM
3614 /* Do the best we can - a case sensitive, untranslated comparison. */
3615 res = memcmp (astring, bstring, min (alen, blen) * 2);
5879bb8f
NC
3616#endif
3617
3618 if (res == 0)
3619 res = alen - blen;
3620
3621 return res;
3622}
3623
3624static void
3625rsrc_print_name (char * buffer, rsrc_string string)
3626{
3627 unsigned int i;
3628 bfd_byte * name = string.string;
3629
3630 for (i = string.len; i--; name += 2)
3631 sprintf (buffer + strlen (buffer), "%.1s", name);
3632}
3633
3634static const char *
3635rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3636{
3637 static char buffer [256];
3638 bfd_boolean is_string = FALSE;
3639
3640 buffer[0] = 0;
3641
9373215c
PM
3642 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3643 && dir->entry->parent->entry != NULL)
5879bb8f
NC
3644 {
3645 strcpy (buffer, "type: ");
3646 if (dir->entry->parent->entry->is_name)
9373215c
PM
3647 rsrc_print_name (buffer + strlen (buffer),
3648 dir->entry->parent->entry->name_id.name);
5879bb8f
NC
3649 else
3650 {
3651 unsigned int id = dir->entry->parent->entry->name_id.id;
3652
3653 sprintf (buffer + strlen (buffer), "%x", id);
3654 switch (id)
3655 {
3656 case 1: strcat (buffer, " (CURSOR)"); break;
3657 case 2: strcat (buffer, " (BITMAP)"); break;
3658 case 3: strcat (buffer, " (ICON)"); break;
3659 case 4: strcat (buffer, " (MENU)"); break;
3660 case 5: strcat (buffer, " (DIALOG)"); break;
3661 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3662 case 7: strcat (buffer, " (FONTDIR)"); break;
3663 case 8: strcat (buffer, " (FONT)"); break;
3664 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3665 case 10: strcat (buffer, " (RCDATA)"); break;
3666 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3667 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3668 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3669 case 16: strcat (buffer, " (VERSION)"); break;
3670 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3671 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3672 case 20: strcat (buffer, " (VXD)"); break;
3673 case 21: strcat (buffer, " (ANICURSOR)"); break;
3674 case 22: strcat (buffer, " (ANIICON)"); break;
3675 case 23: strcat (buffer, " (HTML)"); break;
3676 case 24: strcat (buffer, " (MANIFEST)"); break;
3677 case 240: strcat (buffer, " (DLGINIT)"); break;
3678 case 241: strcat (buffer, " (TOOLBAR)"); break;
3679 }
3680 }
3681 }
3682
3683 if (dir != NULL && dir->entry != NULL)
3684 {
3685 strcat (buffer, " name: ");
3686 if (dir->entry->is_name)
3687 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3688 else
3689 {
3690 unsigned int id = dir->entry->name_id.id;
3691
3692 sprintf (buffer + strlen (buffer), "%x", id);
3693
3694 if (is_string)
3695 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3696 (id - 1) << 4, (id << 4) - 1);
3697 }
3698 }
3699
3700 if (entry != NULL)
3701 {
3702 strcat (buffer, " lang: ");
3703
3704 if (entry->is_name)
3705 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3706 else
3707 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3708 }
3709
3710 return buffer;
3711}
3712
3713/* *sigh* Windows resource strings are special. Only the top 28-bits of
3714 their ID is stored in the NAME entry. The bottom four bits are used as
3715 an index into unicode string table that makes up the data of the leaf.
3716 So identical type-name-lang string resources may not actually be
3717 identical at all.
3718
3719 This function is called when we have detected two string resources with
3720 match top-28-bit IDs. We have to scan the string tables inside the leaves
3721 and discover if there are any real collisions. If there are then we report
9373215c
PM
3722 them and return FALSE. Otherwise we copy any strings from B into A and
3723 then return TRUE. */
5879bb8f
NC
3724
3725static bfd_boolean
3726rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3727 rsrc_entry * b ATTRIBUTE_UNUSED)
3728{
3729 unsigned int copy_needed = 0;
3730 unsigned int i;
9373215c
PM
3731 bfd_byte * astring;
3732 bfd_byte * bstring;
3733 bfd_byte * new_data;
3734 bfd_byte * nstring;
5879bb8f
NC
3735
3736 /* Step one: Find out what we have to do. */
3737 BFD_ASSERT (! a->is_dir);
9373215c 3738 astring = a->value.leaf->data;
5879bb8f
NC
3739
3740 BFD_ASSERT (! b->is_dir);
9373215c 3741 bstring = b->value.leaf->data;
5879bb8f
NC
3742
3743 for (i = 0; i < 16; i++)
3744 {
3745 unsigned int alen = astring[0] + (astring[1] << 8);
3746 unsigned int blen = bstring[0] + (bstring[1] << 8);
3747
3748 if (alen == 0)
3749 {
3750 copy_needed += blen * 2;
3751 }
3752 else if (blen == 0)
3753 ;
3754 else if (alen != blen)
3755 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3756 break;
3757 /* alen == blen != 0. We might have two identical strings. If so we
3758 can ignore the second one. There is no need for wchar_t vs UTF-16
3759 theatrics here - we are only interested in (case sensitive) equality. */
3760 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3761 break;
3762
3763 astring += (alen + 1) * 2;
3764 bstring += (blen + 1) * 2;
3765 }
3766
3767 if (i != 16)
3768 {
3769 if (a->parent != NULL
3770 && a->parent->entry != NULL
3771 && a->parent->entry->is_name == FALSE)
3772 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3773 ((a->parent->entry->name_id.id - 1) << 4) + i);
3774 return FALSE;
3775 }
3776
3777 if (copy_needed == 0)
3778 return TRUE;
3779
3780 /* If we reach here then A and B must both have non-colliding strings.
3781 (We never get string resources with fully empty string tables).
3782 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3783 in B's strings. */
9373215c 3784 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
5879bb8f
NC
3785 if (new_data == NULL)
3786 return FALSE;
3787
9373215c 3788 nstring = new_data;
5879bb8f
NC
3789 astring = a->value.leaf->data;
3790 bstring = b->value.leaf->data;
3791
3792 for (i = 0; i < 16; i++)
3793 {
3794 unsigned int alen = astring[0] + (astring[1] << 8);
3795 unsigned int blen = bstring[0] + (bstring[1] << 8);
3796
3797 if (alen != 0)
3798 {
3799 memcpy (nstring, astring, (alen + 1) * 2);
3800 nstring += (alen + 1) * 2;
3801 }
3802 else if (blen != 0)
3803 {
3804 memcpy (nstring, bstring, (blen + 1) * 2);
3805 nstring += (blen + 1) * 2;
3806 }
3807 else
3808 {
3809 * nstring++ = 0;
3810 * nstring++ = 0;
3811 }
9373215c 3812
5879bb8f
NC
3813 astring += (alen + 1) * 2;
3814 bstring += (blen + 1) * 2;
3815 }
3816
3817 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
9373215c 3818
5879bb8f
NC
3819 free (a->value.leaf->data);
3820 a->value.leaf->data = new_data;
3821 a->value.leaf->size += copy_needed;
3822
3823 return TRUE;
3824}
3825
3826static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3827
3828/* Sort the entries in given part of the directory.
3829 We use an old fashioned bubble sort because we are dealing
9373215c 3830 with lists and we want to handle matches specially. */
5879bb8f
NC
3831
3832static void
3833rsrc_sort_entries (rsrc_dir_chain * chain,
3834 bfd_boolean is_name,
3835 rsrc_directory * dir)
3836{
3837 rsrc_entry * entry;
3838 rsrc_entry * next;
3839 rsrc_entry ** points_to_entry;
3840 bfd_boolean swapped;
3841
3842 if (chain->num_entries < 2)
3843 return;
3844
3845 do
3846 {
3847 swapped = FALSE;
3848 points_to_entry = & chain->first_entry;
3849 entry = * points_to_entry;
3850 next = entry->next_entry;
3851
3852 do
3853 {
3854 signed int cmp = rsrc_cmp (is_name, entry, next);
3855
3856 if (cmp > 0)
3857 {
3858 entry->next_entry = next->next_entry;
3859 next->next_entry = entry;
3860 * points_to_entry = next;
3861 points_to_entry = & next->next_entry;
3862 next = entry->next_entry;
3863 swapped = TRUE;
3864 }
3865 else if (cmp == 0)
3866 {
3867 if (entry->is_dir && next->is_dir)
3868 {
3869 /* When we encounter identical directory entries we have to
3870 merge them together. The exception to this rule is for
3871 resource manifests - there can only be one of these,
3872 even if they differ in language. Zero-language manifests
3873 are assumed to be default manifests (provided by the
3714081c 3874 Cygwin/MinGW build system) and these can be silently dropped,
5879bb8f
NC
3875 unless that would reduce the number of manifests to zero.
3876 There should only ever be one non-zero lang manifest -
3877 if there are more it is an error. A non-zero lang
3878 manifest takes precedence over a default manifest. */
3879 if (entry->is_name == FALSE
3880 && entry->name_id.id == 1
3881 && dir != NULL
3882 && dir->entry != NULL
3883 && dir->entry->is_name == FALSE
3884 && dir->entry->name_id.id == 0x18)
3885 {
3886 if (next->value.directory->names.num_entries == 0
3887 && next->value.directory->ids.num_entries == 1
3888 && next->value.directory->ids.first_entry->is_name == FALSE
3889 && next->value.directory->ids.first_entry->name_id.id == 0)
3890 /* Fall through so that NEXT is dropped. */
3891 ;
3892 else if (entry->value.directory->names.num_entries == 0
3893 && entry->value.directory->ids.num_entries == 1
3894 && entry->value.directory->ids.first_entry->is_name == FALSE
3895 && entry->value.directory->ids.first_entry->name_id.id == 0)
3896 {
3897 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3898 entry->next_entry = next->next_entry;
3899 next->next_entry = entry;
3900 * points_to_entry = next;
3901 points_to_entry = & next->next_entry;
3902 next = entry->next_entry;
3903 swapped = TRUE;
3904 }
3905 else
3906 {
3907 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3908 bfd_set_error (bfd_error_file_truncated);
3909 return;
3910 }
9373215c 3911
5879bb8f
NC
3912 /* Unhook NEXT from the chain. */
3913 /* FIXME: memory loss here. */
3914 entry->next_entry = next->next_entry;
3915 chain->num_entries --;
3916 if (chain->num_entries < 2)
3917 return;
3918 next = next->next_entry;
3919 }
3920 else
3921 rsrc_merge (entry, next);
3922 }
3923 else if (entry->is_dir != next->is_dir)
3924 {
3925 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3926 bfd_set_error (bfd_error_file_truncated);
3927 return;
3928 }
3929 else
3930 {
3931 /* Otherwise with identical leaves we issue an error
3932 message - because there should never be duplicates.
3933 The exception is Type 18/Name 1/Lang 0 which is the
3934 defaul manifest - this can just be dropped. */
3935 if (entry->is_name == FALSE
3936 && entry->name_id.id == 0
3937 && dir != NULL
3938 && dir->entry != NULL
3939 && dir->entry->is_name == FALSE
3940 && dir->entry->name_id.id == 1
3941 && dir->entry->parent != NULL
3942 && dir->entry->parent->entry != NULL
3943 && dir->entry->parent->entry->is_name == FALSE
3944 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3945 ;
3946 else if (dir != NULL
3947 && dir->entry != NULL
3948 && dir->entry->parent != NULL
3949 && dir->entry->parent->entry != NULL
3950 && dir->entry->parent->entry->is_name == FALSE
3951 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3952 {
3953 /* Strings need special handling. */
3954 if (! rsrc_merge_string_entries (entry, next))
3955 {
3956 /* _bfd_error_handler should have been called inside merge_strings. */
3957 bfd_set_error (bfd_error_file_truncated);
3958 return;
3959 }
3960 }
3961 else
3962 {
3963 if (dir == NULL
3964 || dir->entry == NULL
3965 || dir->entry->parent == NULL
3966 || dir->entry->parent->entry == NULL)
3967 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3968 else
3969 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3970 rsrc_resource_name (entry, dir));
3971 bfd_set_error (bfd_error_file_truncated);
3972 return;
3973 }
3974 }
3975
3976 /* Unhook NEXT from the chain. */
3977 entry->next_entry = next->next_entry;
3978 chain->num_entries --;
3979 if (chain->num_entries < 2)
3980 return;
3981 next = next->next_entry;
3982 }
3983 else
3984 {
3985 points_to_entry = & entry->next_entry;
3986 entry = next;
3987 next = next->next_entry;
3988 }
3989 }
3990 while (next);
3991
3992 chain->last_entry = entry;
3993 }
3994 while (swapped);
3995}
3996
3997/* Attach B's chain onto A. */
3998static void
9373215c 3999rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
5879bb8f
NC
4000{
4001 if (bchain->num_entries == 0)
4002 return;
4003
4004 achain->num_entries += bchain->num_entries;
4005
4006 if (achain->first_entry == NULL)
4007 {
4008 achain->first_entry = bchain->first_entry;
4009 achain->last_entry = bchain->last_entry;
4010 }
4011 else
4012 {
4013 achain->last_entry->next_entry = bchain->first_entry;
4014 achain->last_entry = bchain->last_entry;
4015 }
9373215c 4016
5879bb8f
NC
4017 bchain->num_entries = 0;
4018 bchain->first_entry = bchain->last_entry = NULL;
4019}
4020
4021static void
4022rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4023{
9373215c
PM
4024 rsrc_directory * adir;
4025 rsrc_directory * bdir;
4026
5879bb8f
NC
4027 BFD_ASSERT (a->is_dir);
4028 BFD_ASSERT (b->is_dir);
4029
9373215c
PM
4030 adir = a->value.directory;
4031 bdir = b->value.directory;
4032
5879bb8f
NC
4033 if (adir->characteristics != bdir->characteristics)
4034 {
4035 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
4036 bfd_set_error (bfd_error_file_truncated);
4037 return;
4038 }
9373215c 4039
5879bb8f
NC
4040 if (adir->major != bdir->major || adir->minor != bdir->minor)
4041 {
4042 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
4043 bfd_set_error (bfd_error_file_truncated);
4044 return;
4045 }
4046
4047 /* Attach B's name chain to A. */
4048 rsrc_attach_chain (& adir->names, & bdir->names);
4049
4050 /* Attach B's ID chain to A. */
4051 rsrc_attach_chain (& adir->ids, & bdir->ids);
4052
4053 /* Now sort A's entries. */
4054 rsrc_sort_entries (& adir->names, TRUE, adir);
4055 rsrc_sort_entries (& adir->ids, FALSE, adir);
4056}
4057
4058/* Check the .rsrc section. If it contains multiple concatenated
4059 resources then we must merge them properly. Otherwise Windows
4060 will ignore all but the first set. */
4061
4062static void
4063rsrc_process_section (bfd * abfd,
4064 struct coff_final_link_info * pfinfo)
4065{
9373215c
PM
4066 rsrc_directory new_table;
4067 bfd_size_type size;
4068 asection * sec;
4069 pe_data_type * pe;
4070 bfd_vma rva_bias;
4071 bfd_byte * data;
4072 bfd_byte * datastart;
4073 bfd_byte * dataend;
4074 bfd_byte * new_data;
4075 unsigned int num_resource_sets;
4076 rsrc_directory * type_tables;
4077 rsrc_write_data write_data;
4078 unsigned int indx;
6caf7111
NC
4079 bfd * input;
4080 unsigned int num_input_rsrc = 0;
4081 unsigned int max_num_input_rsrc = 4;
4082 ptrdiff_t * rsrc_sizes = NULL;
5879bb8f
NC
4083
4084 new_table.names.num_entries = 0;
4085 new_table.ids.num_entries = 0;
9373215c 4086
5879bb8f
NC
4087 sec = bfd_get_section_by_name (abfd, ".rsrc");
4088 if (sec == NULL || (size = sec->rawsize) == 0)
4089 return;
4090
9373215c 4091 pe = pe_data (abfd);
5879bb8f
NC
4092 if (pe == NULL)
4093 return;
4094
5879bb8f
NC
4095 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4096
9373215c 4097 data = bfd_malloc (size);
5879bb8f
NC
4098 if (data == NULL)
4099 return;
c32abae8 4100
9373215c 4101 datastart = data;
5879bb8f
NC
4102
4103 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4104 goto end;
4105
6caf7111
NC
4106 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4107 their lengths. Note - we rely upon the fact that the linker script
4108 does *not* sort the input .rsrc sections, so that the order in the
4109 linkinfo list matches the order in the output .rsrc section.
4110
4111 We need to know the lengths because each input .rsrc section has padding
4112 at the end of a variable amount. (It does not appear to be based upon
4113 the section alignment or the file alignment). We need to skip any
4114 padding bytes when parsing the input .rsrc sections. */
4115 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4116 if (rsrc_sizes == NULL)
4117 goto end;
4118
4119 for (input = pfinfo->info->input_bfds;
4120 input != NULL;
c72f2fb2 4121 input = input->link.next)
6caf7111
NC
4122 {
4123 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4124
4125 if (rsrc_sec != NULL)
4126 {
4127 if (num_input_rsrc == max_num_input_rsrc)
4128 {
4129 max_num_input_rsrc += 10;
4130 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4131 * sizeof * rsrc_sizes);
4132 if (rsrc_sizes == NULL)
4133 goto end;
4134 }
4135
4136 BFD_ASSERT (rsrc_sec->size > 0);
4137 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4138 }
4139 }
4140
4141 if (num_input_rsrc < 2)
4142 goto end;
61e2488c 4143
5879bb8f
NC
4144 /* Step one: Walk the section, computing the size of the tables,
4145 leaves and data and decide if we need to do anything. */
1d63324c 4146 dataend = data + size;
9373215c 4147 num_resource_sets = 0;
5879bb8f
NC
4148
4149 while (data < dataend)
4150 {
4151 bfd_byte * p = data;
4152
4153 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
1d63324c 4154
5879bb8f
NC
4155 if (data > dataend)
4156 {
4157 /* Corrupted .rsrc section - cannot merge. */
4158 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4159 bfd_get_filename (abfd));
4160 bfd_set_error (bfd_error_file_truncated);
4161 goto end;
4162 }
4163
6caf7111
NC
4164 if ((data - p) > rsrc_sizes [num_resource_sets])
4165 {
4166 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4167 bfd_get_filename (abfd));
4168 bfd_set_error (bfd_error_file_truncated);
4169 goto end;
4170 }
4171 /* FIXME: Should we add a check for "data - p" being much smaller
4172 than rsrc_sizes[num_resource_sets] ? */
4173
4174 data = p + rsrc_sizes[num_resource_sets];
5879bb8f 4175 rva_bias += data - p;
5879bb8f
NC
4176 ++ num_resource_sets;
4177 }
6caf7111 4178 BFD_ASSERT (num_resource_sets == num_input_rsrc);
5879bb8f
NC
4179
4180 /* Step two: Walk the data again, building trees of the resources. */
4181 data = datastart;
4182 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4183
9373215c 4184 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
5879bb8f
NC
4185 if (type_tables == NULL)
4186 goto end;
4187
9373215c 4188 indx = 0;
5879bb8f
NC
4189 while (data < dataend)
4190 {
4191 bfd_byte * p = data;
4192
6caf7111 4193 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
9373215c 4194 dataend, rva_bias, NULL);
6caf7111 4195 data = p + rsrc_sizes[indx];
5879bb8f 4196 rva_bias += data - p;
6caf7111 4197 ++ indx;
5879bb8f 4198 }
337e86d7 4199 BFD_ASSERT (indx == num_resource_sets);
9373215c 4200
5879bb8f 4201 /* Step three: Merge the top level tables (there can be only one).
9373215c 4202
5879bb8f 4203 We must ensure that the merged entries are in ascending order.
9373215c 4204
5879bb8f
NC
4205 We also thread the top level table entries from the old tree onto
4206 the new table, so that they can be pulled off later. */
4207
4208 /* FIXME: Should we verify that all type tables are the same ? */
4209 new_table.characteristics = type_tables[0].characteristics;
4210 new_table.time = type_tables[0].time;
4211 new_table.major = type_tables[0].major;
4212 new_table.minor = type_tables[0].minor;
4213
4214 /* Chain the NAME entries onto the table. */
4215 new_table.names.first_entry = NULL;
4216 new_table.names.last_entry = NULL;
4217
337e86d7
L
4218 for (indx = 0; indx < num_resource_sets; indx++)
4219 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
5879bb8f
NC
4220
4221 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
9373215c 4222
5879bb8f
NC
4223 /* Chain the ID entries onto the table. */
4224 new_table.ids.first_entry = NULL;
4225 new_table.ids.last_entry = NULL;
4226
337e86d7
L
4227 for (indx = 0; indx < num_resource_sets; indx++)
4228 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
5879bb8f
NC
4229
4230 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4231
4232 /* Step four: Create new contents for the .rsrc section. */
3714081c
NC
4233 /* Step four point one: Compute the size of each region of the .rsrc section.
4234 We do this now, rather than earlier, as the merging above may have dropped
4235 some entries. */
4236 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4237 rsrc_compute_region_sizes (& new_table);
4238 /* We increment sizeof_strings to make sure that resource data
4239 starts on an 8-byte boundary. FIXME: Is this correct ? */
4240 sizeof_strings = (sizeof_strings + 7) & ~ 7;
4241
c32abae8 4242 new_data = bfd_zalloc (abfd, size);
5879bb8f
NC
4243 if (new_data == NULL)
4244 goto end;
4245
5879bb8f
NC
4246 write_data.abfd = abfd;
4247 write_data.datastart = new_data;
4248 write_data.next_table = new_data;
4249 write_data.next_leaf = new_data + sizeof_tables_and_entries;
4250 write_data.next_string = write_data.next_leaf + sizeof_leaves;
4251 write_data.next_data = write_data.next_string + sizeof_strings;
9373215c 4252 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
5879bb8f
NC
4253
4254 rsrc_write_directory (& write_data, & new_table);
4255
4256 /* Step five: Replace the old contents with the new.
4257 We recompute the size as we may have lost entries due to mergeing. */
9373215c 4258 size = ((write_data.next_data - new_data) + 3) & ~ 3;
c32abae8
NC
4259
4260 {
4261 int page_size;
4262
4263 if (coff_data (abfd)->link_info)
4264 {
4265 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
4266
4267 /* If no file alignment has been set, default to one.
4268 This repairs 'ld -r' for arm-wince-pe target. */
4269 if (page_size == 0)
4270 page_size = 1;
4271 }
4272 else
4273 page_size = PE_DEF_FILE_ALIGNMENT;
4274 size = (size + page_size - 1) & - page_size;
4275 }
4276
5879bb8f
NC
4277 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4278 sec->size = sec->rawsize = size;
9373215c 4279
5879bb8f 4280 end:
3714081c 4281 /* Step six: Free all the memory that we have used. */
5879bb8f
NC
4282 /* FIXME: Free the resource tree, if we have one. */
4283 free (datastart);
6caf7111 4284 free (rsrc_sizes);
5879bb8f 4285}
5174d0fb 4286
2fbadf2c
ILT
4287/* Handle the .idata section and other things that need symbol table
4288 access. */
4289
b34976b6 4290bfd_boolean
7920ce38 4291_bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2fbadf2c
ILT
4292{
4293 struct coff_link_hash_entry *h1;
4294 struct bfd_link_info *info = pfinfo->info;
4e22f78d 4295 bfd_boolean result = TRUE;
2fbadf2c
ILT
4296
4297 /* There are a few fields that need to be filled in now while we
4298 have symbol table access.
4299
4300 The .idata subsections aren't directly available as sections, but
4301 they are in the symbol table, so get them from there. */
4302
4303 /* The import directory. This is the address of .idata$2, with size
4304 of .idata$2 + .idata$3. */
4305 h1 = coff_link_hash_lookup (coff_hash_table (info),
b34976b6 4306 ".idata$2", FALSE, FALSE, TRUE);
2fbadf2c
ILT
4307 if (h1 != NULL)
4308 {
4e1fc599 4309 /* PR ld/2729: We cannot rely upon all the output sections having been
4e22f78d
NC
4310 created properly, so check before referencing them. Issue a warning
4311 message for any sections tht could not be found. */
b92997d6
AM
4312 if ((h1->root.type == bfd_link_hash_defined
4313 || h1->root.type == bfd_link_hash_defweak)
4314 && h1->root.u.def.section != NULL
4e22f78d 4315 && h1->root.u.def.section->output_section != NULL)
6c73cbb1 4316 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4e22f78d
NC
4317 (h1->root.u.def.value
4318 + h1->root.u.def.section->output_section->vma
4319 + h1->root.u.def.section->output_offset);
4320 else
4321 {
4322 _bfd_error_handler
4e1fc599 4323 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4e22f78d
NC
4324 abfd);
4325 result = FALSE;
4326 }
4327
2fbadf2c 4328 h1 = coff_link_hash_lookup (coff_hash_table (info),
b34976b6 4329 ".idata$4", FALSE, FALSE, TRUE);
4e22f78d 4330 if (h1 != NULL
b92997d6
AM
4331 && (h1->root.type == bfd_link_hash_defined
4332 || h1->root.type == bfd_link_hash_defweak)
4e22f78d
NC
4333 && h1->root.u.def.section != NULL
4334 && h1->root.u.def.section->output_section != NULL)
6c73cbb1 4335 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4e22f78d
NC
4336 ((h1->root.u.def.value
4337 + h1->root.u.def.section->output_section->vma
4338 + h1->root.u.def.section->output_offset)
6c73cbb1 4339 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4e22f78d
NC
4340 else
4341 {
4342 _bfd_error_handler
4e1fc599 4343 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4e22f78d
NC
4344 abfd);
4345 result = FALSE;
4346 }
2fbadf2c
ILT
4347
4348 /* The import address table. This is the size/address of
4349 .idata$5. */
4350 h1 = coff_link_hash_lookup (coff_hash_table (info),
b34976b6 4351 ".idata$5", FALSE, FALSE, TRUE);
4e22f78d 4352 if (h1 != NULL
b92997d6
AM
4353 && (h1->root.type == bfd_link_hash_defined
4354 || h1->root.type == bfd_link_hash_defweak)
4e22f78d
NC
4355 && h1->root.u.def.section != NULL
4356 && h1->root.u.def.section->output_section != NULL)
6c73cbb1 4357 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4e22f78d
NC
4358 (h1->root.u.def.value
4359 + h1->root.u.def.section->output_section->vma
4360 + h1->root.u.def.section->output_offset);
4361 else
4362 {
4363 _bfd_error_handler
4e1fc599 4364 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4e22f78d
NC
4365 abfd);
4366 result = FALSE;
4367 }
4368
2fbadf2c 4369 h1 = coff_link_hash_lookup (coff_hash_table (info),
b34976b6 4370 ".idata$6", FALSE, FALSE, TRUE);
4e22f78d 4371 if (h1 != NULL
b92997d6
AM
4372 && (h1->root.type == bfd_link_hash_defined
4373 || h1->root.type == bfd_link_hash_defweak)
4e22f78d
NC
4374 && h1->root.u.def.section != NULL
4375 && h1->root.u.def.section->output_section != NULL)
6c73cbb1 4376 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4e22f78d
NC
4377 ((h1->root.u.def.value
4378 + h1->root.u.def.section->output_section->vma
4379 + h1->root.u.def.section->output_offset)
4e1fc599 4380 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4e22f78d
NC
4381 else
4382 {
4383 _bfd_error_handler
4e1fc599 4384 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4e22f78d
NC
4385 abfd);
4386 result = FALSE;
4387 }
2fbadf2c 4388 }
cb2f80e6
KT
4389 else
4390 {
4391 h1 = coff_link_hash_lookup (coff_hash_table (info),
4392 "__IAT_start__", FALSE, FALSE, TRUE);
4393 if (h1 != NULL
4394 && (h1->root.type == bfd_link_hash_defined
4395 || h1->root.type == bfd_link_hash_defweak)
4396 && h1->root.u.def.section != NULL
4397 && h1->root.u.def.section->output_section != NULL)
4398 {
4399 bfd_vma iat_va;
4400
4401 iat_va =
4402 (h1->root.u.def.value
4403 + h1->root.u.def.section->output_section->vma
4404 + h1->root.u.def.section->output_offset);
4405
4406 h1 = coff_link_hash_lookup (coff_hash_table (info),
4407 "__IAT_end__", FALSE, FALSE, TRUE);
4408 if (h1 != NULL
4409 && (h1->root.type == bfd_link_hash_defined
4410 || h1->root.type == bfd_link_hash_defweak)
4411 && h1->root.u.def.section != NULL
4412 && h1->root.u.def.section->output_section != NULL)
4413 {
4414 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4415 ((h1->root.u.def.value
4416 + h1->root.u.def.section->output_section->vma
4417 + h1->root.u.def.section->output_offset)
4418 - iat_va);
4419 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4420 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4421 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4422 }
4423 else
4424 {
4425 _bfd_error_handler
4426 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4427 " because .idata$6 is missing"), abfd);
4428 result = FALSE;
4429 }
4430 }
4431 }
ca6dee30
NC
4432
4433 h1 = coff_link_hash_lookup (coff_hash_table (info),
61e2488c 4434 (bfd_get_symbol_leading_char (abfd) != 0
c91a930c
KT
4435 ? "__tls_used" : "_tls_used"),
4436 FALSE, FALSE, TRUE);
ca6dee30
NC
4437 if (h1 != NULL)
4438 {
b92997d6
AM
4439 if ((h1->root.type == bfd_link_hash_defined
4440 || h1->root.type == bfd_link_hash_defweak)
4441 && h1->root.u.def.section != NULL
4e22f78d 4442 && h1->root.u.def.section->output_section != NULL)
6c73cbb1 4443 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4e22f78d
NC
4444 (h1->root.u.def.value
4445 + h1->root.u.def.section->output_section->vma
4446 + h1->root.u.def.section->output_offset
4447 - pe_data (abfd)->pe_opthdr.ImageBase);
4448 else
4449 {
4450 _bfd_error_handler
4e1fc599 4451 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4e22f78d
NC
4452 abfd);
4453 result = FALSE;
4454 }
bc2b2990
PM
4455 /* According to PECOFF sepcifications by Microsoft version 8.2
4456 the TLS data directory consists of 4 pointers, followed
4457 by two 4-byte integer. This implies that the total size
68ffbac6 4458 is different for 32-bit and 64-bit executables. */
bc2b2990 4459#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
6c73cbb1 4460 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
bc2b2990
PM
4461#else
4462 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4463#endif
ca6dee30
NC
4464 }
4465
5174d0fb
KT
4466/* If there is a .pdata section and we have linked pdata finally, we
4467 need to sort the entries ascending. */
4468#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4469 {
4470 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4471
4472 if (sec)
4473 {
21e68916
KT
4474 bfd_size_type x = sec->rawsize;
4475 bfd_byte *tmp_data = NULL;
5174d0fb 4476
21e68916
KT
4477 if (x)
4478 tmp_data = bfd_malloc (x);
4479
4480 if (tmp_data != NULL)
5174d0fb 4481 {
21e68916
KT
4482 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4483 {
4484 qsort (tmp_data,
4485 (size_t) (x / 12),
4486 12, sort_x64_pdata);
4487 bfd_set_section_contents (pfinfo->output_bfd, sec,
4488 tmp_data, 0, x);
4489 }
4490 free (tmp_data);
5174d0fb 4491 }
86eafac0
NC
4492 else
4493 result = FALSE;
5174d0fb
KT
4494 }
4495 }
4496#endif
4497
5879bb8f
NC
4498 rsrc_process_section (abfd, pfinfo);
4499
2fbadf2c
ILT
4500 /* If we couldn't find idata$2, we either have an excessively
4501 trivial program or are in DEEP trouble; we have to assume trivial
4502 program.... */
4e22f78d 4503 return result;
2fbadf2c 4504}
This page took 1.061593 seconds and 4 git commands to generate.