1 /* NLM (NetWare Loadable Module) executable support for BFD.
2 Copyright (C) 1993 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, using ELF support as the
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include <string.h> /* For strrchr and friends */
29 /* The functions in this file do not use the names they appear to use.
30 This file is actually compiled multiple times, once for each size
31 of NLM target we are using. At each size we use a different name,
32 constructed by the macro nlmNAME. For example, the function which
33 is named nlm_symbol_type below is actually named nlm32_symbol_type
34 in the final executable. */
36 #define Nlm_External_Fixed_Header NlmNAME(External_Fixed_Header)
37 #define Nlm_External_Version_Header NlmNAME(External_Version_Header)
38 #define Nlm_External_Copyright_Header NlmNAME(External_Copyright_Header)
39 #define Nlm_External_Extended_Header NlmNAME(External_Extended_Header)
40 #define Nlm_External_Custom_Header NlmNAME(External_Custom_Header)
41 #define Nlm_External_Cygnus_Ext_Header NlmNAME(External_Cygnus_Ext_Header)
43 #define nlm_symbol_type nlmNAME(symbol_type)
44 #define nlm_get_symtab_upper_bound nlmNAME(get_symtab_upper_bound)
45 #define nlm_get_symtab nlmNAME(get_symtab)
46 #define nlm_make_empty_symbol nlmNAME(make_empty_symbol)
47 #define nlm_print_symbol nlmNAME(print_symbol)
48 #define nlm_get_symbol_info nlmNAME(get_symbol_info)
49 #define nlm_get_reloc_upper_bound nlmNAME(get_reloc_upper_bound)
50 #define nlm_canonicalize_reloc nlmNAME(canonicalize_reloc)
51 #define nlm_object_p nlmNAME(object_p)
52 #define nlm_set_section_contents nlmNAME(set_section_contents)
53 #define nlm_write_object_contents nlmNAME(write_object_contents)
55 #define nlm_swap_fixed_header_in(abfd,src,dst) \
56 (nlm_swap_fixed_header_in_func(abfd))(abfd,src,dst)
57 #define nlm_swap_fixed_header_out(abfd,src,dst) \
58 (nlm_swap_fixed_header_out_func(abfd))(abfd,src,dst)
60 /* Forward declarations of static functions */
62 static boolean add_bfd_section
63 PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
64 static boolean nlm_swap_variable_header_in
66 static boolean nlm_swap_variable_header_out
68 static boolean find_nonzero
69 PARAMS ((PTR, size_t));
70 static boolean nlm_swap_auxiliary_headers_in
72 static boolean nlm_swap_auxiliary_headers_out
74 static boolean nlm_slurp_symbol_table
76 static boolean nlm_slurp_reloc_fixups
78 static boolean nlm_compute_section_file_positions
80 static int nlm_external_reloc_compare
81 PARAMS ((const void *, const void *));
83 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
84 can be handled by explicitly specifying 32 bits or "the long type". */
86 #define put_word bfd_h_put_64
87 #define get_word bfd_h_get_64
90 #define put_word bfd_h_put_32
91 #define get_word bfd_h_get_32
98 struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
99 boolean (*backend_object_p) PARAMS ((bfd *));
101 Nlm_Internal_Fixed_Header *i_fxdhdrp;
102 struct nlm_obj_tdata *new_tdata = NULL;
103 const char *signature;
104 enum bfd_architecture arch;
106 /* Some NLM formats have a prefix before the standard NLM fixed
108 backend_object_p = nlm_backend_object_p_func (abfd);
109 if (backend_object_p)
111 if (!(*backend_object_p) (abfd))
112 goto got_wrong_format_error;
115 /* Read in the fixed length portion of the NLM header in external format. */
117 x_fxdhdr = (PTR) malloc (nlm_fixed_header_size (abfd));
118 if (x_fxdhdr == NULL)
120 bfd_set_error (bfd_error_no_memory);
124 if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
125 nlm_fixed_header_size (abfd))
127 if (bfd_get_error () != bfd_error_system_call)
128 goto got_wrong_format_error;
133 /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
134 the tdata pointer in the bfd. */
136 new_tdata = ((struct nlm_obj_tdata *)
137 bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata)));
138 if (new_tdata == NULL)
140 bfd_set_error (bfd_error_no_memory);
144 nlm_tdata (abfd) = new_tdata;
146 i_fxdhdrp = nlm_fixed_header (abfd);
147 nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
151 /* Check to see if we have an NLM file for this backend by matching
152 the NLM signature. */
154 signature = nlm_signature (abfd);
155 if (signature != NULL
156 && *signature != '\0'
157 && strncmp ((char *) i_fxdhdrp->signature, signature,
158 NLM_SIGNATURE_SIZE) != 0)
159 goto got_wrong_format_error;
161 /* There's no supported way to discover the endianess of an NLM, so test for
162 a sane version number after doing byte swapping appropriate for this
163 XVEC. (Hack alert!) */
165 if (i_fxdhdrp->version > 0xFFFF)
166 goto got_wrong_format_error;
168 /* There's no supported way to check for 32 bit versus 64 bit addresses,
169 so ignore this distinction for now. (FIXME) */
171 /* Swap in the rest of the required header. */
172 if (!nlm_swap_variable_header_in (abfd))
174 if (bfd_get_error () != bfd_error_system_call)
175 goto got_wrong_format_error;
180 /* Add the sections supplied by all NLM's, and then read in the
181 auxiliary headers. Reading the auxiliary headers may create
182 additional sections described in the cygnus_ext header.
183 From this point on we assume that we have an NLM, and do not
184 treat errors as indicating the wrong format. */
186 if (!add_bfd_section (abfd, NLM_CODE_NAME,
187 i_fxdhdrp->codeImageOffset,
188 i_fxdhdrp->codeImageSize,
189 (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
191 || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
192 i_fxdhdrp->dataImageOffset,
193 i_fxdhdrp->dataImageSize,
194 (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
196 || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
198 i_fxdhdrp->uninitializedDataSize,
202 if (!nlm_swap_auxiliary_headers_in (abfd))
205 if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
206 || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
207 abfd->flags |= HAS_RELOC;
208 if (nlm_fixed_header (abfd)->numberOfPublics != 0
209 || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
210 || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
211 abfd->flags |= HAS_SYMS;
213 arch = nlm_architecture (abfd);
214 if (arch != bfd_arch_unknown)
215 bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
219 got_wrong_format_error:
220 bfd_set_error (bfd_error_wrong_format);
222 nlm_tdata (abfd) = preserved_tdata;
223 if (new_tdata != NULL)
224 bfd_release (abfd, new_tdata);
225 if (x_fxdhdr != NULL)
230 /* Add a section to the bfd. */
233 add_bfd_section (abfd, name, offset, size, flags)
242 newsect = bfd_make_section (abfd, name);
247 newsect->vma = 0; /* NLM's are relocatable. */
248 newsect->_raw_size = size;
249 newsect->filepos = offset;
250 newsect->flags = flags;
251 newsect->alignment_power = bfd_log2 (0); /* FIXME */
255 /* Read and swap in the variable length header. All the fields must
256 exist in the NLM, and must exist in the order they are read here. */
259 nlm_swap_variable_header_in (abfd)
262 unsigned char temp[NLM_TARGET_LONG_SIZE];
264 /* Read the description length and text members. */
266 if (bfd_read ((PTR) & nlm_variable_header (abfd)->descriptionLength,
267 sizeof (nlm_variable_header (abfd)->descriptionLength),
269 sizeof (nlm_variable_header (abfd)->descriptionLength))
271 if (bfd_read ((PTR) nlm_variable_header (abfd)->descriptionText,
272 nlm_variable_header (abfd)->descriptionLength + 1,
274 nlm_variable_header (abfd)->descriptionLength + 1)
277 /* Read and convert the stackSize field. */
279 if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
281 nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
283 /* Read and convert the reserved field. */
285 if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
287 nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
289 /* Read the oldThreadName field. This field is a fixed length string. */
291 if (bfd_read ((PTR) nlm_variable_header (abfd)->oldThreadName,
292 sizeof (nlm_variable_header (abfd)->oldThreadName),
294 sizeof (nlm_variable_header (abfd)->oldThreadName))
297 /* Read the screen name length and text members. */
299 if (bfd_read ((PTR) & nlm_variable_header (abfd)->screenNameLength,
300 sizeof (nlm_variable_header (abfd)->screenNameLength),
302 sizeof (nlm_variable_header (abfd)->screenNameLength))
304 if (bfd_read ((PTR) nlm_variable_header (abfd)->screenName,
305 nlm_variable_header (abfd)->screenNameLength + 1,
307 nlm_variable_header (abfd)->screenNameLength + 1)
310 /* Read the thread name length and text members. */
312 if (bfd_read ((PTR) & nlm_variable_header (abfd)->threadNameLength,
313 sizeof (nlm_variable_header (abfd)->threadNameLength),
315 sizeof (nlm_variable_header (abfd)->threadNameLength))
317 if (bfd_read ((PTR) nlm_variable_header (abfd)->threadName,
318 nlm_variable_header (abfd)->threadNameLength + 1,
320 nlm_variable_header (abfd)->threadNameLength + 1)
325 /* Swap and write out the variable length header. All the fields must
326 exist in the NLM, and must exist in this order. */
329 nlm_swap_variable_header_out (abfd)
332 unsigned char temp[NLM_TARGET_LONG_SIZE];
334 /* Write the description length and text members. */
336 if (bfd_write ((PTR) & nlm_variable_header (abfd)->descriptionLength,
337 sizeof (nlm_variable_header (abfd)->descriptionLength),
339 sizeof (nlm_variable_header (abfd)->descriptionLength))
341 if (bfd_write ((PTR) nlm_variable_header (abfd)->descriptionText,
342 nlm_variable_header (abfd)->descriptionLength + 1,
344 nlm_variable_header (abfd)->descriptionLength + 1)
347 /* Convert and write the stackSize field. */
349 put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize,
351 if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
354 /* Convert and write the reserved field. */
356 put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
358 if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
361 /* Write the oldThreadName field. This field is a fixed length string. */
363 if (bfd_write ((PTR) nlm_variable_header (abfd)->oldThreadName,
364 sizeof (nlm_variable_header (abfd)->oldThreadName),
366 sizeof (nlm_variable_header (abfd)->oldThreadName))
369 /* Write the screen name length and text members. */
371 if (bfd_write ((PTR) & nlm_variable_header (abfd)->screenNameLength,
372 sizeof (nlm_variable_header (abfd)->screenNameLength),
374 sizeof (nlm_variable_header (abfd)->screenNameLength))
376 if (bfd_write ((PTR) nlm_variable_header (abfd)->screenName,
377 nlm_variable_header (abfd)->screenNameLength + 1,
379 nlm_variable_header (abfd)->screenNameLength + 1)
382 /* Write the thread name length and text members. */
384 if (bfd_write ((PTR) & nlm_variable_header (abfd)->threadNameLength,
385 sizeof (nlm_variable_header (abfd)->threadNameLength),
387 sizeof (nlm_variable_header (abfd)->threadNameLength))
389 if (bfd_write ((PTR) nlm_variable_header (abfd)->threadName,
390 nlm_variable_header (abfd)->threadNameLength + 1,
392 nlm_variable_header (abfd)->threadNameLength + 1)
397 /* Read and swap in the contents of all the auxiliary headers. Because of
398 the braindead design, we have to do strcmps on strings of indeterminate
399 length to figure out what each auxiliary header is. Even worse, we have
400 no way of knowing how many auxiliary headers there are or where the end
401 of the auxiliary headers are, except by finding something that doesn't
402 look like a known auxiliary header. This means that the first new type
403 of auxiliary header added will break all existing tools that don't
407 nlm_swap_auxiliary_headers_in (abfd)
415 position = bfd_tell (abfd);
416 if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) !=
419 if (bfd_seek (abfd, position, SEEK_SET) == -1)
421 if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
423 Nlm_External_Version_Header thdr;
424 if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
426 memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
427 sizeof (thdr.stamp));
428 nlm_version_header (abfd)->majorVersion =
429 get_word (abfd, (bfd_byte *) thdr.majorVersion);
430 nlm_version_header (abfd)->minorVersion =
431 get_word (abfd, (bfd_byte *) thdr.minorVersion);
432 nlm_version_header (abfd)->revision =
433 get_word (abfd, (bfd_byte *) thdr.revision);
434 nlm_version_header (abfd)->year =
435 get_word (abfd, (bfd_byte *) thdr.year);
436 nlm_version_header (abfd)->month =
437 get_word (abfd, (bfd_byte *) thdr.month);
438 nlm_version_header (abfd)->day =
439 get_word (abfd, (bfd_byte *) thdr.day);
441 else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
443 Nlm_External_Extended_Header thdr;
444 if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
446 memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
447 sizeof (thdr.stamp));
448 nlm_extended_header (abfd)->languageID =
449 get_word (abfd, (bfd_byte *) thdr.languageID);
450 nlm_extended_header (abfd)->messageFileOffset =
451 get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
452 nlm_extended_header (abfd)->messageFileLength =
453 get_word (abfd, (bfd_byte *) thdr.messageFileLength);
454 nlm_extended_header (abfd)->messageCount =
455 get_word (abfd, (bfd_byte *) thdr.messageCount);
456 nlm_extended_header (abfd)->helpFileOffset =
457 get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
458 nlm_extended_header (abfd)->helpFileLength =
459 get_word (abfd, (bfd_byte *) thdr.helpFileLength);
460 nlm_extended_header (abfd)->RPCDataOffset =
461 get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
462 nlm_extended_header (abfd)->RPCDataLength =
463 get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
464 nlm_extended_header (abfd)->sharedCodeOffset =
465 get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
466 nlm_extended_header (abfd)->sharedCodeLength =
467 get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
468 nlm_extended_header (abfd)->sharedDataOffset =
469 get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
470 nlm_extended_header (abfd)->sharedDataLength =
471 get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
472 nlm_extended_header (abfd)->sharedRelocationFixupOffset =
473 get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
474 nlm_extended_header (abfd)->sharedRelocationFixupCount =
475 get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
476 nlm_extended_header (abfd)->sharedExternalReferenceOffset =
477 get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
478 nlm_extended_header (abfd)->sharedExternalReferenceCount =
479 get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
480 nlm_extended_header (abfd)->sharedPublicsOffset =
481 get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
482 nlm_extended_header (abfd)->sharedPublicsCount =
483 get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
484 nlm_extended_header (abfd)->sharedDebugRecordOffset =
485 get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
486 nlm_extended_header (abfd)->sharedDebugRecordCount =
487 get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
488 nlm_extended_header (abfd)->SharedInitializationOffset =
489 get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
490 nlm_extended_header (abfd)->SharedExitProcedureOffset =
491 get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
492 nlm_extended_header (abfd)->productID =
493 get_word (abfd, (bfd_byte *) thdr.productID);
494 nlm_extended_header (abfd)->reserved0 =
495 get_word (abfd, (bfd_byte *) thdr.reserved0);
496 nlm_extended_header (abfd)->reserved1 =
497 get_word (abfd, (bfd_byte *) thdr.reserved1);
498 nlm_extended_header (abfd)->reserved2 =
499 get_word (abfd, (bfd_byte *) thdr.reserved2);
500 nlm_extended_header (abfd)->reserved3 =
501 get_word (abfd, (bfd_byte *) thdr.reserved3);
502 nlm_extended_header (abfd)->reserved4 =
503 get_word (abfd, (bfd_byte *) thdr.reserved4);
504 nlm_extended_header (abfd)->reserved5 =
505 get_word (abfd, (bfd_byte *) thdr.reserved5);
507 else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
509 if (bfd_read ((PTR) nlm_copyright_header (abfd)->stamp,
510 sizeof (nlm_copyright_header (abfd)->stamp),
512 != sizeof (nlm_copyright_header (abfd)->stamp))
514 if (bfd_read ((PTR) & (nlm_copyright_header (abfd)
515 ->copyrightMessageLength),
518 /* The copyright message is a variable length string. */
519 if (bfd_read ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
520 nlm_copyright_header (abfd)->copyrightMessageLength + 1,
522 nlm_copyright_header (abfd)->copyrightMessageLength + 1)
525 else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
527 Nlm_External_Custom_Header thdr;
528 bfd_size_type hdrLength;
530 bfd_size_type dataLength;
534 /* Read the stamp ("CuStHeAd"). */
535 if (bfd_read ((PTR) thdr.stamp, 1, sizeof (thdr.stamp), abfd)
536 != sizeof (thdr.stamp))
538 /* Read the length of this custom header. */
539 if (bfd_read ((PTR) thdr.length, 1, sizeof (thdr.length), abfd)
540 != sizeof (thdr.length))
542 hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
543 /* Read further fields if we have them. */
544 if (hdrLength < NLM_TARGET_LONG_SIZE)
548 if (bfd_read ((PTR) thdr.dataOffset, 1,
549 sizeof (thdr.dataOffset), abfd)
550 != sizeof (thdr.dataOffset))
552 dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
554 if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
558 if (bfd_read ((PTR) thdr.dataLength, 1,
559 sizeof (thdr.dataLength), abfd)
560 != sizeof (thdr.dataLength))
562 dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
564 if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
565 memset (dataStamp, 0, sizeof (dataStamp));
568 if (bfd_read ((PTR) dataStamp, 1, sizeof (dataStamp), abfd)
569 != sizeof (dataStamp))
573 /* Read the rest of the header, if any. */
574 if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
581 hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
582 hdr = bfd_alloc (abfd, hdrLength);
585 bfd_set_error (bfd_error_no_memory);
588 if (bfd_read (hdr, 1, hdrLength, abfd) != hdrLength)
592 /* If we have found a Cygnus header, process it. Otherwise,
593 just save the associated data without trying to interpret
595 if (strncmp (dataStamp, "CyGnUsEx", 8) == 0)
601 BFD_ASSERT (hdrLength == 0 && hdr == NULL);
603 pos = bfd_tell (abfd);
604 if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
606 contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
607 if (contents == NULL)
609 bfd_set_error (bfd_error_no_memory);
612 if (bfd_read (contents, 1, dataLength, abfd) != dataLength)
614 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
617 memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
618 nlm_cygnus_ext_header (abfd)->offset = dataOffset;
619 nlm_cygnus_ext_header (abfd)->length = dataLength;
621 /* This data this header points to provides a list of
622 the sections which were in the original object file
623 which was converted to become an NLM. We locate
624 those sections and add them to the BFD. Note that
625 this is likely to create a second .text, .data and
626 .bss section; retrieving the sections by name will
627 get the actual NLM sections, which is what we want to
628 happen. The sections from the original file, which
629 may be subsets of the NLM section, can only be found
630 using bfd_map_over_sections. */
632 pend = p + dataLength;
641 /* The format of this information is
642 null terminated section name
643 zeroes to adjust to 4 byte boundary
644 4 byte section data file pointer
649 l = strlen (name) + 1;
652 filepos = bfd_h_get_32 (abfd, p);
654 size = bfd_h_get_32 (abfd, p);
657 newsec = bfd_make_section_anyway (abfd, name);
658 if (newsec == (asection *) NULL)
660 newsec->_raw_size = size;
663 newsec->filepos = filepos;
664 newsec->flags |= SEC_HAS_CONTENTS;
670 memcpy (nlm_custom_header (abfd)->stamp, thdr.stamp,
671 sizeof (thdr.stamp));
672 nlm_custom_header (abfd)->hdrLength = hdrLength;
673 nlm_custom_header (abfd)->dataOffset = dataOffset;
674 nlm_custom_header (abfd)->dataLength = dataLength;
675 memcpy (nlm_custom_header (abfd)->dataStamp, dataStamp,
677 nlm_custom_header (abfd)->hdr = hdr;
688 /* Return whether there is a non-zero byte in a memory block. */
691 find_nonzero (buf, size)
695 char *p = (char *) buf;
703 /* Swap out the contents of the auxiliary headers. We create those
704 auxiliary headers which have been set non-zero. We do not require
705 the caller to set up the stamp fields. */
708 nlm_swap_auxiliary_headers_out (abfd)
711 /* Write out the version header if there is one. */
712 if (find_nonzero ((PTR) nlm_version_header (abfd),
713 sizeof (Nlm_Internal_Version_Header)))
715 Nlm_External_Version_Header thdr;
717 memcpy (thdr.stamp, "VeRsIoN#", 8);
718 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion,
719 (bfd_byte *) thdr.majorVersion);
720 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion,
721 (bfd_byte *) thdr.minorVersion);
722 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision,
723 (bfd_byte *) thdr.revision);
724 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year,
725 (bfd_byte *) thdr.year);
726 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month,
727 (bfd_byte *) thdr.month);
728 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
729 (bfd_byte *) thdr.day);
730 if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
734 /* Write out the extended header if there is one. */
735 if (find_nonzero ((PTR) nlm_extended_header (abfd),
736 sizeof (Nlm_Internal_Extended_Header)))
738 Nlm_External_Extended_Header thdr;
740 memcpy (thdr.stamp, "MeSsAgEs", 8);
742 (bfd_vma) nlm_extended_header (abfd)->languageID,
743 (bfd_byte *) thdr.languageID);
745 (bfd_vma) nlm_extended_header (abfd)->messageFileOffset,
746 (bfd_byte *) thdr.messageFileOffset);
748 (bfd_vma) nlm_extended_header (abfd)->messageFileLength,
749 (bfd_byte *) thdr.messageFileLength);
751 (bfd_vma) nlm_extended_header (abfd)->messageCount,
752 (bfd_byte *) thdr.messageCount);
754 (bfd_vma) nlm_extended_header (abfd)->helpFileOffset,
755 (bfd_byte *) thdr.helpFileOffset);
757 (bfd_vma) nlm_extended_header (abfd)->helpFileLength,
758 (bfd_byte *) thdr.helpFileLength);
760 (bfd_vma) nlm_extended_header (abfd)->RPCDataOffset,
761 (bfd_byte *) thdr.RPCDataOffset);
763 (bfd_vma) nlm_extended_header (abfd)->RPCDataLength,
764 (bfd_byte *) thdr.RPCDataLength);
766 (bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset,
767 (bfd_byte *) thdr.sharedCodeOffset);
769 (bfd_vma) nlm_extended_header (abfd)->sharedCodeLength,
770 (bfd_byte *) thdr.sharedCodeLength);
772 (bfd_vma) nlm_extended_header (abfd)->sharedDataOffset,
773 (bfd_byte *) thdr.sharedDataOffset);
775 (bfd_vma) nlm_extended_header (abfd)->sharedDataLength,
776 (bfd_byte *) thdr.sharedDataLength);
778 (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset,
779 (bfd_byte *) thdr.sharedRelocationFixupOffset);
781 (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount,
782 (bfd_byte *) thdr.sharedRelocationFixupCount);
784 (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset,
785 (bfd_byte *) thdr.sharedExternalReferenceOffset);
787 (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount,
788 (bfd_byte *) thdr.sharedExternalReferenceCount);
790 (bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset,
791 (bfd_byte *) thdr.sharedPublicsOffset);
793 (bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount,
794 (bfd_byte *) thdr.sharedPublicsCount);
796 (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
797 (bfd_byte *) thdr.sharedDebugRecordOffset);
799 (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
800 (bfd_byte *) thdr.sharedDebugRecordCount);
802 (bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
803 (bfd_byte *) thdr.sharedInitializationOffset);
805 (bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
806 (bfd_byte *) thdr.SharedExitProcedureOffset);
808 (bfd_vma) nlm_extended_header (abfd)->productID,
809 (bfd_byte *) thdr.productID);
811 (bfd_vma) nlm_extended_header (abfd)->reserved0,
812 (bfd_byte *) thdr.reserved0);
814 (bfd_vma) nlm_extended_header (abfd)->reserved1,
815 (bfd_byte *) thdr.reserved1);
817 (bfd_vma) nlm_extended_header (abfd)->reserved2,
818 (bfd_byte *) thdr.reserved2);
820 (bfd_vma) nlm_extended_header (abfd)->reserved3,
821 (bfd_byte *) thdr.reserved3);
823 (bfd_vma) nlm_extended_header (abfd)->reserved4,
824 (bfd_byte *) thdr.reserved4);
826 (bfd_vma) nlm_extended_header (abfd)->reserved5,
827 (bfd_byte *) thdr.reserved5);
828 if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
833 /* Write out the copyright header if there is one. */
834 if (find_nonzero ((PTR) nlm_copyright_header (abfd),
835 sizeof (Nlm_Internal_Copyright_Header)))
837 Nlm_External_Copyright_Header thdr;
839 memcpy (thdr.stamp, "CoPyRiGhT=", 10);
840 if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
841 != sizeof (thdr.stamp))
843 thdr.copyrightMessageLength[0] =
844 nlm_copyright_header (abfd)->copyrightMessageLength;
845 if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
847 /* The copyright message is a variable length string. */
848 if (bfd_write ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
849 nlm_copyright_header (abfd)->copyrightMessageLength + 1,
851 nlm_copyright_header (abfd)->copyrightMessageLength + 1)
855 /* Write out the custom header if there is one. */
856 if (find_nonzero ((PTR) nlm_custom_header (abfd),
857 sizeof (Nlm_Internal_Custom_Header)))
859 Nlm_External_Custom_Header thdr;
861 bfd_size_type hdrLength;
863 ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
864 sizeof (nlm_custom_header (abfd)->dataStamp));
865 memcpy (thdr.stamp, "CuStHeAd", 8);
866 hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
867 + nlm_custom_header (abfd)->hdrLength);
868 put_word (abfd, hdrLength, thdr.length);
869 put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataOffset,
871 put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataLength,
875 BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
876 if (bfd_write ((PTR) &thdr, 1,
877 sizeof (thdr) - sizeof (thdr.dataStamp), abfd)
878 != sizeof (thdr) - sizeof (thdr.dataStamp))
883 memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
884 sizeof (thdr.dataStamp));
885 if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
887 if (bfd_write (nlm_custom_header (abfd)->hdr, 1,
888 nlm_custom_header (abfd)->hdrLength, abfd)
889 != nlm_custom_header (abfd)->hdrLength)
894 /* Write out the Cygnus debugging header if there is one. */
895 if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
896 sizeof (Nlm_Internal_Cygnus_Ext_Header)))
898 Nlm_External_Custom_Header thdr;
900 memcpy (thdr.stamp, "CuStHeAd", 8);
901 put_word (abfd, (bfd_vma) 2 * NLM_TARGET_LONG_SIZE + 8,
902 (bfd_byte *) thdr.length);
903 put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->offset,
904 (bfd_byte *) thdr.dataOffset);
905 put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
906 (bfd_byte *) thdr.dataLength);
907 memcpy (thdr.dataStamp, "CyGnUsEx", 8);
908 if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
915 /* We read the NLM's public symbols and use it to generate a bfd symbol
916 table (hey, it's better than nothing) on a one-for-one basis. Thus
917 use the number of public symbols as the number of bfd symbols we will
918 have once we actually get around to reading them in.
920 Return the number of bytes required to hold the symtab vector, based on
921 the count plus 1, since we will NULL terminate the vector allocated based
925 nlm_get_symtab_upper_bound (abfd)
928 Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
930 long symtab_size = 0;
932 i_fxdhdrp = nlm_fixed_header (abfd);
933 symcount = (i_fxdhdrp->numberOfPublics
934 + i_fxdhdrp->numberOfDebugRecords
935 + i_fxdhdrp->numberOfExternalReferences);
936 symtab_size = (symcount + 1) * (sizeof (asymbol));
937 return (symtab_size);
940 /* Note that bfd_get_symcount is guaranteed to be zero if slurping the
941 symbol table fails. */
944 nlm_get_symtab (abfd, alocation)
948 nlm_symbol_type *symbase;
949 bfd_size_type counter = 0;
951 if (nlm_slurp_symbol_table (abfd) == false)
953 symbase = nlm_get_symbols (abfd);
954 while (counter < bfd_get_symcount (abfd))
956 *alocation++ = &symbase->symbol;
960 *alocation = (asymbol *) NULL;
961 return bfd_get_symcount (abfd);
964 /* Make an NLM symbol. There is nothing special to do here. */
967 nlm_make_empty_symbol (abfd)
970 nlm_symbol_type *new;
972 new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
974 new->symbol.the_bfd = abfd;
978 /* Get symbol information. */
981 nlm_get_symbol_info (ignore_abfd, symbol, ret)
986 bfd_symbol_info (symbol, ret);
989 /* Print symbol information. */
992 nlm_print_symbol (abfd, afile, symbol, how)
996 bfd_print_symbol_type how;
998 FILE *file = (FILE *) afile;
1002 case bfd_print_symbol_name:
1003 case bfd_print_symbol_more:
1005 fprintf (file, "%s", symbol->name);
1007 case bfd_print_symbol_all:
1008 bfd_print_symbol_vandf ((PTR) file, symbol);
1009 fprintf (file, " %-5s", symbol->section->name);
1011 fprintf (file, " %s", symbol->name);
1016 /* Slurp in nlm symbol table.
1018 In the external (in-file) form, NLM export records are variable length,
1019 with the following form:
1021 1 byte length of the symbol name (N)
1022 N bytes the symbol name
1023 4 bytes the symbol offset from start of it's section
1025 We also read in the debugging symbols and import records. Import
1026 records are treated as undefined symbols. As we read the import
1027 records we also read in the associated reloc information, which is
1028 attached to the symbol.
1030 The bfd symbols are copied to SYMPTRS.
1032 When we return, the bfd symcount is either zero or contains the correct
1037 nlm_slurp_symbol_table (abfd)
1040 Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
1041 bfd_size_type totsymcount; /* Number of NLM symbols */
1042 bfd_size_type symcount; /* Counter of NLM symbols */
1043 nlm_symbol_type *sym; /* Pointer to current bfd symbol */
1044 unsigned char symlength; /* Symbol length read into here */
1045 unsigned char symtype; /* Type of debugging symbol */
1046 bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here */
1047 boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
1048 boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
1050 if (nlm_get_symbols (abfd) != NULL)
1053 /* Read each raw NLM symbol, using the information to create a canonical bfd
1056 Note that we allocate the initial bfd canonical symbol buffer based on a
1057 one-to-one mapping of the NLM symbols to canonical symbols. We actually
1058 use all the NLM symbols, so there will be no space left over at the end.
1059 When we have all the symbols, we build the caller's pointer vector. */
1062 i_fxdhdrp = nlm_fixed_header (abfd);
1063 totsymcount = (i_fxdhdrp->numberOfPublics
1064 + i_fxdhdrp->numberOfDebugRecords
1065 + i_fxdhdrp->numberOfExternalReferences);
1066 if (totsymcount == 0)
1071 if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) == -1)
1074 sym = ((nlm_symbol_type *)
1075 bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
1078 bfd_set_error (bfd_error_no_memory);
1081 nlm_set_symbols (abfd, sym);
1083 /* We use the bfd's symcount directly as the control count, so that early
1084 termination of the loop leaves the symcount correct for the symbols that
1087 set_public_section_func = nlm_set_public_section_func (abfd);
1088 symcount = i_fxdhdrp->numberOfPublics;
1089 while (abfd->symcount < symcount)
1091 if (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
1092 != sizeof (symlength))
1094 sym->symbol.the_bfd = abfd;
1095 sym->symbol.name = bfd_alloc (abfd, symlength + 1);
1096 if (!sym->symbol.name)
1098 bfd_set_error (bfd_error_no_memory);
1101 if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
1104 /* Cast away const. */
1105 ((char *) (sym->symbol.name))[symlength] = '\0';
1106 if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
1108 sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
1109 sym->symbol.value = get_word (abfd, temp);
1110 if (set_public_section_func)
1112 /* Most backends can use the code below, but unfortunately
1113 some use a different scheme. */
1114 if ((*set_public_section_func) (abfd, sym) == false)
1119 if (sym->symbol.value & NLM_HIBIT)
1121 sym->symbol.value &= ~NLM_HIBIT;
1122 sym->symbol.flags |= BSF_FUNCTION;
1123 sym->symbol.section =
1124 bfd_get_section_by_name (abfd, NLM_CODE_NAME);
1128 sym->symbol.section =
1129 bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
1137 /* Read the debugging records. */
1139 if (i_fxdhdrp->numberOfDebugRecords > 0)
1141 if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1)
1144 symcount += i_fxdhdrp->numberOfDebugRecords;
1145 while (abfd->symcount < symcount)
1147 if ((bfd_read ((PTR) & symtype, sizeof (symtype), 1, abfd)
1148 != sizeof (symtype))
1149 || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
1150 || (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
1151 != sizeof (symlength)))
1153 sym->symbol.the_bfd = abfd;
1154 sym->symbol.name = bfd_alloc (abfd, symlength + 1);
1155 if (!sym->symbol.name)
1157 bfd_set_error (bfd_error_no_memory);
1160 if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
1163 /* Cast away const. */
1164 ((char *) (sym->symbol.name))[symlength] = '\0';
1165 sym->symbol.flags = BSF_LOCAL;
1166 sym->symbol.value = get_word (abfd, temp);
1169 sym->symbol.section =
1170 bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
1172 else if (symtype == 1)
1174 sym->symbol.flags |= BSF_FUNCTION;
1175 sym->symbol.section =
1176 bfd_get_section_by_name (abfd, NLM_CODE_NAME);
1180 sym->symbol.section = &bfd_abs_section;
1188 /* Read in the import records. We can only do this if we know how
1189 to read relocs for this target. */
1191 read_import_func = nlm_read_import_func (abfd);
1192 if (read_import_func != NULL)
1194 if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET)
1198 symcount += i_fxdhdrp->numberOfExternalReferences;
1199 while (abfd->symcount < symcount)
1201 if ((*read_import_func) (abfd, sym) == false)
1211 /* Get the relocs for an NLM file. There are two types of relocs.
1212 Imports are relocs against symbols defined in other NLM files. We
1213 treat these as relocs against global symbols. Relocation fixups
1214 are internal relocs.
1216 The actual format used to store the relocs is machine specific. */
1218 /* Read in the relocation fixup information. This is stored in
1219 nlm_relocation_fixups, an array of arelent structures, and
1220 nlm_relocation_fixup_secs, an array of section pointers. The
1221 section pointers are needed because the relocs are not sorted by
1225 nlm_slurp_reloc_fixups (abfd)
1228 boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
1230 bfd_size_type count;
1234 if (nlm_relocation_fixups (abfd) != NULL)
1236 read_func = nlm_read_reloc_func (abfd);
1237 if (read_func == NULL)
1240 if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
1244 count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1245 rels = (arelent *) bfd_alloc (abfd, count * sizeof (arelent));
1246 secs = (asection **) bfd_alloc (abfd, count * sizeof (asection *));
1247 if ((rels == NULL || secs == NULL) && count != 0)
1249 bfd_set_error (bfd_error_no_memory);
1252 nlm_relocation_fixups (abfd) = rels;
1253 nlm_relocation_fixup_secs (abfd) = secs;
1255 /* We have to read piece by piece, because we don't know how large
1256 the machine specific reloc information is. */
1257 while (count-- != 0)
1259 if ((*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels) == false)
1261 nlm_relocation_fixups (abfd) = NULL;
1262 nlm_relocation_fixup_secs (abfd) = NULL;
1272 /* Get the number of relocs. This really just returns an upper bound,
1273 since it does not attempt to distinguish them based on the section.
1274 That will be handled when they are actually read. */
1277 nlm_get_reloc_upper_bound (abfd, sec)
1281 nlm_symbol_type *syms;
1282 bfd_size_type count;
1285 /* If we don't know how to read relocs, just return 0. */
1286 if (nlm_read_reloc_func (abfd) == NULL)
1288 /* Make sure we have either the code or the data section. */
1289 if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
1292 syms = nlm_get_symbols (abfd);
1295 if (nlm_slurp_symbol_table (abfd) == false)
1297 syms = nlm_get_symbols (abfd);
1300 ret = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1302 count = bfd_get_symcount (abfd);
1303 while (count-- != 0)
1309 return (ret + 1) * sizeof (arelent *);
1312 /* Get the relocs themselves. */
1315 nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
1323 bfd_size_type count, i;
1326 /* Get the relocation fixups. */
1327 rels = nlm_relocation_fixups (abfd);
1330 if (nlm_slurp_reloc_fixups (abfd) == false)
1332 rels = nlm_relocation_fixups (abfd);
1334 secs = nlm_relocation_fixup_secs (abfd);
1337 count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1338 for (i = 0; i < count; i++, rels++, secs++)
1347 /* Get the import symbols. */
1348 count = bfd_get_symcount (abfd);
1349 for (i = 0; i < count; i++, symbols++)
1354 if (bfd_asymbol_flavour (sym) == bfd_target_nlm_flavour)
1356 nlm_symbol_type *nlm_sym;
1359 nlm_sym = (nlm_symbol_type *) sym;
1360 for (j = 0; j < nlm_sym->rcnt; j++)
1362 if (nlm_sym->relocs[j].section == sec)
1364 *relptr = &nlm_sym->relocs[j].reloc;
1365 (*relptr)->sym_ptr_ptr = symbols;
1378 /* Compute the section file positions for an NLM file. All variable
1379 length data in the file headers must be set before this function is
1380 called. If the variable length data is changed later, the
1381 resulting object file will be incorrect. Unfortunately, there is
1382 no way to check this.
1384 This routine also sets the Size and Offset fields in the fixed
1387 It also looks over the symbols and moves any common symbols into
1388 the .bss section; NLM has no way to represent a common symbol.
1389 This approach means that either the symbols must already have been
1390 set at this point, or there must be no common symbols. We need to
1391 move the symbols at this point so that mangle_relocs can see the
1395 nlm_compute_section_file_positions (abfd)
1400 bfd_vma text, data, bss;
1401 bfd_vma text_low, data_low;
1402 int text_align, data_align, other_align;
1403 file_ptr text_ptr, data_ptr, other_ptr;
1405 asymbol **sym_ptr_ptr;
1407 if (abfd->output_has_begun == true)
1410 /* Make sure we have a section to hold uninitialized data. */
1411 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
1412 if (bss_sec == NULL)
1414 if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
1415 (file_ptr) 0, (bfd_size_type) 0,
1418 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
1421 abfd->output_has_begun = true;
1423 /* The fixed header. */
1424 sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
1426 /* The variable header. */
1427 sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
1428 + nlm_variable_header (abfd)->descriptionLength + 1
1429 + NLM_TARGET_LONG_SIZE /* stackSize */
1430 + NLM_TARGET_LONG_SIZE /* reserved */
1431 + sizeof (nlm_variable_header (abfd)->oldThreadName)
1432 + sizeof (nlm_variable_header (abfd)->screenNameLength)
1433 + nlm_variable_header (abfd)->screenNameLength + 1
1434 + sizeof (nlm_variable_header (abfd)->threadNameLength)
1435 + nlm_variable_header (abfd)->threadNameLength + 1);
1437 /* The auxiliary headers. */
1438 if (find_nonzero ((PTR) nlm_version_header (abfd),
1439 sizeof (Nlm_Internal_Version_Header)))
1440 sofar += sizeof (Nlm_External_Version_Header);
1441 if (find_nonzero ((PTR) nlm_extended_header (abfd),
1442 sizeof (Nlm_Internal_Extended_Header)))
1443 sofar += sizeof (Nlm_External_Extended_Header);
1444 if (find_nonzero ((PTR) nlm_copyright_header (abfd),
1445 sizeof (Nlm_Internal_Copyright_Header)))
1446 sofar += (sizeof (Nlm_External_Copyright_Header)
1447 + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
1448 if (find_nonzero ((PTR) nlm_custom_header (abfd),
1449 sizeof (Nlm_Internal_Custom_Header)))
1450 sofar += (sizeof (Nlm_External_Custom_Header)
1451 + nlm_custom_header (abfd)->hdrLength);
1452 if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
1453 sizeof (Nlm_Internal_Cygnus_Ext_Header)))
1454 sofar += sizeof (Nlm_External_Custom_Header);
1456 /* Compute the section file positions in two passes. First get the
1457 sizes of the text and data sections, and then set the file
1458 positions. This code aligns the sections in the file using the
1459 same alignment restrictions that apply to the sections in memory;
1460 this may not be necessary. */
1462 text_low = (bfd_vma) - 1;
1465 data_low = (bfd_vma) - 1;
1469 for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
1473 sec->_raw_size = BFD_ALIGN (sec->_raw_size, 1 << sec->alignment_power);
1475 f = bfd_get_section_flags (abfd, sec);
1478 text += sec->_raw_size;
1479 if (bfd_get_section_vma (abfd, sec) < text_low)
1480 text_low = bfd_get_section_vma (abfd, sec);
1481 if (sec->alignment_power > text_align)
1482 text_align = sec->alignment_power;
1484 else if (f & SEC_DATA)
1486 data += sec->_raw_size;
1487 if (bfd_get_section_vma (abfd, sec) < data_low)
1488 data_low = bfd_get_section_vma (abfd, sec);
1489 if (sec->alignment_power > data_align)
1490 data_align = sec->alignment_power;
1492 else if (f & SEC_HAS_CONTENTS)
1494 if (sec->alignment_power > other_align)
1495 other_align = sec->alignment_power;
1497 else if (f & SEC_ALLOC)
1498 bss += sec->_raw_size;
1501 nlm_set_text_low (abfd, text_low);
1502 nlm_set_data_low (abfd, data_low);
1504 if (nlm_no_uninitialized_data (abfd))
1506 /* This NetWare format does not use uninitialized data. We must
1507 increase the size of the data section. We will never wind up
1508 writing those file locations, so they will remain zero. */
1513 text_ptr = BFD_ALIGN (sofar, 1 << text_align);
1514 data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
1515 other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
1517 /* Fill in some fields in the header for which we now have the
1519 nlm_fixed_header (abfd)->codeImageOffset = text_ptr;
1520 nlm_fixed_header (abfd)->codeImageSize = text;
1521 nlm_fixed_header (abfd)->dataImageOffset = data_ptr;
1522 nlm_fixed_header (abfd)->dataImageSize = data;
1523 nlm_fixed_header (abfd)->uninitializedDataSize = bss;
1525 for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
1529 f = bfd_get_section_flags (abfd, sec);
1533 sec->filepos = text_ptr;
1534 text_ptr += sec->_raw_size;
1536 else if (f & SEC_DATA)
1538 sec->filepos = data_ptr;
1539 data_ptr += sec->_raw_size;
1541 else if (f & SEC_HAS_CONTENTS)
1543 sec->filepos = other_ptr;
1544 other_ptr += sec->_raw_size;
1548 nlm_fixed_header (abfd)->relocationFixupOffset = other_ptr;
1550 /* Move all common symbols into the .bss section. */
1552 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1553 if (sym_ptr_ptr != NULL)
1558 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1560 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1567 if (!bfd_is_com_section (bfd_get_section (sym)))
1570 /* Put the common symbol in the .bss section, and increase
1571 the size of the .bss section by the size of the common
1572 symbol (which is the old value of the symbol). */
1573 sym->section = bss_sec;
1575 sym->value = bss_sec->_raw_size + add;
1577 add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
1581 if (nlm_no_uninitialized_data (abfd))
1583 /* We could handle this case, but so far it hasn't been
1587 nlm_fixed_header (abfd)->uninitializedDataSize += add;
1588 bss_sec->_raw_size += add;
1595 /* Set the contents of a section. To do this we need to know where
1596 the section is going to be located in the output file. That means
1597 that the sizes of all the sections must be set, and all the
1598 variable size header information must be known. */
1601 nlm_set_section_contents (abfd, section, location, offset, count)
1606 bfd_size_type count;
1608 if (abfd->output_has_begun == false
1609 && nlm_compute_section_file_positions (abfd) == false)
1615 /* i386 NetWare has a very restricted set of relocs. In order for
1616 objcopy to work, the NLM i386 backend needs a chance to rework
1617 the section contents so that its set of relocs will work. If all
1618 the relocs are already acceptable, this will not do anything. */
1619 if (section->reloc_count != 0)
1621 boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR,
1622 bfd_vma, bfd_size_type));
1624 mangle_relocs_func = nlm_mangle_relocs_func (abfd);
1625 if (mangle_relocs_func != NULL)
1627 if (!(*mangle_relocs_func) (abfd, section, location,
1628 (bfd_vma) offset, count))
1633 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
1634 || bfd_write (location, 1, count, abfd) != count)
1640 /* We need to sort a list of relocs associated with sections when we
1641 write out the external relocs. */
1644 nlm_external_reloc_compare (p1, p2)
1648 const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
1649 const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
1652 cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
1653 (*r2->rel->sym_ptr_ptr)->name);
1657 /* We sort by address within symbol to make the sort more stable and
1658 increase the chances that different hosts will generate bit for
1659 bit equivalent results. */
1660 return (int) (r1->rel->address - r2->rel->address);
1663 /* Write out an NLM file. We write out the information in this order:
1669 other sections (custom data, messages, help, shared NLM, RPC,
1670 module dependencies)
1672 external references (imports)
1673 public symbols (exports)
1675 This is similar to the order used by the NetWare tools; the
1676 difference is that NetWare puts the sections other than code, data
1677 and custom data at the end of the NLM. It is convenient for us to
1678 know where the sections are going to be before worrying about the
1679 size of the other information.
1681 By the time this function is called, all the section data should
1682 have been output using set_section_contents. Note that custom
1683 data, the message file, the help file, the shared NLM file, the RPC
1684 data, and the module dependencies are all considered to be
1685 sections; the caller is responsible for filling in the offset and
1686 length fields in the NLM headers. The relocation fixups and
1687 imports are both obtained from the list of relocs attached to each
1688 section. The exports and debugging records are obtained from the
1689 list of outsymbols. */
1692 nlm_write_object_contents (abfd)
1696 boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
1697 bfd_size_type external_reloc_count, internal_reloc_count, i, c;
1698 struct reloc_and_sec *external_relocs;
1699 asymbol **sym_ptr_ptr;
1701 boolean (*write_prefix_func) PARAMS ((bfd *));
1702 unsigned char *fixed_header = NULL;
1704 fixed_header = (unsigned char *) malloc (nlm_fixed_header_size (abfd));
1705 if (fixed_header == NULL)
1707 bfd_set_error (bfd_error_no_memory);
1711 if (abfd->output_has_begun == false
1712 && nlm_compute_section_file_positions (abfd) == false)
1715 /* Write out the variable length headers. */
1717 nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
1720 if (nlm_swap_variable_header_out (abfd) == false
1721 || nlm_swap_auxiliary_headers_out (abfd) == false)
1723 bfd_set_error (bfd_error_system_call);
1727 /* A weak check on whether the section file positions were
1729 if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
1731 bfd_set_error (bfd_error_invalid_operation);
1735 /* Advance to the relocs. */
1736 if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
1740 /* The format of the relocation entries is dependent upon the
1741 particular target. We use an external routine to write the reloc
1743 write_import_func = nlm_write_import_func (abfd);
1745 /* Write out the internal relocation fixups. While we're looping
1746 over the relocs, we also count the external relocs, which is
1747 needed when they are written out below. */
1748 internal_reloc_count = 0;
1749 external_reloc_count = 0;
1750 for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
1752 arelent **rel_ptr_ptr, **rel_end;
1754 if (sec->reloc_count == 0)
1757 /* We can only represent relocs within a code or data
1758 section. We ignore them for a debugging section. */
1759 if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
1762 /* We need to know how to write out imports */
1763 if (write_import_func == NULL)
1765 bfd_set_error (bfd_error_invalid_operation);
1769 rel_ptr_ptr = sec->orelocation;
1770 rel_end = rel_ptr_ptr + sec->reloc_count;
1771 for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
1777 sym = *rel->sym_ptr_ptr;
1779 if (bfd_get_section (sym) != &bfd_und_section)
1781 ++internal_reloc_count;
1782 if ((*write_import_func) (abfd, sec, rel) == false)
1786 ++external_reloc_count;
1789 nlm_fixed_header (abfd)->numberOfRelocationFixups = internal_reloc_count;
1791 /* Write out the imports (relocs against external symbols). These
1792 are output as a symbol name followed by all the relocs for that
1793 symbol, so we must first gather together all the relocs against
1794 external symbols and sort them. */
1796 (struct reloc_and_sec *) bfd_alloc (abfd,
1797 (external_reloc_count
1798 * sizeof (struct reloc_and_sec)));
1799 if (external_relocs == (struct reloc_and_sec *) NULL)
1801 bfd_set_error (bfd_error_no_memory);
1805 for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
1807 arelent **rel_ptr_ptr, **rel_end;
1809 if (sec->reloc_count == 0)
1812 rel_ptr_ptr = sec->orelocation;
1813 rel_end = rel_ptr_ptr + sec->reloc_count;
1814 for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
1820 sym = *rel->sym_ptr_ptr;
1822 if (bfd_get_section (sym) != &bfd_und_section)
1825 external_relocs[i].rel = rel;
1826 external_relocs[i].sec = sec;
1831 BFD_ASSERT (i == external_reloc_count);
1833 /* Sort the external relocs by name. */
1834 qsort ((PTR) external_relocs, (size_t) external_reloc_count,
1835 sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
1837 /* Write out the external relocs. */
1838 nlm_fixed_header (abfd)->externalReferencesOffset = bfd_tell (abfd);
1841 while (i < external_reloc_count)
1845 bfd_size_type j, cnt;
1849 rel = external_relocs[i].rel;
1850 sym = *rel->sym_ptr_ptr;
1854 (j < external_reloc_count
1855 && *external_relocs[j].rel->sym_ptr_ptr == sym);
1859 if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym,
1860 &external_relocs[i])
1867 nlm_fixed_header (abfd)->numberOfExternalReferences = c;
1869 /* Write out the public symbols (exports). */
1870 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1871 if (sym_ptr_ptr != (asymbol **) NULL)
1873 bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
1874 boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
1878 nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
1879 get_public_offset_func = nlm_get_public_offset_func (abfd);
1880 write_export_func = nlm_write_export_func (abfd);
1882 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1883 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1888 bfd_byte temp[NLM_TARGET_LONG_SIZE];
1892 if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
1893 || bfd_get_section (sym) == &bfd_und_section)
1898 if (get_public_offset_func)
1900 /* Most backends can use the code below, but
1901 unfortunately some use a different scheme. */
1902 offset = (*get_public_offset_func) (abfd, sym);
1906 offset = bfd_asymbol_value (sym);
1908 if (sec->flags & SEC_CODE)
1910 offset -= nlm_get_text_low (abfd);
1911 offset |= NLM_HIBIT;
1913 else if (sec->flags & (SEC_DATA | SEC_ALLOC))
1915 /* SEC_ALLOC is for the .bss section. */
1916 offset -= nlm_get_data_low (abfd);
1920 /* We can't handle an exported symbol that is not in
1921 the code or data segment. */
1922 bfd_set_error (bfd_error_invalid_operation);
1927 if (write_export_func)
1929 if ((*write_export_func) (abfd, sym, offset) == false)
1934 len = strlen (sym->name);
1935 if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
1936 != sizeof (bfd_byte))
1937 || bfd_write (sym->name, len, 1, abfd) != len)
1940 put_word (abfd, offset, temp);
1941 if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
1945 nlm_fixed_header (abfd)->numberOfPublics = c;
1947 /* Write out the debugging records. The NLM conversion program
1948 wants to be able to inhibit this, so as a special hack if
1949 debugInfoOffset is set to -1 we don't write any debugging
1950 information. This can not be handled by fiddling with the
1951 symbol table, because exported symbols appear in both the
1952 exported symbol list and the debugging information. */
1953 if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) - 1)
1955 nlm_fixed_header (abfd)->debugInfoOffset = 0;
1956 nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
1960 nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
1962 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1963 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1964 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1969 bfd_byte temp[NLM_TARGET_LONG_SIZE];
1973 /* The NLM notion of a debugging symbol is actually what
1974 BFD calls a local or global symbol. What BFD calls a
1975 debugging symbol NLM does not understand at all. */
1976 if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
1977 || (sym->flags & BSF_DEBUGGING) != 0
1978 || bfd_get_section (sym) == &bfd_und_section)
1983 offset = bfd_asymbol_value (sym);
1985 if (sec->flags & SEC_CODE)
1987 offset -= nlm_get_text_low (abfd);
1990 else if (sec->flags & (SEC_DATA | SEC_ALLOC))
1992 /* SEC_ALLOC is for the .bss section. */
1993 offset -= nlm_get_data_low (abfd);
1999 /* The type is 0 for data, 1 for code, 2 for absolute. */
2000 if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
2001 != sizeof (bfd_byte))
2004 put_word (abfd, offset, temp);
2005 if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
2008 len = strlen (sym->name);
2009 if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
2010 != sizeof (bfd_byte))
2011 || bfd_write (sym->name, len, 1, abfd) != len)
2014 nlm_fixed_header (abfd)->numberOfDebugRecords = c;
2018 /* NLMLINK fills in offset values even if there is no data, so we do
2020 last = bfd_tell (abfd);
2021 if (nlm_fixed_header (abfd)->codeImageOffset == 0)
2022 nlm_fixed_header (abfd)->codeImageOffset = last;
2023 if (nlm_fixed_header (abfd)->dataImageOffset == 0)
2024 nlm_fixed_header (abfd)->dataImageOffset = last;
2025 if (nlm_fixed_header (abfd)->customDataOffset == 0)
2026 nlm_fixed_header (abfd)->customDataOffset = last;
2027 if (nlm_fixed_header (abfd)->moduleDependencyOffset == 0)
2028 nlm_fixed_header (abfd)->moduleDependencyOffset = last;
2029 if (nlm_fixed_header (abfd)->relocationFixupOffset == 0)
2030 nlm_fixed_header (abfd)->relocationFixupOffset = last;
2031 if (nlm_fixed_header (abfd)->externalReferencesOffset == 0)
2032 nlm_fixed_header (abfd)->externalReferencesOffset = last;
2033 if (nlm_fixed_header (abfd)->publicsOffset == 0)
2034 nlm_fixed_header (abfd)->publicsOffset = last;
2035 if (nlm_fixed_header (abfd)->debugInfoOffset == 0)
2036 nlm_fixed_header (abfd)->debugInfoOffset = last;
2038 /* At this point everything has been written out except the fixed
2040 memcpy (nlm_fixed_header (abfd)->signature, nlm_signature (abfd),
2041 NLM_SIGNATURE_SIZE);
2042 nlm_fixed_header (abfd)->version = NLM_HEADER_VERSION;
2043 nlm_fixed_header (abfd)->codeStartOffset =
2044 (bfd_get_start_address (abfd)
2045 - nlm_get_text_low (abfd));
2047 /* We have no convenient way for the caller to pass in the exit
2048 procedure or the check unload procedure, so the caller must set
2049 the values in the header to the values of the symbols. */
2050 nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
2051 if (nlm_fixed_header (abfd)->checkUnloadProcedureOffset != 0)
2052 nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
2053 nlm_get_text_low (abfd);
2055 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
2058 write_prefix_func = nlm_write_prefix_func (abfd);
2059 if (write_prefix_func)
2061 if ((*write_prefix_func) (abfd) == false)
2065 BFD_ASSERT (bfd_tell (abfd) == nlm_optional_prefix_size (abfd));
2067 nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
2068 if (bfd_write (fixed_header, nlm_fixed_header_size (abfd), 1, abfd)
2069 != nlm_fixed_header_size (abfd))
2072 if (fixed_header != NULL)
2073 free (fixed_header);
2077 if (fixed_header != NULL)
2078 free (fixed_header);