]> Git Repo - binutils.git/blame - bfd/nlm32-ppc.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf32-mips.c (mips16_jump_reloc): Print a warning rather than
[binutils.git] / bfd / nlm32-ppc.c
CommitLineData
3af0f479
ILT		 1/* Support for 32-bit PowerPC NLM (NetWare Loadable Module)
2 Copyright (C) 1994 Free Software Foundation, Inc.
3
4This file is part of BFD, the Binary File Descriptor library.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
18Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20#include "bfd.h"
21#include "sysdep.h"
22#include "libbfd.h"
23
476d01f0
ILT		 24/* The format of a PowerPC NLM changed. Define OLDFORMAT to get the
25 old format. */
26
3af0f479
ILT		 27#define ARCH_SIZE 32
28
29#include "nlm/ppc-ext.h"
30#define Nlm_External_Fixed_Header Nlm32_powerpc_External_Fixed_Header
31
32#include "libnlm.h"
33
476d01f0 34#ifdef OLDFORMAT
3af0f479
ILT		 35static boolean nlm_powerpc_backend_object_p
36 PARAMS ((bfd *));
37static boolean nlm_powerpc_write_prefix
38 PARAMS ((bfd *));
476d01f0
ILT		 39#endif
40
3af0f479
ILT		 41static boolean nlm_powerpc_read_reloc
42 PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
43static boolean nlm_powerpc_mangle_relocs
44 PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
45static boolean nlm_powerpc_read_import
46 PARAMS ((bfd *, nlmNAME(symbol_type) *));
476d01f0
ILT		 47
48#ifdef OLDFORMAT
3af0f479
ILT		 49static boolean nlm_powerpc_write_reloc
50 PARAMS ((bfd *, asection *, arelent *, int));
476d01f0
ILT		 51#endif
52
3af0f479
ILT		 53static boolean nlm_powerpc_write_import
54 PARAMS ((bfd *, asection *, arelent *));
55static boolean nlm_powerpc_write_external
56 PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));
476d01f0
ILT		 57
58#ifndef OLDFORMAT
59static boolean nlm_powerpc_set_public_section
60 PARAMS ((bfd *, nlmNAME(symbol_type) *));
61static bfd_vma nlm_powerpc_get_public_offset
62 PARAMS ((bfd *, asymbol *));
63#endif
3af0f479 64\f
476d01f0
ILT		 65#ifdef OLDFORMAT
66
67/* The prefix header is only used in the old format. */
68
3af0f479
ILT		 69/* PowerPC NLM's have a prefix header before the standard NLM. This
70 function reads it in, verifies the version, and seeks the bfd to
71 the location before the regular NLM header. */
72
73static boolean
74nlm_powerpc_backend_object_p (abfd)
75 bfd *abfd;
76{
77 struct nlm32_powerpc_external_prefix_header s;
78
79 if (bfd_read ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
80 return false;
81
82 if (memcmp (s.signature, NLM32_POWERPC_SIGNATURE, sizeof s.signature) != 0
83 || bfd_h_get_32 (abfd, s.headerVersion) != NLM32_POWERPC_HEADER_VERSION)
84 return false;
85
86 return true;
87}
88
89/* Write out the prefix. */
90
91static boolean
92nlm_powerpc_write_prefix (abfd)
93 bfd *abfd;
94{
95 struct nlm32_powerpc_external_prefix_header s;
96
97 memset (&s, 0, sizeof s);
98 memcpy (s.signature, NLM32_POWERPC_SIGNATURE, sizeof s.signature);
99 bfd_h_put_32 (abfd, (bfd_vma) NLM32_POWERPC_HEADER_VERSION, s.headerVersion);
100 bfd_h_put_32 (abfd, (bfd_vma) 0, s.origins);
101
102 /* FIXME: What should we do about the date? */
103
104 if (bfd_write ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
105 return false;
106
107 return true;
108}
476d01f0
ILT		 109
110#endif /* OLDFORMAT */
3af0f479 111\f
476d01f0
ILT		 112#ifndef OLDFORMAT
113
114/* There is only one type of reloc in a PowerPC NLM. */
115
116static reloc_howto_type nlm_powerpc_howto =
117 HOWTO (0, /* type */
118 0, /* rightshift */
119 2, /* size (0 = byte, 1 = short, 2 = long) */
120 32, /* bitsize */
121 false, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_bitfield, /* complain_on_overflow */
124 0, /* special_function */
125 "32", /* name */
126 true, /* partial_inplace */
127 0xffffffff, /* src_mask */
128 0xffffffff, /* dst_mask */
129 false); /* pcrel_offset */
130
131/* Read a PowerPC NLM reloc. */
132
133static boolean
134nlm_powerpc_read_reloc (abfd, sym, secp, rel)
135 bfd *abfd;
136 nlmNAME(symbol_type) *sym;
137 asection **secp;
138 arelent *rel;
139{
140 bfd_byte temp[4];
141 bfd_vma val;
142 const char *name;
143
144 if (bfd_read (temp, sizeof (temp), 1, abfd) != sizeof (temp))
145 return false;
146
147 val = bfd_get_32 (abfd, temp);
148
149 /* The value is a word offset into either the code or data segment.
150 This is the location which needs to be adjusted.
151
152 The high bit is 0 if the value is an offset into the data
153 segment, or 1 if the value is an offset into the text segment.
154
155 If this is a relocation fixup rather than an imported symbol (the
156 sym argument is NULL), then the second most significant bit is 0
157 if the address of the data segment should be added to the
158 location addressed by the value, or 1 if the address of the text
159 segment should be added.
160
161 If this is an imported symbol, the second most significant bit is
162 not used and must be 0. */
163
164 if ((val & NLM_HIBIT) == 0)
165 name = NLM_INITIALIZED_DATA_NAME;
166 else
167 {
168 name = NLM_CODE_NAME;
169 val &=~ NLM_HIBIT;
170 }
171 *secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
172
173 if (sym == NULL)
174 {
175 if ((val & (NLM_HIBIT >> 1)) == 0)
176 name = NLM_INITIALIZED_DATA_NAME;
177 else
178 {
179 name = NLM_CODE_NAME;
180 val &=~ (NLM_HIBIT >> 1);
181 }
182 rel->sym_ptr_ptr = bfd_get_section_by_name (abfd, name)->symbol_ptr_ptr;
183 }
184
185 rel->howto = &nlm_powerpc_howto;
186
187 rel->address = val << 2;
188 rel->addend = 0;
189
190 return true;
191}
192
193#else /* OLDFORMAT */
194
195/* This reloc handling is only applicable to the old format. */
196
3af0f479
ILT		 197/* How to process the various reloc types. PowerPC NLMs use XCOFF
198 reloc types, and I have just copied the XCOFF reloc table here. */
199
200static reloc_howto_type nlm_powerpc_howto_table[] =
201{
202 /* Standard 32 bit relocation. */
203 HOWTO (0, /* type */
204 0, /* rightshift */
205 2, /* size (0 = byte, 1 = short, 2 = long) */
206 32, /* bitsize */
207 false, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_bitfield, /* complain_on_overflow */
210 0, /* special_function */
211 "R_POS", /* name */
212 true, /* partial_inplace */
213 0xffffffff, /* src_mask */
214 0xffffffff, /* dst_mask */
215 false), /* pcrel_offset */
216
217 /* 32 bit relocation, but store negative value. */
218 HOWTO (1, /* type */
219 0, /* rightshift */
220 -2, /* size (0 = byte, 1 = short, 2 = long) */
221 32, /* bitsize */
222 false, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_bitfield, /* complain_on_overflow */
225 0, /* special_function */
226 "R_NEG", /* name */
227 true, /* partial_inplace */
228 0xffffffff, /* src_mask */
229 0xffffffff, /* dst_mask */
230 false), /* pcrel_offset */
231
232 /* 32 bit PC relative relocation. */
233 HOWTO (2, /* type */
234 0, /* rightshift */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
236 32, /* bitsize */
237 true, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_signed, /* complain_on_overflow */
240 0, /* special_function */
241 "R_REL", /* name */
242 true, /* partial_inplace */
243 0xffffffff, /* src_mask */
244 0xffffffff, /* dst_mask */
245 false), /* pcrel_offset */
246
247 /* 16 bit TOC relative relocation. */
248 HOWTO (3, /* type */
249 0, /* rightshift */
250 1, /* size (0 = byte, 1 = short, 2 = long) */
251 16, /* bitsize */
252 false, /* pc_relative */
253 0, /* bitpos */
254 complain_overflow_signed, /* complain_on_overflow */
255 0, /* special_function */
256 "R_TOC", /* name */
257 true, /* partial_inplace */
258 0xffff, /* src_mask */
259 0xffff, /* dst_mask */
260 false), /* pcrel_offset */
261
262 /* I don't really know what this is. */
263 HOWTO (4, /* type */
264 1, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 32, /* bitsize */
267 false, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 0, /* special_function */
271 "R_RTB", /* name */
272 true, /* partial_inplace */
273 0xffffffff, /* src_mask */
274 0xffffffff, /* dst_mask */
275 false), /* pcrel_offset */
276
277 /* External TOC relative symbol. */
278 HOWTO (5, /* type */
279 0, /* rightshift */
280 2, /* size (0 = byte, 1 = short, 2 = long) */
281 16, /* bitsize */
282 false, /* pc_relative */
283 0, /* bitpos */
284 complain_overflow_bitfield, /* complain_on_overflow */
285 0, /* special_function */
286 "R_GL", /* name */
287 true, /* partial_inplace */
288 0xffff, /* src_mask */
289 0xffff, /* dst_mask */
290 false), /* pcrel_offset */
291
292 /* Local TOC relative symbol. */
293 HOWTO (6, /* type */
294 0, /* rightshift */
295 2, /* size (0 = byte, 1 = short, 2 = long) */
296 16, /* bitsize */
297 false, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_bitfield, /* complain_on_overflow */
300 0, /* special_function */
301 "R_TCL", /* name */
302 true, /* partial_inplace */
303 0xffff, /* src_mask */
304 0xffff, /* dst_mask */
305 false), /* pcrel_offset */
306
307 { 7 },
308
309 /* Non modifiable absolute branch. */
310 HOWTO (8, /* type */
311 0, /* rightshift */
312 2, /* size (0 = byte, 1 = short, 2 = long) */
313 26, /* bitsize */
314 false, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_bitfield, /* complain_on_overflow */
317 0, /* special_function */
318 "R_BA", /* name */
319 true, /* partial_inplace */
320 0x3fffffc, /* src_mask */
321 0x3fffffc, /* dst_mask */
322 false), /* pcrel_offset */
323
324 { 9 },
325
326 /* Non modifiable relative branch. */
327 HOWTO (0xa, /* type */
328 0, /* rightshift */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
330 26, /* bitsize */
331 true, /* pc_relative */
332 0, /* bitpos */
333 complain_overflow_signed, /* complain_on_overflow */
334 0, /* special_function */
335 "R_BR", /* name */
336 true, /* partial_inplace */
337 0x3fffffc, /* src_mask */
338 0x3fffffc, /* dst_mask */
339 false), /* pcrel_offset */
340
341 { 0xb },
342
343 /* Indirect load. */
344 HOWTO (0xc, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 false, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
351 0, /* special_function */
352 "R_RL", /* name */
353 true, /* partial_inplace */
354 0xffff, /* src_mask */
355 0xffff, /* dst_mask */
356 false), /* pcrel_offset */
357
358 /* Load address. */
359 HOWTO (0xd, /* type */
360 0, /* rightshift */
361 2, /* size (0 = byte, 1 = short, 2 = long) */
362 16, /* bitsize */
363 false, /* pc_relative */
364 0, /* bitpos */
365 complain_overflow_bitfield, /* complain_on_overflow */
366 0, /* special_function */
367 "R_RLA", /* name */
368 true, /* partial_inplace */
369 0xffff, /* src_mask */
370 0xffff, /* dst_mask */
371 false), /* pcrel_offset */
372
373 { 0xe },
374
375 /* Non-relocating reference. */
376 HOWTO (0xf, /* type */
377 0, /* rightshift */
378 2, /* size (0 = byte, 1 = short, 2 = long) */
379 32, /* bitsize */
380 false, /* pc_relative */
381 0, /* bitpos */
382 complain_overflow_bitfield, /* complain_on_overflow */
383 0, /* special_function */
384 "R_REF", /* name */
385 false, /* partial_inplace */
386 0, /* src_mask */
387 0, /* dst_mask */
388 false), /* pcrel_offset */
389
390 { 0x10 },
391 { 0x11 },
392
393 /* TOC relative indirect load. */
394 HOWTO (0x12, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 16, /* bitsize */
398 false, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_bitfield, /* complain_on_overflow */
401 0, /* special_function */
402 "R_TRL", /* name */
403 true, /* partial_inplace */
404 0xffff, /* src_mask */
405 0xffff, /* dst_mask */
406 false), /* pcrel_offset */
407
408 /* TOC relative load address. */
409 HOWTO (0x13, /* type */
410 0, /* rightshift */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
412 16, /* bitsize */
413 false, /* pc_relative */
414 0, /* bitpos */
415 complain_overflow_bitfield, /* complain_on_overflow */
416 0, /* special_function */
417 "R_TRLA", /* name */
418 true, /* partial_inplace */
419 0xffff, /* src_mask */
420 0xffff, /* dst_mask */
421 false), /* pcrel_offset */
422
423 /* Modifiable relative branch. */
424 HOWTO (0x14, /* type */
425 1, /* rightshift */
426 2, /* size (0 = byte, 1 = short, 2 = long) */
427 32, /* bitsize */
428 false, /* pc_relative */
429 0, /* bitpos */
430 complain_overflow_bitfield, /* complain_on_overflow */
431 0, /* special_function */
432 "R_RRTBI", /* name */
433 true, /* partial_inplace */
434 0xffffffff, /* src_mask */
435 0xffffffff, /* dst_mask */
436 false), /* pcrel_offset */
437
438 /* Modifiable absolute branch. */
439 HOWTO (0x15, /* type */
440 1, /* rightshift */
441 2, /* size (0 = byte, 1 = short, 2 = long) */
442 32, /* bitsize */
443 false, /* pc_relative */
444 0, /* bitpos */
445 complain_overflow_bitfield, /* complain_on_overflow */
446 0, /* special_function */
447 "R_RRTBA", /* name */
448 true, /* partial_inplace */
449 0xffffffff, /* src_mask */
450 0xffffffff, /* dst_mask */
451 false), /* pcrel_offset */
452
453 /* Modifiable call absolute indirect. */
454 HOWTO (0x16, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 16, /* bitsize */
458 false, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_bitfield, /* complain_on_overflow */
461 0, /* special_function */
462 "R_CAI", /* name */
463 true, /* partial_inplace */
464 0xffff, /* src_mask */
465 0xffff, /* dst_mask */
466 false), /* pcrel_offset */
467
468 /* Modifiable call relative. */
469 HOWTO (0x17, /* type */
470 0, /* rightshift */
471 2, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 false, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_bitfield, /* complain_on_overflow */
476 0, /* special_function */
477 "R_REL", /* name */
478 true, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 false), /* pcrel_offset */
482
483 /* Modifiable branch absolute. */
484 HOWTO (0x18, /* type */
485 0, /* rightshift */
486 2, /* size (0 = byte, 1 = short, 2 = long) */
487 16, /* bitsize */
488 false, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_bitfield, /* complain_on_overflow */
491 0, /* special_function */
492 "R_RBA", /* name */
493 true, /* partial_inplace */
494 0xffff, /* src_mask */
495 0xffff, /* dst_mask */
496 false), /* pcrel_offset */
497
498 /* Modifiable branch absolute. */
499 HOWTO (0x19, /* type */
500 0, /* rightshift */
501 2, /* size (0 = byte, 1 = short, 2 = long) */
502 16, /* bitsize */
503 false, /* pc_relative */
504 0, /* bitpos */
505 complain_overflow_bitfield, /* complain_on_overflow */
506 0, /* special_function */
507 "R_RBAC", /* name */
508 true, /* partial_inplace */
509 0xffff, /* src_mask */
510 0xffff, /* dst_mask */
511 false), /* pcrel_offset */
512
513 /* Modifiable branch relative. */
514 HOWTO (0x1a, /* type */
515 0, /* rightshift */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
517 26, /* bitsize */
518 false, /* pc_relative */
519 0, /* bitpos */
520 complain_overflow_signed, /* complain_on_overflow */
521 0, /* special_function */
522 "R_REL", /* name */
523 true, /* partial_inplace */
524 0xffff, /* src_mask */
525 0xffff, /* dst_mask */
526 false), /* pcrel_offset */
527
528 /* Modifiable branch absolute. */
529 HOWTO (0x1b, /* type */
530 0, /* rightshift */
531 2, /* size (0 = byte, 1 = short, 2 = long) */
532 16, /* bitsize */
533 false, /* pc_relative */
534 0, /* bitpos */
535 complain_overflow_bitfield, /* complain_on_overflow */
536 0, /* special_function */
537 "R_REL", /* name */
538 true, /* partial_inplace */
539 0xffff, /* src_mask */
540 0xffff, /* dst_mask */
541 false) /* pcrel_offset */
542};
543
544#define HOWTO_COUNT (sizeof nlm_powerpc_howto_table \
545 / sizeof nlm_powerpc_howto_table[0])
546
547/* Read a PowerPC NLM reloc. */
548
549static boolean
550nlm_powerpc_read_reloc (abfd, sym, secp, rel)
551 bfd *abfd;
552 nlmNAME(symbol_type) *sym;
553 asection **secp;
554 arelent *rel;
555{
556 struct nlm32_powerpc_external_reloc ext;
557 bfd_vma l_vaddr;
558 unsigned long l_symndx;
559 int l_rtype;
560 int l_rsecnm;
561 asection *code_sec, *data_sec, *bss_sec;
562
563 /* Read the reloc from the file. */
564 if (bfd_read (&ext, sizeof ext, 1, abfd) != sizeof ext)
4002f18a 565 return false;
3af0f479
ILT		 566
567 /* Swap in the fields. */
568 l_vaddr = bfd_h_get_32 (abfd, ext.l_vaddr);
569 l_symndx = bfd_h_get_32 (abfd, ext.l_symndx);
570 l_rtype = bfd_h_get_16 (abfd, ext.l_rtype);
571 l_rsecnm = bfd_h_get_16 (abfd, ext.l_rsecnm);
572
573 /* Get the sections now, for convenience. */
574 code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
575 data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
576 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
577
578 /* Work out the arelent fields. */
579 if (sym != NULL)
580 {
581 /* This is an import. sym_ptr_ptr is filled in by
582 nlm_canonicalize_reloc. */
583 rel->sym_ptr_ptr = NULL;
584 }
585 else
586 {
587 asection *sec;
588
589 if (l_symndx == 0)
590 sec = code_sec;
591 else if (l_symndx == 1)
592 sec = data_sec;
593 else if (l_symndx == 2)
594 sec = bss_sec;
595 else
596 {
597 bfd_set_error (bfd_error_bad_value);
598 return false;
599 }
600
601 rel->sym_ptr_ptr = sec->symbol_ptr_ptr;
602 }
603
604 rel->addend = 0;
605
606 BFD_ASSERT ((l_rtype & 0xff) < HOWTO_COUNT);
607
608 rel->howto = nlm_powerpc_howto_table + (l_rtype & 0xff);
609
610 BFD_ASSERT (rel->howto->name != NULL
611 && ((l_rtype & 0x8000) != 0
612 ? (rel->howto->complain_on_overflow
613 == complain_overflow_signed)
614 : (rel->howto->complain_on_overflow
615 == complain_overflow_bitfield))
616 && ((l_rtype >> 8) & 0x1f) == rel->howto->bitsize - 1);
617
618 if (l_rsecnm == 0)
619 *secp = code_sec;
620 else if (l_rsecnm == 1)
621 {
622 *secp = data_sec;
623 l_vaddr -= bfd_section_size (abfd, code_sec);
624 }
625 else
626 {
627 bfd_set_error (bfd_error_bad_value);
628 return false;
629 }
630
631 rel->address = l_vaddr;
632
633 return true;
634}
635
476d01f0
ILT		 636#endif /* OLDFORMAT */
637
3af0f479
ILT		 638/* Mangle PowerPC NLM relocs for output. */
639
640static boolean
641nlm_powerpc_mangle_relocs (abfd, sec, data, offset, count)
642 bfd *abfd;
643 asection *sec;
644 PTR data;
645 bfd_vma offset;
646 bfd_size_type count;
647{
648 return true;
649}
650
651/* Read a PowerPC NLM import record */
652
653static boolean
654nlm_powerpc_read_import (abfd, sym)
655 bfd *abfd;
656 nlmNAME(symbol_type) *sym;
657{
658 struct nlm_relent *nlm_relocs; /* relocation records for symbol */
659 bfd_size_type rcount; /* number of relocs */
660 bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
661 unsigned char symlength; /* length of symbol name */
662 char *name;
663
664 if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
665 != sizeof (symlength))
4002f18a 666 return (false);
3af0f479
ILT		 667 sym -> symbol.the_bfd = abfd;
668 name = bfd_alloc (abfd, symlength + 1);
669 if (name == NULL)
670 {
671 bfd_set_error (bfd_error_no_memory);
672 return false;
673 }
674 if (bfd_read (name, symlength, 1, abfd) != symlength)
4002f18a 675 return (false);
3af0f479
ILT		 676 name[symlength] = '\0';
677 sym -> symbol.name = name;
678 sym -> symbol.flags = 0;
679 sym -> symbol.value = 0;
680 sym -> symbol.section = &bfd_und_section;
681 if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
4002f18a 682 return (false);
3af0f479
ILT		 683 rcount = bfd_h_get_32 (abfd, temp);
684 nlm_relocs = ((struct nlm_relent *)
685 bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
686 if (nlm_relocs == (struct nlm_relent *) NULL)
687 {
688 bfd_set_error (bfd_error_no_memory);
689 return false;
690 }
691 sym -> relocs = nlm_relocs;
692 sym -> rcnt = 0;
693 while (sym -> rcnt < rcount)
694 {
695 asection *section;
696
697 if (nlm_powerpc_read_reloc (abfd, sym, &section,
698 &nlm_relocs -> reloc)
699 == false)
700 return false;
701 nlm_relocs -> section = section;
702 nlm_relocs++;
703 sym -> rcnt++;
704 }
705 return true;
706}
707
476d01f0
ILT		 708#ifndef OLDFORMAT
709
710/* Write a PowerPC NLM reloc. */
711
712static boolean
713nlm_powerpc_write_import (abfd, sec, rel)
714 bfd *abfd;
715 asection *sec;
716 arelent *rel;
717{
718 asymbol *sym;
719 bfd_vma val;
720 bfd_byte temp[4];
721
722 /* PowerPC NetWare only supports one kind of reloc. */
723 if (rel->addend != 0
724 || rel->howto == NULL
725 || rel->howto->rightshift != 0
726 || rel->howto->size != 2
727 || rel->howto->bitsize != 32
728 || rel->howto->bitpos != 0
729 || rel->howto->pc_relative
730 || (rel->howto->src_mask != 0xffffffff && rel->addend != 0)
731 || rel->howto->dst_mask != 0xffffffff)
732 {
733 bfd_set_error (bfd_error_invalid_operation);
734 return false;
735 }
736
737 sym = *rel->sym_ptr_ptr;
738
739 /* The value we write out is the offset into the appropriate
740 segment, rightshifted by two. This offset is the section vma,
741 adjusted by the vma of the lowest section in that segment, plus
742 the address of the relocation. */
743 val = bfd_get_section_vma (abfd, sec) + rel->address;
744 if ((val & 3) != 0)
745 {
746 bfd_set_error (bfd_error_bad_value);
747 return false;
748 }
749 val >>= 2;
750
751 /* The high bit is 0 if the reloc is in the data section, or 1 if
752 the reloc is in the code section. */
753 if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
754 val -= nlm_get_data_low (abfd);
755 else
756 {
757 val -= nlm_get_text_low (abfd);
758 val |= NLM_HIBIT;
759 }
760
761 if (bfd_get_section (sym) != &bfd_und_section)
762 {
763 /* This is an internal relocation fixup. The second most
764 significant bit is 0 if this is a reloc against the data
765 segment, or 1 if it is a reloc against the text segment. */
766 if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
767 val |= NLM_HIBIT >> 1;
768 }
769
770 bfd_put_32 (abfd, val, temp);
771 if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
772 return false;
773
774 return true;
775}
776
777#else /* OLDFORMAT */
778
779/* This is used for the reloc handling in the old format. */
780
3af0f479
ILT		 781/* Write a PowerPC NLM reloc. */
782
783static boolean
784nlm_powerpc_write_reloc (abfd, sec, rel, indx)
785 bfd *abfd;
786 asection *sec;
787 arelent *rel;
788 int indx;
789{
790 struct nlm32_powerpc_external_reloc ext;
791 asection *code_sec, *data_sec, *bss_sec;
792 asymbol *sym;
793 asection *symsec;
794 unsigned long l_symndx;
795 int l_rtype;
796 int l_rsecnm;
797 const reloc_howto_type *howto;
798 bfd_size_type address;
799
800 /* Get the sections now, for convenience. */
801 code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
802 data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
803 bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
804
805 sym = *rel->sym_ptr_ptr;
806 symsec = bfd_get_section (sym);
807 if (indx != -1)
808 {
809 BFD_ASSERT (symsec == &bfd_und_section);
810 l_symndx = indx + 3;
811 }
812 else
813 {
814 if (symsec == code_sec)
815 l_symndx = 0;
816 else if (symsec == data_sec)
817 l_symndx = 1;
818 else if (symsec == bss_sec)
819 l_symndx = 2;
820 else
821 {
822 bfd_set_error (bfd_error_bad_value);
823 return false;
824 }
825 }
826
827 bfd_h_put_32 (abfd, (bfd_vma) l_symndx, ext.l_symndx);
828
829 for (howto = nlm_powerpc_howto_table;
830 howto < nlm_powerpc_howto_table + HOWTO_COUNT;
831 howto++)
832 {
833 if (howto->rightshift == rel->howto->rightshift
834 && howto->size == rel->howto->size
835 && howto->bitsize == rel->howto->bitsize
836 && howto->pc_relative == rel->howto->pc_relative
837 && howto->bitpos == rel->howto->bitpos
838 && (howto->partial_inplace == rel->howto->partial_inplace
839 || (! rel->howto->partial_inplace
840 && rel->addend == 0))
841 && (howto->src_mask == rel->howto->src_mask
842 || (rel->howto->src_mask == 0
843 && rel->addend == 0))
844 && howto->dst_mask == rel->howto->dst_mask
845 && howto->pcrel_offset == rel->howto->pcrel_offset)
846 break;
847 }
848 if (howto >= nlm_powerpc_howto_table + HOWTO_COUNT)
849 {
850 bfd_set_error (bfd_error_bad_value);
851 return false;
852 }
853
854 l_rtype = howto->type;
855 if (howto->complain_on_overflow == complain_overflow_signed)
856 l_rtype |= 0x8000;
857 l_rtype |= (howto->bitsize - 1) << 8;
858 bfd_h_put_16 (abfd, (bfd_vma) l_rtype, ext.l_rtype);
859
860 address = rel->address;
861
862 if (sec == code_sec)
863 l_rsecnm = 0;
864 else if (sec == data_sec)
865 {
866 l_rsecnm = 1;
867 address += bfd_section_size (abfd, code_sec);
868 }
869 else
870 {
871 bfd_set_error (bfd_error_bad_value);
872 return false;
873 }
874
875 bfd_h_put_16 (abfd, (bfd_vma) l_rsecnm, ext.l_rsecnm);
876 bfd_h_put_32 (abfd, (bfd_vma) address, ext.l_vaddr);
877
878 if (bfd_write (&ext, sizeof ext, 1, abfd) != sizeof ext)
879 return false;
880
881 return true;
882}
883
884/* Write a PowerPC NLM import. */
885
886static boolean
887nlm_powerpc_write_import (abfd, sec, rel)
888 bfd *abfd;
889 asection *sec;
890 arelent *rel;
891{
892 return nlm_powerpc_write_reloc (abfd, sec, rel, -1);
893}
894
476d01f0
ILT		 895#endif /* OLDFORMAT */
896
3af0f479
ILT		 897/* Write a PowerPC NLM external symbol. This routine keeps a static
898 count of the symbol index. FIXME: I don't know if this is
899 necessary, and the index never gets reset. */
900
901static boolean
902nlm_powerpc_write_external (abfd, count, sym, relocs)
903 bfd *abfd;
904 bfd_size_type count;
905 asymbol *sym;
906 struct reloc_and_sec *relocs;
907{
908 int i;
909 bfd_byte len;
910 unsigned char temp[NLM_TARGET_LONG_SIZE];
476d01f0 911#ifdef OLDFORMAT
3af0f479 912 static int indx;
476d01f0 913#endif
3af0f479
ILT		 914
915 len = strlen (sym->name);
916 if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
917 || bfd_write (sym->name, len, 1, abfd) != len)
4002f18a 918 return false;
3af0f479
ILT		 919
920 bfd_put_32 (abfd, count, temp);
921 if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
4002f18a 922 return false;
3af0f479
ILT		 923
924 for (i = 0; i < count; i++)
925 {
476d01f0
ILT		 926#ifndef OLDFORMAT
927 if (! nlm_powerpc_write_import (abfd, relocs[i].sec, relocs[i].rel))
3af0f479 928 return false;
476d01f0
ILT		 929#else
930 if (! nlm_powerpc_write_reloc (abfd, relocs[i].sec,
931 relocs[i].rel, indx))
932 return false;
933#endif
3af0f479
ILT		 934 }
935
476d01f0 936#ifdef OLDFORMAT
3af0f479 937 ++indx;
476d01f0 938#endif
3af0f479
ILT		 939
940 return true;
941}
476d01f0
ILT		 942\f
943#ifndef OLDFORMAT
3af0f479 944
476d01f0
ILT		 945/* PowerPC Netware uses a word offset, not a byte offset, for public
946 symbols. */
947
948/* Set the section for a public symbol. */
949
950static boolean
951nlm_powerpc_set_public_section (abfd, sym)
952 bfd *abfd;
953 nlmNAME(symbol_type) *sym;
954{
955 if (sym->symbol.value & NLM_HIBIT)
956 {
957 sym->symbol.value &= ~NLM_HIBIT;
958 sym->symbol.flags |= BSF_FUNCTION;
959 sym->symbol.section =
960 bfd_get_section_by_name (abfd, NLM_CODE_NAME);
961 }
962 else
963 {
964 sym->symbol.section =
965 bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
966 }
967
968 sym->symbol.value <<= 2;
969
970 return true;
971}
972
973/* Get the offset to write out for a public symbol. */
974
975static bfd_vma
976nlm_powerpc_get_public_offset (abfd, sym)
977 bfd *abfd;
978 asymbol *sym;
979{
980 bfd_vma offset;
981 asection *sec;
982
983 offset = bfd_asymbol_value (sym);
984 sec = bfd_get_section (sym);
985 if (sec->flags & SEC_CODE)
986 {
987 offset -= nlm_get_text_low (abfd);
988 offset |= NLM_HIBIT;
989 }
990 else if (sec->flags & (SEC_DATA | SEC_ALLOC))
991 {
992 /* SEC_ALLOC is for the .bss section. */
993 offset -= nlm_get_data_low (abfd);
994 }
995 else
996 {
997 /* We can't handle an exported symbol that is not in the code or
998 data segment. */
999 bfd_set_error (bfd_error_invalid_operation);
1000 /* FIXME: No way to return error. */
1001 abort ();
1002 }
1003
1004 return offset;
1005}
1006
1007#endif /* ! defined (OLDFORMAT) */
1008\f
3af0f479
ILT		 1009#include "nlmswap.h"
1010
1011static const struct nlm_backend_data nlm32_powerpc_backend =
1012{
1013 "NetWare PowerPC Module \032",
1014 sizeof (Nlm32_powerpc_External_Fixed_Header),
476d01f0
ILT		 1015#ifndef OLDFORMAT
1016 0, /* optional_prefix_size */
1017#else
3af0f479 1018 sizeof (struct nlm32_powerpc_external_prefix_header),
476d01f0 1019#endif
3af0f479
ILT		 1020 bfd_arch_powerpc,
1021 0,
1022 false,
476d01f0
ILT		 1023#ifndef OLDFORMAT
1024 0, /* backend_object_p */
1025 0, /* write_prefix */
1026#else
3af0f479
ILT		 1027 nlm_powerpc_backend_object_p,
1028 nlm_powerpc_write_prefix,
476d01f0 1029#endif
3af0f479
ILT		 1030 nlm_powerpc_read_reloc,
1031 nlm_powerpc_mangle_relocs,
1032 nlm_powerpc_read_import,
1033 nlm_powerpc_write_import,
476d01f0
ILT		 1034#ifndef OLDFORMAT
1035 nlm_powerpc_set_public_section,
1036 nlm_powerpc_get_public_offset,
1037#else
3af0f479
ILT		 1038 0, /* set_public_section */
1039 0, /* get_public_offset */
476d01f0 1040#endif
3af0f479
ILT		 1041 nlm_swap_fixed_header_in,
1042 nlm_swap_fixed_header_out,
1043 nlm_powerpc_write_external,
1044 0, /* write_export */
1045};
1046
1047#define TARGET_BIG_NAME "nlm32-powerpc"
1048#define TARGET_BIG_SYM nlmNAME(powerpc_vec)
1049#define TARGET_BACKEND_DATA &nlm32_powerpc_backend
1050
1051#include "nlm-target.h"
Empty description
This page took 0.379799 seconds and 4 git commands to generate.