bfd/
[binutils.git] / bfd / nlmcode.h
blob507d5d64476ff94c5facff07fd0be665c6fdcb1e
1 /* NLM (NetWare Loadable Module) executable support for BFD.
2 Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006 Free Software Foundation, Inc.
5 Written by Fred Fish @ Cygnus Support, using ELF support as the
6 template.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "libbfd.h"
27 #include "libnlm.h"
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_canonicalize_symtab nlmNAME (canonicalize_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 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
61 can be handled by explicitly specifying 32 bits or "the long type". */
62 #if ARCH_SIZE == 64
63 #define put_word H_PUT_64
64 #define get_word H_GET_64
65 #endif
66 #if ARCH_SIZE == 32
67 #define put_word H_PUT_32
68 #define get_word H_GET_32
69 #endif
71 /* Read and swap in the variable length header. All the fields must
72 exist in the NLM, and must exist in the order they are read here. */
74 static bfd_boolean
75 nlm_swap_variable_header_in (bfd *abfd)
77 unsigned char temp[NLM_TARGET_LONG_SIZE];
78 bfd_size_type amt;
80 /* Read the description length and text members. */
81 amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
82 if (bfd_bread ((void *) &nlm_variable_header (abfd)->descriptionLength,
83 amt, abfd) != amt)
84 return FALSE;
85 amt = nlm_variable_header (abfd)->descriptionLength + 1;
86 if (bfd_bread ((void *) nlm_variable_header (abfd)->descriptionText,
87 amt, abfd) != amt)
88 return FALSE;
90 /* Read and convert the stackSize field. */
91 amt = sizeof (temp);
92 if (bfd_bread ((void *) temp, amt, abfd) != amt)
93 return FALSE;
94 nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
96 /* Read and convert the reserved field. */
97 amt = sizeof (temp);
98 if (bfd_bread ((void *) temp, amt, abfd) != amt)
99 return FALSE;
100 nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
102 /* Read the oldThreadName field. This field is a fixed length string. */
103 amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
104 if (bfd_bread ((void *) nlm_variable_header (abfd)->oldThreadName,
105 amt, abfd) != amt)
106 return FALSE;
108 /* Read the screen name length and text members. */
109 amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
110 if (bfd_bread ((void *) & nlm_variable_header (abfd)->screenNameLength,
111 amt, abfd) != amt)
112 return FALSE;
113 amt = nlm_variable_header (abfd)->screenNameLength + 1;
114 if (bfd_bread ((void *) nlm_variable_header (abfd)->screenName,
115 amt, abfd) != amt)
116 return FALSE;
118 /* Read the thread name length and text members. */
119 amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
120 if (bfd_bread ((void *) & nlm_variable_header (abfd)->threadNameLength,
121 amt, abfd) != amt)
122 return FALSE;
123 amt = nlm_variable_header (abfd)->threadNameLength + 1;
124 if (bfd_bread ((void *) nlm_variable_header (abfd)->threadName,
125 amt, abfd) != amt)
126 return FALSE;
127 return TRUE;
130 /* Add a section to the bfd. */
132 static bfd_boolean
133 add_bfd_section (bfd *abfd,
134 char *name,
135 file_ptr offset,
136 bfd_size_type size,
137 flagword flags)
139 asection *newsect;
141 newsect = bfd_make_section_with_flags (abfd, name, flags);
142 if (newsect == NULL)
143 return FALSE;
145 newsect->vma = 0; /* NLM's are relocatable. */
146 newsect->size = size;
147 newsect->filepos = offset;
148 newsect->alignment_power = bfd_log2 ((bfd_vma) 0); /* FIXME */
150 return TRUE;
153 /* Read and swap in the contents of all the auxiliary headers. Because of
154 the braindead design, we have to do strcmps on strings of indeterminate
155 length to figure out what each auxiliary header is. Even worse, we have
156 no way of knowing how many auxiliary headers there are or where the end
157 of the auxiliary headers are, except by finding something that doesn't
158 look like a known auxiliary header. This means that the first new type
159 of auxiliary header added will break all existing tools that don't
160 recognize it. */
162 static bfd_boolean
163 nlm_swap_auxiliary_headers_in (bfd *abfd)
165 char tempstr[16];
166 file_ptr position;
167 bfd_size_type amt;
169 for (;;)
171 position = bfd_tell (abfd);
172 amt = sizeof (tempstr);
173 if (bfd_bread ((void *) tempstr, amt, abfd) != amt)
174 return FALSE;
175 if (bfd_seek (abfd, position, SEEK_SET) != 0)
176 return FALSE;
177 if (CONST_STRNEQ (tempstr, "VeRsIoN#"))
179 Nlm_External_Version_Header thdr;
181 amt = sizeof (thdr);
182 if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
183 return FALSE;
184 memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
185 sizeof (thdr.stamp));
186 nlm_version_header (abfd)->majorVersion =
187 get_word (abfd, (bfd_byte *) thdr.majorVersion);
188 nlm_version_header (abfd)->minorVersion =
189 get_word (abfd, (bfd_byte *) thdr.minorVersion);
190 nlm_version_header (abfd)->revision =
191 get_word (abfd, (bfd_byte *) thdr.revision);
192 nlm_version_header (abfd)->year =
193 get_word (abfd, (bfd_byte *) thdr.year);
194 nlm_version_header (abfd)->month =
195 get_word (abfd, (bfd_byte *) thdr.month);
196 nlm_version_header (abfd)->day =
197 get_word (abfd, (bfd_byte *) thdr.day);
199 else if (CONST_STRNEQ (tempstr, "MeSsAgEs"))
201 Nlm_External_Extended_Header thdr;
203 amt = sizeof (thdr);
204 if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
205 return FALSE;
206 memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
207 sizeof (thdr.stamp));
208 nlm_extended_header (abfd)->languageID =
209 get_word (abfd, (bfd_byte *) thdr.languageID);
210 nlm_extended_header (abfd)->messageFileOffset =
211 get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
212 nlm_extended_header (abfd)->messageFileLength =
213 get_word (abfd, (bfd_byte *) thdr.messageFileLength);
214 nlm_extended_header (abfd)->messageCount =
215 get_word (abfd, (bfd_byte *) thdr.messageCount);
216 nlm_extended_header (abfd)->helpFileOffset =
217 get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
218 nlm_extended_header (abfd)->helpFileLength =
219 get_word (abfd, (bfd_byte *) thdr.helpFileLength);
220 nlm_extended_header (abfd)->RPCDataOffset =
221 get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
222 nlm_extended_header (abfd)->RPCDataLength =
223 get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
224 nlm_extended_header (abfd)->sharedCodeOffset =
225 get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
226 nlm_extended_header (abfd)->sharedCodeLength =
227 get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
228 nlm_extended_header (abfd)->sharedDataOffset =
229 get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
230 nlm_extended_header (abfd)->sharedDataLength =
231 get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
232 nlm_extended_header (abfd)->sharedRelocationFixupOffset =
233 get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
234 nlm_extended_header (abfd)->sharedRelocationFixupCount =
235 get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
236 nlm_extended_header (abfd)->sharedExternalReferenceOffset =
237 get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
238 nlm_extended_header (abfd)->sharedExternalReferenceCount =
239 get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
240 nlm_extended_header (abfd)->sharedPublicsOffset =
241 get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
242 nlm_extended_header (abfd)->sharedPublicsCount =
243 get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
244 nlm_extended_header (abfd)->sharedDebugRecordOffset =
245 get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
246 nlm_extended_header (abfd)->sharedDebugRecordCount =
247 get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
248 nlm_extended_header (abfd)->SharedInitializationOffset =
249 get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
250 nlm_extended_header (abfd)->SharedExitProcedureOffset =
251 get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
252 nlm_extended_header (abfd)->productID =
253 get_word (abfd, (bfd_byte *) thdr.productID);
254 nlm_extended_header (abfd)->reserved0 =
255 get_word (abfd, (bfd_byte *) thdr.reserved0);
256 nlm_extended_header (abfd)->reserved1 =
257 get_word (abfd, (bfd_byte *) thdr.reserved1);
258 nlm_extended_header (abfd)->reserved2 =
259 get_word (abfd, (bfd_byte *) thdr.reserved2);
260 nlm_extended_header (abfd)->reserved3 =
261 get_word (abfd, (bfd_byte *) thdr.reserved3);
262 nlm_extended_header (abfd)->reserved4 =
263 get_word (abfd, (bfd_byte *) thdr.reserved4);
264 nlm_extended_header (abfd)->reserved5 =
265 get_word (abfd, (bfd_byte *) thdr.reserved5);
267 else if (CONST_STRNEQ (tempstr, "CoPyRiGhT="))
269 amt = sizeof (nlm_copyright_header (abfd)->stamp);
270 if (bfd_bread ((void *) nlm_copyright_header (abfd)->stamp,
271 amt, abfd) != amt)
272 return FALSE;
273 if (bfd_bread ((void *) &(nlm_copyright_header (abfd)
274 ->copyrightMessageLength),
275 (bfd_size_type) 1, abfd) != 1)
276 return FALSE;
277 /* The copyright message is a variable length string. */
278 amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
279 if (bfd_bread ((void *) nlm_copyright_header (abfd)->copyrightMessage,
280 amt, abfd) != amt)
281 return FALSE;
283 else if (CONST_STRNEQ (tempstr, "CuStHeAd"))
285 Nlm_External_Custom_Header thdr;
286 bfd_size_type hdrLength;
287 file_ptr dataOffset;
288 bfd_size_type dataLength;
289 char dataStamp[8];
290 void * hdr;
292 /* Read the stamp ("CuStHeAd"). */
293 amt = sizeof (thdr.stamp);
294 if (bfd_bread ((void *) thdr.stamp, amt, abfd) != amt)
295 return FALSE;
296 /* Read the length of this custom header. */
297 amt = sizeof (thdr.length);
298 if (bfd_bread ((void *) thdr.length, amt, abfd) != amt)
299 return FALSE;
300 hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
301 /* Read further fields if we have them. */
302 if (hdrLength < NLM_TARGET_LONG_SIZE)
303 dataOffset = 0;
304 else
306 amt = sizeof (thdr.dataOffset);
307 if (bfd_bread ((void *) thdr.dataOffset, amt, abfd) != amt)
308 return FALSE;
309 dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
311 if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
312 dataLength = 0;
313 else
315 amt = sizeof (thdr.dataLength);
316 if (bfd_bread ((void *) thdr.dataLength, amt, abfd) != amt)
317 return FALSE;
318 dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
320 if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
321 memset (dataStamp, 0, sizeof (dataStamp));
322 else
324 amt = sizeof (dataStamp);
325 if (bfd_bread ((void *) dataStamp, amt, abfd) != amt)
326 return FALSE;
329 /* Read the rest of the header, if any. */
330 if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
332 hdr = NULL;
333 hdrLength = 0;
335 else
337 hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
338 hdr = bfd_alloc (abfd, hdrLength);
339 if (hdr == NULL)
340 return FALSE;
341 if (bfd_bread (hdr, hdrLength, abfd) != hdrLength)
342 return FALSE;
345 /* If we have found a Cygnus header, process it. Otherwise,
346 just save the associated data without trying to interpret
347 it. */
348 if (CONST_STRNEQ (dataStamp, "CyGnUsEx"))
350 file_ptr pos;
351 bfd_byte *contents;
352 bfd_byte *p, *pend;
354 BFD_ASSERT (hdrLength == 0 && hdr == NULL);
356 pos = bfd_tell (abfd);
357 if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
358 return FALSE;
359 contents = bfd_alloc (abfd, dataLength);
360 if (contents == NULL)
361 return FALSE;
362 if (bfd_bread (contents, dataLength, abfd) != dataLength)
363 return FALSE;
364 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
365 return FALSE;
367 LITMEMCPY (nlm_cygnus_ext_header (abfd), "CyGnUsEx");
368 nlm_cygnus_ext_header (abfd)->offset = dataOffset;
369 nlm_cygnus_ext_header (abfd)->length = dataLength;
371 /* This data this header points to provides a list of
372 the sections which were in the original object file
373 which was converted to become an NLM. We locate
374 those sections and add them to the BFD. Note that
375 this is likely to create a second .text, .data and
376 .bss section; retrieving the sections by name will
377 get the actual NLM sections, which is what we want to
378 happen. The sections from the original file, which
379 may be subsets of the NLM section, can only be found
380 using bfd_map_over_sections. */
381 p = contents;
382 pend = p + dataLength;
383 while (p < pend)
385 char *name;
386 size_t l;
387 file_ptr filepos;
388 bfd_size_type size;
389 asection *newsec;
391 /* The format of this information is
392 null terminated section name
393 zeroes to adjust to 4 byte boundary
394 4 byte section data file pointer
395 4 byte section size. */
397 name = (char *) p;
398 l = strlen (name) + 1;
399 l = (l + 3) &~ (size_t) 3;
400 p += l;
401 filepos = H_GET_32 (abfd, p);
402 p += 4;
403 size = H_GET_32 (abfd, p);
404 p += 4;
406 newsec = bfd_make_section_anyway (abfd, name);
407 if (newsec == NULL)
408 return FALSE;
409 newsec->size = size;
410 if (filepos != 0)
412 newsec->filepos = filepos;
413 newsec->flags |= SEC_HAS_CONTENTS;
417 else
419 memcpy (nlm_custom_header (abfd)->stamp, thdr.stamp,
420 sizeof (thdr.stamp));
421 nlm_custom_header (abfd)->hdrLength = hdrLength;
422 nlm_custom_header (abfd)->dataOffset = dataOffset;
423 nlm_custom_header (abfd)->dataLength = dataLength;
424 memcpy (nlm_custom_header (abfd)->dataStamp, dataStamp,
425 sizeof (dataStamp));
426 nlm_custom_header (abfd)->hdr = hdr;
429 else
430 break;
432 return TRUE;
435 const bfd_target *
436 nlm_object_p (bfd *abfd)
438 struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
439 bfd_boolean (*backend_object_p) (bfd *);
440 void * x_fxdhdr = NULL;
441 Nlm_Internal_Fixed_Header *i_fxdhdrp;
442 struct nlm_obj_tdata *new_tdata = NULL;
443 const char *signature;
444 enum bfd_architecture arch;
445 bfd_size_type amt;
447 /* Some NLM formats have a prefix before the standard NLM fixed
448 header. */
449 backend_object_p = nlm_backend_object_p_func (abfd);
450 if (backend_object_p)
452 if (!(*backend_object_p) (abfd))
453 goto got_wrong_format_error;
456 /* Read in the fixed length portion of the NLM header in external format. */
457 amt = nlm_fixed_header_size (abfd);
458 x_fxdhdr = bfd_malloc (amt);
459 if (x_fxdhdr == NULL)
460 goto got_no_match;
462 if (bfd_bread ((void *) x_fxdhdr, amt, abfd) != amt)
464 if (bfd_get_error () != bfd_error_system_call)
465 goto got_wrong_format_error;
466 else
467 goto got_no_match;
470 /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
471 the tdata pointer in the bfd. */
472 amt = sizeof (struct nlm_obj_tdata);
473 new_tdata = bfd_zalloc (abfd, amt);
474 if (new_tdata == NULL)
475 goto got_no_match;
477 nlm_tdata (abfd) = new_tdata;
479 i_fxdhdrp = nlm_fixed_header (abfd);
480 nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
481 free (x_fxdhdr);
482 x_fxdhdr = NULL;
484 /* Check to see if we have an NLM file for this backend by matching
485 the NLM signature. */
486 signature = nlm_signature (abfd);
487 if (signature != NULL
488 && *signature != '\0'
489 && strncmp ((char *) i_fxdhdrp->signature, signature,
490 NLM_SIGNATURE_SIZE) != 0)
491 goto got_wrong_format_error;
493 /* There's no supported way to discover the endianess of an NLM, so test for
494 a sane version number after doing byte swapping appropriate for this
495 XVEC. (Hack alert!) */
496 if (i_fxdhdrp->version > 0xFFFF)
497 goto got_wrong_format_error;
499 /* There's no supported way to check for 32 bit versus 64 bit addresses,
500 so ignore this distinction for now. (FIXME) */
501 /* Swap in the rest of the required header. */
502 if (!nlm_swap_variable_header_in (abfd))
504 if (bfd_get_error () != bfd_error_system_call)
505 goto got_wrong_format_error;
506 else
507 goto got_no_match;
510 /* Add the sections supplied by all NLM's, and then read in the
511 auxiliary headers. Reading the auxiliary headers may create
512 additional sections described in the cygnus_ext header.
513 From this point on we assume that we have an NLM, and do not
514 treat errors as indicating the wrong format. */
515 if (!add_bfd_section (abfd, NLM_CODE_NAME,
516 i_fxdhdrp->codeImageOffset,
517 i_fxdhdrp->codeImageSize,
518 (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
519 | SEC_RELOC))
520 || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
521 i_fxdhdrp->dataImageOffset,
522 i_fxdhdrp->dataImageSize,
523 (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
524 | SEC_RELOC))
525 || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
526 (file_ptr) 0,
527 i_fxdhdrp->uninitializedDataSize,
528 SEC_ALLOC))
529 goto got_no_match;
531 if (!nlm_swap_auxiliary_headers_in (abfd))
532 goto got_no_match;
534 if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
535 || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
536 abfd->flags |= HAS_RELOC;
537 if (nlm_fixed_header (abfd)->numberOfPublics != 0
538 || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
539 || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
540 abfd->flags |= HAS_SYMS;
542 arch = nlm_architecture (abfd);
543 if (arch != bfd_arch_unknown)
544 bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
546 abfd->flags |= EXEC_P;
547 bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
549 return abfd->xvec;
551 got_wrong_format_error:
552 bfd_set_error (bfd_error_wrong_format);
553 got_no_match:
554 nlm_tdata (abfd) = preserved_tdata;
555 if (new_tdata != NULL)
556 bfd_release (abfd, new_tdata);
557 if (x_fxdhdr != NULL)
558 free (x_fxdhdr);
560 return NULL;
563 /* Swap and write out the variable length header. All the fields must
564 exist in the NLM, and must exist in this order. */
566 static bfd_boolean
567 nlm_swap_variable_header_out (bfd *abfd)
569 bfd_byte temp[NLM_TARGET_LONG_SIZE];
570 bfd_size_type amt;
572 /* Write the description length and text members. */
573 amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
574 if (bfd_bwrite (& nlm_variable_header (abfd)->descriptionLength, amt,
575 abfd) != amt)
576 return FALSE;
577 amt = nlm_variable_header (abfd)->descriptionLength + 1;
578 if (bfd_bwrite ((void *) nlm_variable_header (abfd)->descriptionText, amt,
579 abfd) != amt)
580 return FALSE;
582 /* Convert and write the stackSize field. */
583 put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize, temp);
584 amt = sizeof (temp);
585 if (bfd_bwrite (temp, amt, abfd) != amt)
586 return FALSE;
588 /* Convert and write the reserved field. */
589 put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved, temp);
590 amt = sizeof (temp);
591 if (bfd_bwrite (temp, amt, abfd) != amt)
592 return FALSE;
594 /* Write the oldThreadName field. This field is a fixed length string. */
595 amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
596 if (bfd_bwrite (nlm_variable_header (abfd)->oldThreadName, amt,
597 abfd) != amt)
598 return FALSE;
600 /* Write the screen name length and text members. */
601 amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
602 if (bfd_bwrite (& nlm_variable_header (abfd)->screenNameLength, amt,
603 abfd) != amt)
604 return FALSE;
605 amt = nlm_variable_header (abfd)->screenNameLength + 1;
606 if (bfd_bwrite (nlm_variable_header (abfd)->screenName, amt, abfd) != amt)
607 return FALSE;
609 /* Write the thread name length and text members. */
610 amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
611 if (bfd_bwrite (& nlm_variable_header (abfd)->threadNameLength, amt,
612 abfd) != amt)
613 return FALSE;
614 amt = nlm_variable_header (abfd)->threadNameLength + 1;
615 if (bfd_bwrite (nlm_variable_header (abfd)->threadName, amt, abfd) != amt)
616 return FALSE;
617 return TRUE;
620 /* Return whether there is a non-zero byte in a memory block. */
622 static bfd_boolean
623 find_nonzero (void * buf, size_t size)
625 char *p = (char *) buf;
627 while (size-- != 0)
628 if (*p++ != 0)
629 return TRUE;
630 return FALSE;
633 /* Swap out the contents of the auxiliary headers. We create those
634 auxiliary headers which have been set non-zero. We do not require
635 the caller to set up the stamp fields. */
637 static bfd_boolean
638 nlm_swap_auxiliary_headers_out (bfd *abfd)
640 bfd_size_type amt;
642 /* Write out the version header if there is one. */
643 if (find_nonzero (nlm_version_header (abfd),
644 sizeof (Nlm_Internal_Version_Header)))
646 Nlm_External_Version_Header thdr;
648 LITMEMCPY (thdr.stamp, "VeRsIoN#");
649 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion,
650 (bfd_byte *) thdr.majorVersion);
651 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion,
652 (bfd_byte *) thdr.minorVersion);
653 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision,
654 (bfd_byte *) thdr.revision);
655 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year,
656 (bfd_byte *) thdr.year);
657 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month,
658 (bfd_byte *) thdr.month);
659 put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
660 (bfd_byte *) thdr.day);
661 if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
662 != sizeof (thdr))
663 return FALSE;
666 /* Note - the CoPyRiGhT tag is emitted before the MeSsAgEs
667 tag in order to make the NW4.x and NW5.x loaders happy. */
669 /* Write out the copyright header if there is one. */
670 if (find_nonzero (nlm_copyright_header (abfd),
671 sizeof (Nlm_Internal_Copyright_Header)))
673 Nlm_External_Copyright_Header thdr;
675 LITMEMCPY (thdr.stamp, "CoPyRiGhT=");
676 amt = sizeof (thdr.stamp);
677 if (bfd_bwrite ((void *) thdr.stamp, amt, abfd) != amt)
678 return FALSE;
679 thdr.copyrightMessageLength[0] =
680 nlm_copyright_header (abfd)->copyrightMessageLength;
681 amt = 1;
682 if (bfd_bwrite ((void *) thdr.copyrightMessageLength, amt, abfd) != amt)
683 return FALSE;
684 /* The copyright message is a variable length string. */
685 amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
686 if (bfd_bwrite ((void *) nlm_copyright_header (abfd)->copyrightMessage,
687 amt, abfd) != amt)
688 return FALSE;
691 /* Write out the extended header if there is one. */
692 if (find_nonzero (nlm_extended_header (abfd),
693 sizeof (Nlm_Internal_Extended_Header)))
695 Nlm_External_Extended_Header thdr;
697 LITMEMCPY (thdr.stamp, "MeSsAgEs");
698 put_word (abfd,
699 (bfd_vma) nlm_extended_header (abfd)->languageID,
700 (bfd_byte *) thdr.languageID);
701 put_word (abfd,
702 (bfd_vma) nlm_extended_header (abfd)->messageFileOffset,
703 (bfd_byte *) thdr.messageFileOffset);
704 put_word (abfd,
705 (bfd_vma) nlm_extended_header (abfd)->messageFileLength,
706 (bfd_byte *) thdr.messageFileLength);
707 put_word (abfd,
708 (bfd_vma) nlm_extended_header (abfd)->messageCount,
709 (bfd_byte *) thdr.messageCount);
710 put_word (abfd,
711 (bfd_vma) nlm_extended_header (abfd)->helpFileOffset,
712 (bfd_byte *) thdr.helpFileOffset);
713 put_word (abfd,
714 (bfd_vma) nlm_extended_header (abfd)->helpFileLength,
715 (bfd_byte *) thdr.helpFileLength);
716 put_word (abfd,
717 (bfd_vma) nlm_extended_header (abfd)->RPCDataOffset,
718 (bfd_byte *) thdr.RPCDataOffset);
719 put_word (abfd,
720 (bfd_vma) nlm_extended_header (abfd)->RPCDataLength,
721 (bfd_byte *) thdr.RPCDataLength);
722 put_word (abfd,
723 (bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset,
724 (bfd_byte *) thdr.sharedCodeOffset);
725 put_word (abfd,
726 (bfd_vma) nlm_extended_header (abfd)->sharedCodeLength,
727 (bfd_byte *) thdr.sharedCodeLength);
728 put_word (abfd,
729 (bfd_vma) nlm_extended_header (abfd)->sharedDataOffset,
730 (bfd_byte *) thdr.sharedDataOffset);
731 put_word (abfd,
732 (bfd_vma) nlm_extended_header (abfd)->sharedDataLength,
733 (bfd_byte *) thdr.sharedDataLength);
734 put_word (abfd,
735 (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset,
736 (bfd_byte *) thdr.sharedRelocationFixupOffset);
737 put_word (abfd,
738 (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount,
739 (bfd_byte *) thdr.sharedRelocationFixupCount);
740 put_word (abfd,
741 (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset,
742 (bfd_byte *) thdr.sharedExternalReferenceOffset);
743 put_word (abfd,
744 (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount,
745 (bfd_byte *) thdr.sharedExternalReferenceCount);
746 put_word (abfd,
747 (bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset,
748 (bfd_byte *) thdr.sharedPublicsOffset);
749 put_word (abfd,
750 (bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount,
751 (bfd_byte *) thdr.sharedPublicsCount);
752 put_word (abfd,
753 (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
754 (bfd_byte *) thdr.sharedDebugRecordOffset);
755 put_word (abfd,
756 (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
757 (bfd_byte *) thdr.sharedDebugRecordCount);
758 put_word (abfd,
759 (bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
760 (bfd_byte *) thdr.sharedInitializationOffset);
761 put_word (abfd,
762 (bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
763 (bfd_byte *) thdr.SharedExitProcedureOffset);
764 put_word (abfd,
765 (bfd_vma) nlm_extended_header (abfd)->productID,
766 (bfd_byte *) thdr.productID);
767 put_word (abfd,
768 (bfd_vma) nlm_extended_header (abfd)->reserved0,
769 (bfd_byte *) thdr.reserved0);
770 put_word (abfd,
771 (bfd_vma) nlm_extended_header (abfd)->reserved1,
772 (bfd_byte *) thdr.reserved1);
773 put_word (abfd,
774 (bfd_vma) nlm_extended_header (abfd)->reserved2,
775 (bfd_byte *) thdr.reserved2);
776 put_word (abfd,
777 (bfd_vma) nlm_extended_header (abfd)->reserved3,
778 (bfd_byte *) thdr.reserved3);
779 put_word (abfd,
780 (bfd_vma) nlm_extended_header (abfd)->reserved4,
781 (bfd_byte *) thdr.reserved4);
782 put_word (abfd,
783 (bfd_vma) nlm_extended_header (abfd)->reserved5,
784 (bfd_byte *) thdr.reserved5);
785 if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
786 != sizeof (thdr))
787 return FALSE;
790 /* Write out the custom header if there is one. */
791 if (find_nonzero (nlm_custom_header (abfd),
792 sizeof (Nlm_Internal_Custom_Header)))
794 Nlm_External_Custom_Header thdr;
795 bfd_boolean ds;
796 bfd_size_type hdrLength;
798 ds = find_nonzero (nlm_custom_header (abfd)->dataStamp,
799 sizeof (nlm_custom_header (abfd)->dataStamp));
800 LITMEMCPY (thdr.stamp, "CuStHeAd");
801 hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
802 + nlm_custom_header (abfd)->hdrLength);
803 put_word (abfd, hdrLength, thdr.length);
804 put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataOffset,
805 thdr.dataOffset);
806 put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataLength,
807 thdr.dataLength);
808 if (! ds)
810 BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
811 amt = sizeof (thdr) - sizeof (thdr.dataStamp);
812 if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
813 return FALSE;
815 else
817 memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
818 sizeof (thdr.dataStamp));
819 amt = sizeof (thdr);
820 if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
821 return FALSE;
822 amt = nlm_custom_header (abfd)->hdrLength;
823 if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
824 return FALSE;
828 /* Write out the Cygnus debugging header if there is one. */
829 if (find_nonzero (nlm_cygnus_ext_header (abfd),
830 sizeof (Nlm_Internal_Cygnus_Ext_Header)))
832 Nlm_External_Custom_Header thdr;
834 LITMEMCPY (thdr.stamp, "CuStHeAd");
835 put_word (abfd, (bfd_vma) 2 * NLM_TARGET_LONG_SIZE + 8,
836 (bfd_byte *) thdr.length);
837 put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->offset,
838 (bfd_byte *) thdr.dataOffset);
839 put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
840 (bfd_byte *) thdr.dataLength);
841 LITMEMCPY (thdr.dataStamp, "CyGnUsEx");
842 amt = sizeof (thdr);
843 if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
844 return FALSE;
847 return TRUE;
850 /* We read the NLM's public symbols and use it to generate a bfd symbol
851 table (hey, it's better than nothing) on a one-for-one basis. Thus
852 use the number of public symbols as the number of bfd symbols we will
853 have once we actually get around to reading them in.
855 Return the number of bytes required to hold the symtab vector, based on
856 the count plus 1, since we will NULL terminate the vector allocated based
857 on this size. */
859 long
860 nlm_get_symtab_upper_bound (bfd *abfd)
862 Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
863 long symcount;
864 long symtab_size = 0;
866 i_fxdhdrp = nlm_fixed_header (abfd);
867 symcount = (i_fxdhdrp->numberOfPublics
868 + i_fxdhdrp->numberOfDebugRecords
869 + i_fxdhdrp->numberOfExternalReferences);
870 symtab_size = (symcount + 1) * (sizeof (asymbol));
871 return symtab_size;
874 /* Slurp in nlm symbol table.
876 In the external (in-file) form, NLM export records are variable length,
877 with the following form:
879 1 byte length of the symbol name (N)
880 N bytes the symbol name
881 4 bytes the symbol offset from start of it's section
883 We also read in the debugging symbols and import records. Import
884 records are treated as undefined symbols. As we read the import
885 records we also read in the associated reloc information, which is
886 attached to the symbol.
888 The bfd symbols are copied to SYMvoid *S.
890 When we return, the bfd symcount is either zero or contains the correct
891 number of symbols. */
893 static bfd_boolean
894 nlm_slurp_symbol_table (bfd *abfd)
896 Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
897 bfd_size_type totsymcount; /* Number of NLM symbols. */
898 bfd_size_type symcount; /* Counter of NLM symbols. */
899 nlm_symbol_type *sym; /* Pointer to current bfd symbol. */
900 unsigned char symlength; /* Symbol length read into here. */
901 unsigned char symtype; /* Type of debugging symbol. */
902 bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here. */
903 bfd_boolean (*read_import_func) (bfd *, nlm_symbol_type *);
904 bfd_boolean (*set_public_section_func) (bfd *, nlm_symbol_type *);
905 bfd_size_type amt;
907 if (nlm_get_symbols (abfd) != NULL)
908 return TRUE;
910 /* Read each raw NLM symbol, using the information to create a canonical bfd
911 symbol table entry.
913 Note that we allocate the initial bfd canonical symbol buffer based on a
914 one-to-one mapping of the NLM symbols to canonical symbols. We actually
915 use all the NLM symbols, so there will be no space left over at the end.
916 When we have all the symbols, we build the caller's pointer vector. */
918 abfd->symcount = 0;
919 i_fxdhdrp = nlm_fixed_header (abfd);
920 totsymcount = (i_fxdhdrp->numberOfPublics
921 + i_fxdhdrp->numberOfDebugRecords
922 + i_fxdhdrp->numberOfExternalReferences);
923 if (totsymcount == 0)
924 return TRUE;
926 if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) != 0)
927 return FALSE;
929 amt = totsymcount * sizeof (nlm_symbol_type);
930 sym = bfd_zalloc (abfd, amt);
931 if (!sym)
932 return FALSE;
933 nlm_set_symbols (abfd, sym);
935 /* We use the bfd's symcount directly as the control count, so that early
936 termination of the loop leaves the symcount correct for the symbols that
937 were read. */
939 set_public_section_func = nlm_set_public_section_func (abfd);
940 symcount = i_fxdhdrp->numberOfPublics;
941 while (abfd->symcount < symcount)
943 amt = sizeof (symlength);
944 if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
945 return FALSE;
946 amt = symlength;
947 sym->symbol.the_bfd = abfd;
948 sym->symbol.name = bfd_alloc (abfd, amt + 1);
949 if (!sym->symbol.name)
950 return FALSE;
951 if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
952 return FALSE;
953 /* Cast away const. */
954 ((char *) (sym->symbol.name))[symlength] = '\0';
955 amt = sizeof (temp);
956 if (bfd_bread ((void *) temp, amt, abfd) != amt)
957 return FALSE;
958 sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
959 sym->symbol.value = get_word (abfd, temp);
960 if (set_public_section_func)
962 /* Most backends can use the code below, but unfortunately
963 some use a different scheme. */
964 if (! (*set_public_section_func) (abfd, sym))
965 return FALSE;
967 else
969 if (sym->symbol.value & NLM_HIBIT)
971 sym->symbol.value &= ~NLM_HIBIT;
972 sym->symbol.flags |= BSF_FUNCTION;
973 sym->symbol.section =
974 bfd_get_section_by_name (abfd, NLM_CODE_NAME);
976 else
977 sym->symbol.section =
978 bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
980 sym->rcnt = 0;
981 abfd->symcount++;
982 sym++;
985 /* Read the debugging records. */
987 if (i_fxdhdrp->numberOfDebugRecords > 0)
989 if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) != 0)
990 return FALSE;
992 symcount += i_fxdhdrp->numberOfDebugRecords;
993 while (abfd->symcount < symcount)
995 amt = sizeof (symtype);
996 if (bfd_bread ((void *) &symtype, amt, abfd) != amt)
997 return FALSE;
998 amt = sizeof (temp);
999 if (bfd_bread ((void *) temp, amt, abfd) != amt)
1000 return FALSE;
1001 amt = sizeof (symlength);
1002 if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
1003 return FALSE;
1004 amt = symlength;
1005 sym->symbol.the_bfd = abfd;
1006 sym->symbol.name = bfd_alloc (abfd, amt + 1);
1007 if (!sym->symbol.name)
1008 return FALSE;
1009 if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
1010 return FALSE;
1011 /* Cast away const. */
1012 ((char *) (sym->symbol.name))[symlength] = '\0';
1013 sym->symbol.flags = BSF_LOCAL;
1014 sym->symbol.value = get_word (abfd, temp);
1016 if (symtype == 0)
1017 sym->symbol.section =
1018 bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
1019 else if (symtype == 1)
1021 sym->symbol.flags |= BSF_FUNCTION;
1022 sym->symbol.section =
1023 bfd_get_section_by_name (abfd, NLM_CODE_NAME);
1025 else
1026 sym->symbol.section = bfd_abs_section_ptr;
1028 sym->rcnt = 0;
1029 abfd->symcount++;
1030 sym++;
1034 /* Read in the import records. We can only do this if we know how
1035 to read relocs for this target. */
1036 read_import_func = nlm_read_import_func (abfd);
1037 if (read_import_func != NULL)
1039 if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET) != 0)
1040 return FALSE;
1042 symcount += i_fxdhdrp->numberOfExternalReferences;
1043 while (abfd->symcount < symcount)
1045 if (! (*read_import_func) (abfd, sym))
1046 return FALSE;
1047 sym++;
1048 abfd->symcount++;
1052 return TRUE;
1055 /* Note that bfd_get_symcount is guaranteed to be zero if slurping the
1056 symbol table fails. */
1058 long
1059 nlm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
1061 nlm_symbol_type *symbase;
1062 bfd_size_type counter = 0;
1064 if (! nlm_slurp_symbol_table (abfd))
1065 return -1;
1066 symbase = nlm_get_symbols (abfd);
1067 while (counter < bfd_get_symcount (abfd))
1069 *alocation++ = &symbase->symbol;
1070 symbase++;
1071 counter++;
1073 *alocation = NULL;
1074 return bfd_get_symcount (abfd);
1077 /* Make an NLM symbol. There is nothing special to do here. */
1079 asymbol *
1080 nlm_make_empty_symbol (bfd *abfd)
1082 bfd_size_type amt = sizeof (nlm_symbol_type);
1083 nlm_symbol_type *new = bfd_zalloc (abfd, amt);
1085 if (new == NULL)
1086 return NULL;
1087 new->symbol.the_bfd = abfd;
1088 return & new->symbol;
1091 /* Get symbol information. */
1093 void
1094 nlm_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1095 asymbol *symbol,
1096 symbol_info *ret)
1098 bfd_symbol_info (symbol, ret);
1101 /* Print symbol information. */
1103 void
1104 nlm_print_symbol (bfd *abfd,
1105 void * afile,
1106 asymbol *symbol,
1107 bfd_print_symbol_type how)
1109 FILE *file = (FILE *) afile;
1111 switch (how)
1113 case bfd_print_symbol_name:
1114 case bfd_print_symbol_more:
1115 if (symbol->name)
1116 fprintf (file, "%s", symbol->name);
1117 break;
1118 case bfd_print_symbol_all:
1119 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1120 fprintf (file, " %-5s", symbol->section->name);
1121 if (symbol->name)
1122 fprintf (file, " %s", symbol->name);
1123 break;
1127 /* Get the relocs for an NLM file. There are two types of relocs.
1128 Imports are relocs against symbols defined in other NLM files. We
1129 treat these as relocs against global symbols. Relocation fixups
1130 are internal relocs.
1132 The actual format used to store the relocs is machine specific. */
1134 /* Read in the relocation fixup information. This is stored in
1135 nlm_relocation_fixups, an array of arelent structures, and
1136 nlm_relocation_fixup_secs, an array of section pointers. The
1137 section pointers are needed because the relocs are not sorted by
1138 section. */
1140 static bfd_boolean
1141 nlm_slurp_reloc_fixups (bfd *abfd)
1143 bfd_boolean (*read_func) (bfd *, nlm_symbol_type *, asection **, arelent *);
1144 bfd_size_type count, amt;
1145 arelent *rels;
1146 asection **secs;
1148 if (nlm_relocation_fixups (abfd) != NULL)
1149 return TRUE;
1150 read_func = nlm_read_reloc_func (abfd);
1151 if (read_func == NULL)
1152 return TRUE;
1154 if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
1155 SEEK_SET) != 0)
1156 return FALSE;
1158 count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1159 amt = count * sizeof (arelent);
1160 rels = bfd_alloc (abfd, amt);
1161 amt = count * sizeof (asection *);
1162 secs = bfd_alloc (abfd, amt);
1163 if ((rels == NULL || secs == NULL) && count != 0)
1164 return FALSE;
1165 nlm_relocation_fixups (abfd) = rels;
1166 nlm_relocation_fixup_secs (abfd) = secs;
1168 /* We have to read piece by piece, because we don't know how large
1169 the machine specific reloc information is. */
1170 while (count-- != 0)
1172 if (! (*read_func) (abfd, NULL, secs, rels))
1174 nlm_relocation_fixups (abfd) = NULL;
1175 nlm_relocation_fixup_secs (abfd) = NULL;
1176 return FALSE;
1178 ++secs;
1179 ++rels;
1182 return TRUE;
1185 /* Get the number of relocs. This really just returns an upper bound,
1186 since it does not attempt to distinguish them based on the section.
1187 That will be handled when they are actually read. */
1189 long
1190 nlm_get_reloc_upper_bound (bfd *abfd, asection *sec)
1192 nlm_symbol_type *syms;
1193 bfd_size_type count;
1194 unsigned int ret;
1196 /* If we don't know how to read relocs, just return 0. */
1197 if (nlm_read_reloc_func (abfd) == NULL)
1198 return -1;
1199 /* Make sure we have either the code or the data section. */
1200 if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
1201 return 0;
1203 syms = nlm_get_symbols (abfd);
1204 if (syms == NULL)
1206 if (! nlm_slurp_symbol_table (abfd))
1207 return -1;
1208 syms = nlm_get_symbols (abfd);
1211 ret = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1213 count = bfd_get_symcount (abfd);
1214 while (count-- != 0)
1216 ret += syms->rcnt;
1217 ++syms;
1220 return (ret + 1) * sizeof (arelent *);
1223 /* Get the relocs themselves. */
1225 long
1226 nlm_canonicalize_reloc (bfd *abfd,
1227 asection *sec,
1228 arelent **relptr,
1229 asymbol **symbols)
1231 arelent *rels;
1232 asection **secs;
1233 bfd_size_type count, i;
1234 long ret;
1236 /* Get the relocation fixups. */
1237 rels = nlm_relocation_fixups (abfd);
1238 if (rels == NULL)
1240 if (! nlm_slurp_reloc_fixups (abfd))
1241 return -1;
1242 rels = nlm_relocation_fixups (abfd);
1244 secs = nlm_relocation_fixup_secs (abfd);
1246 ret = 0;
1247 count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
1248 for (i = 0; i < count; i++, rels++, secs++)
1250 if (*secs == sec)
1252 *relptr++ = rels;
1253 ++ret;
1257 /* Get the import symbols. */
1258 count = bfd_get_symcount (abfd);
1259 for (i = 0; i < count; i++, symbols++)
1261 asymbol *sym;
1263 sym = *symbols;
1264 if (bfd_asymbol_flavour (sym) == bfd_target_nlm_flavour)
1266 nlm_symbol_type *nlm_sym;
1267 bfd_size_type j;
1269 nlm_sym = (nlm_symbol_type *) sym;
1270 for (j = 0; j < nlm_sym->rcnt; j++)
1272 if (nlm_sym->relocs[j].section == sec)
1274 *relptr = &nlm_sym->relocs[j].reloc;
1275 (*relptr)->sym_ptr_ptr = symbols;
1276 ++relptr;
1277 ++ret;
1283 *relptr = NULL;
1285 return ret;
1288 /* Compute the section file positions for an NLM file. All variable
1289 length data in the file headers must be set before this function is
1290 called. If the variable length data is changed later, the
1291 resulting object file will be incorrect. Unfortunately, there is
1292 no way to check this.
1294 This routine also sets the Size and Offset fields in the fixed
1295 header.
1297 It also looks over the symbols and moves any common symbols into
1298 the .bss section; NLM has no way to represent a common symbol.
1299 This approach means that either the symbols must already have been
1300 set at this point, or there must be no common symbols. We need to
1301 move the symbols at this point so that mangle_relocs can see the
1302 final values. */
1304 static bfd_boolean
1305 nlm_compute_section_file_positions (bfd *abfd)
1307 file_ptr sofar;
1308 asection *sec;
1309 bfd_vma text, data, bss;
1310 bfd_vma text_low, data_low;
1311 unsigned int text_align, data_align, other_align;
1312 file_ptr text_ptr, data_ptr, other_ptr;
1313 asection *bss_sec;
1314 asymbol **sym_ptr_ptr;
1316 if (abfd->output_has_begun)
1317 return TRUE;
1319 /* Make sure we have a section to hold uninitialized data. */
1320 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
1321 if (bss_sec == NULL)
1323 if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
1324 (file_ptr) 0, (bfd_size_type) 0,
1325 SEC_ALLOC))
1326 return FALSE;
1327 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
1330 abfd->output_has_begun = TRUE;
1332 /* The fixed header. */
1333 sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
1335 /* The variable header. */
1336 sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
1337 + nlm_variable_header (abfd)->descriptionLength + 1
1338 + NLM_TARGET_LONG_SIZE /* stackSize */
1339 + NLM_TARGET_LONG_SIZE /* reserved */
1340 + sizeof (nlm_variable_header (abfd)->oldThreadName)
1341 + sizeof (nlm_variable_header (abfd)->screenNameLength)
1342 + nlm_variable_header (abfd)->screenNameLength + 1
1343 + sizeof (nlm_variable_header (abfd)->threadNameLength)
1344 + nlm_variable_header (abfd)->threadNameLength + 1);
1346 /* The auxiliary headers. */
1347 if (find_nonzero (nlm_version_header (abfd),
1348 sizeof (Nlm_Internal_Version_Header)))
1349 sofar += sizeof (Nlm_External_Version_Header);
1350 if (find_nonzero (nlm_extended_header (abfd),
1351 sizeof (Nlm_Internal_Extended_Header)))
1352 sofar += sizeof (Nlm_External_Extended_Header);
1353 if (find_nonzero (nlm_copyright_header (abfd),
1354 sizeof (Nlm_Internal_Copyright_Header)))
1355 sofar += (sizeof (Nlm_External_Copyright_Header)
1356 + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
1357 if (find_nonzero (nlm_custom_header (abfd),
1358 sizeof (Nlm_Internal_Custom_Header)))
1359 sofar += (sizeof (Nlm_External_Custom_Header)
1360 + nlm_custom_header (abfd)->hdrLength);
1361 if (find_nonzero (nlm_cygnus_ext_header (abfd),
1362 sizeof (Nlm_Internal_Cygnus_Ext_Header)))
1363 sofar += sizeof (Nlm_External_Custom_Header);
1365 /* Compute the section file positions in two passes. First get the
1366 sizes of the text and data sections, and then set the file
1367 positions. This code aligns the sections in the file using the
1368 same alignment restrictions that apply to the sections in memory;
1369 this may not be necessary. */
1370 text = 0;
1371 text_low = (bfd_vma) - 1;
1372 text_align = 0;
1373 data = 0;
1374 data_low = (bfd_vma) - 1;
1375 data_align = 0;
1376 bss = 0;
1377 other_align = 0;
1378 for (sec = abfd->sections; sec != NULL; sec = sec->next)
1380 flagword f;
1382 sec->size = BFD_ALIGN (sec->size, 1 << sec->alignment_power);
1384 f = bfd_get_section_flags (abfd, sec);
1385 if (f & SEC_CODE)
1387 text += sec->size;
1388 if (bfd_get_section_vma (abfd, sec) < text_low)
1389 text_low = bfd_get_section_vma (abfd, sec);
1390 if (sec->alignment_power > text_align)
1391 text_align = sec->alignment_power;
1393 else if (f & SEC_DATA)
1395 data += sec->size;
1396 if (bfd_get_section_vma (abfd, sec) < data_low)
1397 data_low = bfd_get_section_vma (abfd, sec);
1398 if (sec->alignment_power > data_align)
1399 data_align = sec->alignment_power;
1401 else if (f & SEC_HAS_CONTENTS)
1403 if (sec->alignment_power > other_align)
1404 other_align = sec->alignment_power;
1406 else if (f & SEC_ALLOC)
1407 bss += sec->size;
1410 nlm_set_text_low (abfd, text_low);
1411 nlm_set_data_low (abfd, data_low);
1413 if (nlm_no_uninitialized_data (abfd))
1415 /* This NetWare format does not use uninitialized data. We must
1416 increase the size of the data section. We will never wind up
1417 writing those file locations, so they will remain zero. */
1418 data += bss;
1419 bss = 0;
1422 text_ptr = BFD_ALIGN (sofar, 1 << text_align);
1423 data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
1424 other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
1426 /* Fill in some fields in the header for which we now have the
1427 information. */
1428 nlm_fixed_header (abfd)->codeImageOffset = text_ptr;
1429 nlm_fixed_header (abfd)->codeImageSize = text;
1430 nlm_fixed_header (abfd)->dataImageOffset = data_ptr;
1431 nlm_fixed_header (abfd)->dataImageSize = data;
1432 nlm_fixed_header (abfd)->uninitializedDataSize = bss;
1434 for (sec = abfd->sections; sec != NULL; sec = sec->next)
1436 flagword f;
1438 f = bfd_get_section_flags (abfd, sec);
1440 if (f & SEC_CODE)
1442 sec->filepos = text_ptr;
1443 text_ptr += sec->size;
1445 else if (f & SEC_DATA)
1447 sec->filepos = data_ptr;
1448 data_ptr += sec->size;
1450 else if (f & SEC_HAS_CONTENTS)
1452 sec->filepos = other_ptr;
1453 other_ptr += sec->size;
1457 nlm_fixed_header (abfd)->relocationFixupOffset = other_ptr;
1459 /* Move all common symbols into the .bss section. */
1461 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1462 if (sym_ptr_ptr != NULL)
1464 asymbol **sym_end;
1465 bfd_vma add;
1467 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1468 add = 0;
1469 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1471 asymbol *sym;
1472 bfd_vma size;
1474 sym = *sym_ptr_ptr;
1476 if (!bfd_is_com_section (bfd_get_section (sym)))
1477 continue;
1479 /* Put the common symbol in the .bss section, and increase
1480 the size of the .bss section by the size of the common
1481 symbol (which is the old value of the symbol). */
1482 sym->section = bss_sec;
1483 size = sym->value;
1484 sym->value = bss_sec->size + add;
1485 add += size;
1486 add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
1488 if (add != 0)
1490 if (nlm_no_uninitialized_data (abfd))
1492 /* We could handle this case, but so far it hasn't been
1493 necessary. */
1494 abort ();
1496 nlm_fixed_header (abfd)->uninitializedDataSize += add;
1497 bss_sec->size += add;
1501 return TRUE;
1504 /* Set the contents of a section. To do this we need to know where
1505 the section is going to be located in the output file. That means
1506 that the sizes of all the sections must be set, and all the
1507 variable size header information must be known. */
1509 bfd_boolean
1510 nlm_set_section_contents (bfd *abfd,
1511 asection *section,
1512 const void * location,
1513 file_ptr offset,
1514 bfd_size_type count)
1516 if (! abfd->output_has_begun
1517 && ! nlm_compute_section_file_positions (abfd))
1518 return FALSE;
1520 if (count == 0)
1521 return TRUE;
1523 /* i386 NetWare has a very restricted set of relocs. In order for
1524 objcopy to work, the NLM i386 backend needs a chance to rework
1525 the section contents so that its set of relocs will work. If all
1526 the relocs are already acceptable, this will not do anything. */
1527 if (section->reloc_count != 0)
1529 bfd_boolean (*mangle_relocs_func)
1530 (bfd *, asection *, const void *, bfd_vma, bfd_size_type);
1532 mangle_relocs_func = nlm_mangle_relocs_func (abfd);
1533 if (mangle_relocs_func != NULL)
1535 if (!(*mangle_relocs_func) (abfd, section, location,
1536 (bfd_vma) offset, count))
1537 return FALSE;
1541 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1542 || bfd_bwrite (location, count, abfd) != count)
1543 return FALSE;
1545 return TRUE;
1548 /* We need to sort a list of relocs associated with sections when we
1549 write out the external relocs. */
1551 static int
1552 nlm_external_reloc_compare (const void *p1, const void *p2)
1554 const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
1555 const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
1556 int cmp;
1558 cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
1559 (*r2->rel->sym_ptr_ptr)->name);
1560 if (cmp != 0)
1561 return cmp;
1563 /* We sort by address within symbol to make the sort more stable and
1564 increase the chances that different hosts will generate bit for
1565 bit equivalent results. */
1566 return (int) (r1->rel->address - r2->rel->address);
1569 /* Write out an NLM file. We write out the information in this order:
1570 fixed header
1571 variable header
1572 auxiliary headers
1573 code sections
1574 data sections
1575 other sections (custom data, messages, help, shared NLM, RPC,
1576 module dependencies)
1577 relocation fixups
1578 external references (imports)
1579 public symbols (exports)
1580 debugging records
1581 This is similar to the order used by the NetWare tools; the
1582 difference is that NetWare puts the sections other than code, data
1583 and custom data at the end of the NLM. It is convenient for us to
1584 know where the sections are going to be before worrying about the
1585 size of the other information.
1587 By the time this function is called, all the section data should
1588 have been output using set_section_contents. Note that custom
1589 data, the message file, the help file, the shared NLM file, the RPC
1590 data, and the module dependencies are all considered to be
1591 sections; the caller is responsible for filling in the offset and
1592 length fields in the NLM headers. The relocation fixups and
1593 imports are both obtained from the list of relocs attached to each
1594 section. The exports and debugging records are obtained from the
1595 list of outsymbols. */
1597 bfd_boolean
1598 nlm_write_object_contents (bfd *abfd)
1600 asection *sec;
1601 bfd_boolean (*write_import_func) (bfd *, asection *, arelent *);
1602 bfd_size_type external_reloc_count, internal_reloc_count, i, c;
1603 struct reloc_and_sec *external_relocs;
1604 asymbol **sym_ptr_ptr;
1605 file_ptr last;
1606 bfd_boolean (*write_prefix_func) (bfd *);
1607 unsigned char *fixed_header = NULL;
1608 file_ptr pos;
1609 bfd_size_type amt;
1611 fixed_header = bfd_malloc (nlm_fixed_header_size (abfd));
1612 if (fixed_header == NULL)
1613 goto error_return;
1615 if (! abfd->output_has_begun
1616 && ! nlm_compute_section_file_positions (abfd))
1617 goto error_return;
1619 /* Write out the variable length headers. */
1620 pos = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
1621 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1622 goto error_return;
1623 if (! nlm_swap_variable_header_out (abfd)
1624 || ! nlm_swap_auxiliary_headers_out (abfd))
1626 bfd_set_error (bfd_error_system_call);
1627 goto error_return;
1630 /* A weak check on whether the section file positions were
1631 reasonable. */
1632 if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
1634 bfd_set_error (bfd_error_invalid_operation);
1635 goto error_return;
1638 /* Advance to the relocs. */
1639 if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
1640 SEEK_SET) != 0)
1641 goto error_return;
1643 /* The format of the relocation entries is dependent upon the
1644 particular target. We use an external routine to write the reloc
1645 out. */
1646 write_import_func = nlm_write_import_func (abfd);
1648 /* Write out the internal relocation fixups. While we're looping
1649 over the relocs, we also count the external relocs, which is
1650 needed when they are written out below. */
1651 internal_reloc_count = 0;
1652 external_reloc_count = 0;
1653 for (sec = abfd->sections; sec != NULL; sec = sec->next)
1655 arelent **rel_ptr_ptr, **rel_end;
1657 if (sec->reloc_count == 0)
1658 continue;
1660 /* We can only represent relocs within a code or data
1661 section. We ignore them for a debugging section. */
1662 if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
1663 continue;
1665 /* We need to know how to write out imports */
1666 if (write_import_func == NULL)
1668 bfd_set_error (bfd_error_invalid_operation);
1669 goto error_return;
1672 rel_ptr_ptr = sec->orelocation;
1673 rel_end = rel_ptr_ptr + sec->reloc_count;
1674 for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
1676 arelent *rel;
1677 asymbol *sym;
1679 rel = *rel_ptr_ptr;
1680 sym = *rel->sym_ptr_ptr;
1682 if (! bfd_is_und_section (bfd_get_section (sym)))
1684 ++internal_reloc_count;
1685 if (! (*write_import_func) (abfd, sec, rel))
1686 goto error_return;
1688 else
1689 ++external_reloc_count;
1692 nlm_fixed_header (abfd)->numberOfRelocationFixups = internal_reloc_count;
1694 /* Write out the imports (relocs against external symbols). These
1695 are output as a symbol name followed by all the relocs for that
1696 symbol, so we must first gather together all the relocs against
1697 external symbols and sort them. */
1698 amt = external_reloc_count * sizeof (struct reloc_and_sec);
1699 external_relocs = bfd_alloc (abfd, amt);
1700 if (external_relocs == NULL)
1701 goto error_return;
1702 i = 0;
1703 for (sec = abfd->sections; sec != NULL; sec = sec->next)
1705 arelent **rel_ptr_ptr, **rel_end;
1707 if (sec->reloc_count == 0)
1708 continue;
1710 rel_ptr_ptr = sec->orelocation;
1711 rel_end = rel_ptr_ptr + sec->reloc_count;
1712 for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
1714 arelent *rel;
1715 asymbol *sym;
1717 rel = *rel_ptr_ptr;
1718 sym = *rel->sym_ptr_ptr;
1720 if (! bfd_is_und_section (bfd_get_section (sym)))
1721 continue;
1723 external_relocs[i].rel = rel;
1724 external_relocs[i].sec = sec;
1725 ++i;
1729 BFD_ASSERT (i == external_reloc_count);
1731 /* Sort the external relocs by name. */
1732 qsort (external_relocs, (size_t) external_reloc_count,
1733 sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
1735 /* Write out the external relocs. */
1736 nlm_fixed_header (abfd)->externalReferencesOffset = bfd_tell (abfd);
1737 c = 0;
1738 i = 0;
1739 while (i < external_reloc_count)
1741 arelent *rel;
1742 asymbol *sym;
1743 bfd_size_type j, cnt;
1745 ++c;
1747 rel = external_relocs[i].rel;
1748 sym = *rel->sym_ptr_ptr;
1750 cnt = 0;
1751 for (j = i;
1752 (j < external_reloc_count
1753 && *external_relocs[j].rel->sym_ptr_ptr == sym);
1754 j++)
1755 ++cnt;
1757 if (! (*nlm_write_external_func (abfd)) (abfd, cnt, sym,
1758 &external_relocs[i]))
1759 goto error_return;
1761 i += cnt;
1764 nlm_fixed_header (abfd)->numberOfExternalReferences = c;
1766 /* Write out the public symbols (exports). */
1767 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1768 if (sym_ptr_ptr != NULL)
1770 bfd_vma (*get_public_offset_func) (bfd *, asymbol *);
1771 bfd_boolean (*write_export_func) (bfd *, asymbol *, bfd_vma);
1773 asymbol **sym_end;
1775 nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
1776 get_public_offset_func = nlm_get_public_offset_func (abfd);
1777 write_export_func = nlm_write_export_func (abfd);
1778 c = 0;
1779 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1780 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1782 asymbol *sym;
1783 bfd_byte len;
1784 bfd_vma offset;
1785 bfd_byte temp[NLM_TARGET_LONG_SIZE];
1787 sym = *sym_ptr_ptr;
1789 if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
1790 || bfd_is_und_section (bfd_get_section (sym)))
1791 continue;
1793 ++c;
1795 if (get_public_offset_func)
1797 /* Most backends can use the code below, but
1798 unfortunately some use a different scheme. */
1799 offset = (*get_public_offset_func) (abfd, sym);
1801 else
1803 offset = bfd_asymbol_value (sym);
1804 sec = sym->section;
1805 if (sec->flags & SEC_CODE)
1807 offset -= nlm_get_text_low (abfd);
1808 offset |= NLM_HIBIT;
1810 else if (sec->flags & (SEC_DATA | SEC_ALLOC))
1812 /* SEC_ALLOC is for the .bss section. */
1813 offset -= nlm_get_data_low (abfd);
1815 else
1817 /* We can't handle an exported symbol that is not in
1818 the code or data segment. */
1819 bfd_set_error (bfd_error_invalid_operation);
1820 goto error_return;
1824 if (write_export_func)
1826 if (! (*write_export_func) (abfd, sym, offset))
1827 goto error_return;
1829 else
1831 len = strlen (sym->name);
1832 if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
1833 != sizeof (bfd_byte))
1834 || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
1835 goto error_return;
1837 put_word (abfd, offset, temp);
1838 if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
1839 != sizeof (temp))
1840 goto error_return;
1843 nlm_fixed_header (abfd)->numberOfPublics = c;
1845 /* Write out the debugging records. The NLM conversion program
1846 wants to be able to inhibit this, so as a special hack if
1847 debugInfoOffset is set to -1 we don't write any debugging
1848 information. This can not be handled by fiddling with the
1849 symbol table, because exported symbols appear in both the
1850 exported symbol list and the debugging information. */
1851 if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) - 1)
1853 nlm_fixed_header (abfd)->debugInfoOffset = 0;
1854 nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
1856 else
1858 nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
1859 c = 0;
1860 sym_ptr_ptr = bfd_get_outsymbols (abfd);
1861 sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
1862 for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
1864 asymbol *sym;
1865 bfd_byte type, len;
1866 bfd_vma offset;
1867 bfd_byte temp[NLM_TARGET_LONG_SIZE];
1869 sym = *sym_ptr_ptr;
1871 /* The NLM notion of a debugging symbol is actually what
1872 BFD calls a local or global symbol. What BFD calls a
1873 debugging symbol NLM does not understand at all. */
1874 if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
1875 || (sym->flags & BSF_DEBUGGING) != 0
1876 || bfd_is_und_section (bfd_get_section (sym)))
1877 continue;
1879 ++c;
1881 offset = bfd_asymbol_value (sym);
1882 sec = sym->section;
1883 if (sec->flags & SEC_CODE)
1885 offset -= nlm_get_text_low (abfd);
1886 type = 1;
1888 else if (sec->flags & (SEC_DATA | SEC_ALLOC))
1890 /* SEC_ALLOC is for the .bss section. */
1891 offset -= nlm_get_data_low (abfd);
1892 type = 0;
1894 else
1895 type = 2;
1897 /* The type is 0 for data, 1 for code, 2 for absolute. */
1898 if (bfd_bwrite (&type, (bfd_size_type) sizeof (bfd_byte), abfd)
1899 != sizeof (bfd_byte))
1900 goto error_return;
1902 put_word (abfd, offset, temp);
1903 if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
1904 != sizeof (temp))
1905 goto error_return;
1907 len = strlen (sym->name);
1908 if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
1909 != sizeof (bfd_byte))
1910 || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
1911 goto error_return;
1913 nlm_fixed_header (abfd)->numberOfDebugRecords = c;
1917 /* NLMLINK fills in offset values even if there is no data, so we do
1918 the same. */
1919 last = bfd_tell (abfd);
1920 if (nlm_fixed_header (abfd)->codeImageOffset == 0)
1921 nlm_fixed_header (abfd)->codeImageOffset = last;
1922 if (nlm_fixed_header (abfd)->dataImageOffset == 0)
1923 nlm_fixed_header (abfd)->dataImageOffset = last;
1924 if (nlm_fixed_header (abfd)->customDataOffset == 0)
1925 nlm_fixed_header (abfd)->customDataOffset = last;
1926 if (nlm_fixed_header (abfd)->moduleDependencyOffset == 0)
1927 nlm_fixed_header (abfd)->moduleDependencyOffset = last;
1928 if (nlm_fixed_header (abfd)->relocationFixupOffset == 0)
1929 nlm_fixed_header (abfd)->relocationFixupOffset = last;
1930 if (nlm_fixed_header (abfd)->externalReferencesOffset == 0)
1931 nlm_fixed_header (abfd)->externalReferencesOffset = last;
1932 if (nlm_fixed_header (abfd)->publicsOffset == 0)
1933 nlm_fixed_header (abfd)->publicsOffset = last;
1934 if (nlm_fixed_header (abfd)->debugInfoOffset == 0)
1935 nlm_fixed_header (abfd)->debugInfoOffset = last;
1937 /* At this point everything has been written out except the fixed
1938 header. */
1939 memcpy (nlm_fixed_header (abfd)->signature, nlm_signature (abfd),
1940 NLM_SIGNATURE_SIZE);
1941 nlm_fixed_header (abfd)->version = NLM_HEADER_VERSION;
1942 nlm_fixed_header (abfd)->codeStartOffset =
1943 (bfd_get_start_address (abfd)
1944 - nlm_get_text_low (abfd));
1946 /* We have no convenient way for the caller to pass in the exit
1947 procedure or the check unload procedure, so the caller must set
1948 the values in the header to the values of the symbols. */
1949 nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
1950 if (nlm_fixed_header (abfd)->checkUnloadProcedureOffset != 0)
1951 nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
1952 nlm_get_text_low (abfd);
1954 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1955 goto error_return;
1957 write_prefix_func = nlm_write_prefix_func (abfd);
1958 if (write_prefix_func)
1960 if (! (*write_prefix_func) (abfd))
1961 goto error_return;
1964 BFD_ASSERT ((bfd_size_type) bfd_tell (abfd)
1965 == nlm_optional_prefix_size (abfd));
1967 nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
1968 if (bfd_bwrite (fixed_header, nlm_fixed_header_size (abfd), abfd)
1969 != nlm_fixed_header_size (abfd))
1970 goto error_return;
1972 if (fixed_header != NULL)
1973 free (fixed_header);
1974 return TRUE;
1976 error_return:
1977 if (fixed_header != NULL)
1978 free (fixed_header);
1979 return FALSE;