1 /* Support for 32-bit Alpha NLM (NetWare Loadable Module)
2 Copyright 1993, 1994, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 /* This file describes the 32 bit Alpha NLM format. You might think
23 that an Alpha chip would use a 64 bit format, but, for some reason,
24 it doesn't. */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "libbfd.h"
29
30 #define ARCH_SIZE 32
31
32 #include "nlm/alpha-ext.h"
33 #define Nlm_External_Fixed_Header Nlm32_alpha_External_Fixed_Header
34
35 #include "libnlm.h"
36
37 static bfd_boolean nlm_alpha_backend_object_p
38 PARAMS ((bfd *));
39 static bfd_boolean nlm_alpha_write_prefix
40 PARAMS ((bfd *));
41 static bfd_boolean nlm_alpha_read_reloc
42 PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
43 static bfd_boolean nlm_alpha_mangle_relocs
44 PARAMS ((bfd *, asection *, const PTR, bfd_vma, bfd_size_type));
45 static bfd_boolean nlm_alpha_read_import
46 PARAMS ((bfd *, nlmNAME(symbol_type) *));
47 static bfd_boolean nlm_alpha_write_import
48 PARAMS ((bfd *, asection *, arelent *));
49 static bfd_boolean nlm_alpha_set_public_section
50 PARAMS ((bfd *, nlmNAME(symbol_type) *));
51 static bfd_vma nlm_alpha_get_public_offset
52 PARAMS ((bfd *, asymbol *));
53 static bfd_boolean nlm_alpha_write_external
54 PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));
55
56 /* Alpha NLM's have a prefix header before the standard NLM. This
57 function reads it in, verifies the version, and seeks the bfd to
58 the location before the regular NLM header. */
59
60 static bfd_boolean
nlm_alpha_backend_object_p(abfd)61 nlm_alpha_backend_object_p (abfd)
62 bfd *abfd;
63 {
64 struct nlm32_alpha_external_prefix_header s;
65 file_ptr size;
66
67 if (bfd_bread ((PTR) &s, (bfd_size_type) sizeof s, abfd) != sizeof s)
68 return FALSE;
69
70 if (H_GET_32 (abfd, s.magic) != NLM32_ALPHA_MAGIC)
71 return FALSE;
72
73 /* FIXME: Should we check the format number? */
74
75 /* Skip to the end of the header. */
76 size = H_GET_32 (abfd, s.size);
77 if (bfd_seek (abfd, size, SEEK_SET) != 0)
78 return FALSE;
79
80 return TRUE;
81 }
82
83 /* Write out the prefix. */
84
85 static bfd_boolean
nlm_alpha_write_prefix(abfd)86 nlm_alpha_write_prefix (abfd)
87 bfd *abfd;
88 {
89 struct nlm32_alpha_external_prefix_header s;
90
91 memset (&s, 0, sizeof s);
92 H_PUT_32 (abfd, NLM32_ALPHA_MAGIC, s.magic);
93 H_PUT_32 (abfd, 2, s.format);
94 H_PUT_32 (abfd, sizeof s, s.size);
95 if (bfd_bwrite ((PTR) &s, (bfd_size_type) sizeof s, abfd) != sizeof s)
96 return FALSE;
97 return TRUE;
98 }
99
100 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
101
102 /* How to process the various reloc types. */
103
104 static reloc_howto_type nlm32_alpha_howto_table[] =
105 {
106 /* Reloc type 0 is ignored by itself. However, it appears after a
107 GPDISP reloc to identify the location where the low order 16 bits
108 of the gp register are loaded. */
109 HOWTO (ALPHA_R_IGNORE, /* type */
110 0, /* rightshift */
111 0, /* size (0 = byte, 1 = short, 2 = long) */
112 8, /* bitsize */
113 FALSE, /* pc_relative */
114 0, /* bitpos */
115 complain_overflow_dont, /* complain_on_overflow */
116 0, /* special_function */
117 "IGNORE", /* name */
118 FALSE, /* partial_inplace */
119 0, /* src_mask */
120 0, /* dst_mask */
121 FALSE), /* pcrel_offset */
122
123 /* A 32 bit reference to a symbol. */
124 HOWTO (ALPHA_R_REFLONG, /* type */
125 0, /* rightshift */
126 2, /* size (0 = byte, 1 = short, 2 = long) */
127 32, /* bitsize */
128 FALSE, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_bitfield, /* complain_on_overflow */
131 0, /* special_function */
132 "REFLONG", /* name */
133 TRUE, /* partial_inplace */
134 0xffffffff, /* src_mask */
135 0xffffffff, /* dst_mask */
136 FALSE), /* pcrel_offset */
137
138 /* A 64 bit reference to a symbol. */
139 HOWTO (ALPHA_R_REFQUAD, /* type */
140 0, /* rightshift */
141 4, /* size (0 = byte, 1 = short, 2 = long) */
142 64, /* bitsize */
143 FALSE, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 0, /* special_function */
147 "REFQUAD", /* name */
148 TRUE, /* partial_inplace */
149 ONES (64), /* src_mask */
150 ONES (64), /* dst_mask */
151 FALSE), /* pcrel_offset */
152
153 /* A 32 bit GP relative offset. This is just like REFLONG except
154 that when the value is used the value of the gp register will be
155 added in. */
156 HOWTO (ALPHA_R_GPREL32, /* type */
157 0, /* rightshift */
158 2, /* size (0 = byte, 1 = short, 2 = long) */
159 32, /* bitsize */
160 FALSE, /* pc_relative */
161 0, /* bitpos */
162 complain_overflow_bitfield, /* complain_on_overflow */
163 0, /* special_function */
164 "GPREL32", /* name */
165 TRUE, /* partial_inplace */
166 0xffffffff, /* src_mask */
167 0xffffffff, /* dst_mask */
168 FALSE), /* pcrel_offset */
169
170 /* Used for an instruction that refers to memory off the GP
171 register. The offset is 16 bits of the 32 bit instruction. This
172 reloc always seems to be against the .lita section. */
173 HOWTO (ALPHA_R_LITERAL, /* type */
174 0, /* rightshift */
175 2, /* size (0 = byte, 1 = short, 2 = long) */
176 16, /* bitsize */
177 FALSE, /* pc_relative */
178 0, /* bitpos */
179 complain_overflow_signed, /* complain_on_overflow */
180 0, /* special_function */
181 "LITERAL", /* name */
182 TRUE, /* partial_inplace */
183 0xffff, /* src_mask */
184 0xffff, /* dst_mask */
185 FALSE), /* pcrel_offset */
186
187 /* This reloc only appears immediately following a LITERAL reloc.
188 It identifies a use of the literal. It seems that the linker can
189 use this to eliminate a portion of the .lita section. The symbol
190 index is special: 1 means the literal address is in the base
191 register of a memory format instruction; 2 means the literal
192 address is in the byte offset register of a byte-manipulation
193 instruction; 3 means the literal address is in the target
194 register of a jsr instruction. This does not actually do any
195 relocation. */
196 HOWTO (ALPHA_R_LITUSE, /* type */
197 0, /* rightshift */
198 2, /* size (0 = byte, 1 = short, 2 = long) */
199 32, /* bitsize */
200 FALSE, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_dont, /* complain_on_overflow */
203 0, /* special_function */
204 "LITUSE", /* name */
205 FALSE, /* partial_inplace */
206 0, /* src_mask */
207 0, /* dst_mask */
208 FALSE), /* pcrel_offset */
209
210 /* Load the gp register. This is always used for a ldah instruction
211 which loads the upper 16 bits of the gp register. The next reloc
212 will be an IGNORE reloc which identifies the location of the lda
213 instruction which loads the lower 16 bits. The symbol index of
214 the GPDISP instruction appears to actually be the number of bytes
215 between the ldah and lda instructions. This gives two different
216 ways to determine where the lda instruction is; I don't know why
217 both are used. The value to use for the relocation is the
218 difference between the GP value and the current location; the
219 load will always be done against a register holding the current
220 address. */
221 HOWTO (ALPHA_R_GPDISP, /* type */
222 16, /* rightshift */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
224 16, /* bitsize */
225 TRUE, /* pc_relative */
226 0, /* bitpos */
227 complain_overflow_dont, /* complain_on_overflow */
228 0, /* special_function */
229 "GPDISP", /* name */
230 TRUE, /* partial_inplace */
231 0xffff, /* src_mask */
232 0xffff, /* dst_mask */
233 TRUE), /* pcrel_offset */
234
235 /* A 21 bit branch. The native assembler generates these for
236 branches within the text segment, and also fills in the PC
237 relative offset in the instruction. It seems to me that this
238 reloc, unlike the others, is not partial_inplace. */
239 HOWTO (ALPHA_R_BRADDR, /* type */
240 2, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 21, /* bitsize */
243 TRUE, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_signed, /* complain_on_overflow */
246 0, /* special_function */
247 "BRADDR", /* name */
248 FALSE, /* partial_inplace */
249 0, /* src_mask */
250 0x1fffff, /* dst_mask */
251 FALSE), /* pcrel_offset */
252
253 /* A hint for a jump to a register. */
254 HOWTO (ALPHA_R_HINT, /* type */
255 2, /* rightshift */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
257 14, /* bitsize */
258 FALSE, /* pc_relative */
259 0, /* bitpos */
260 complain_overflow_dont, /* complain_on_overflow */
261 0, /* special_function */
262 "HINT", /* name */
263 TRUE, /* partial_inplace */
264 0x3fff, /* src_mask */
265 0x3fff, /* dst_mask */
266 FALSE), /* pcrel_offset */
267
268 /* 16 bit PC relative offset. */
269 HOWTO (ALPHA_R_SREL16, /* type */
270 0, /* rightshift */
271 1, /* size (0 = byte, 1 = short, 2 = long) */
272 16, /* bitsize */
273 TRUE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_signed, /* complain_on_overflow */
276 0, /* special_function */
277 "SREL16", /* name */
278 TRUE, /* partial_inplace */
279 0xffff, /* src_mask */
280 0xffff, /* dst_mask */
281 FALSE), /* pcrel_offset */
282
283 /* 32 bit PC relative offset. */
284 HOWTO (ALPHA_R_SREL32, /* type */
285 0, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 32, /* bitsize */
288 TRUE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_signed, /* complain_on_overflow */
291 0, /* special_function */
292 "SREL32", /* name */
293 TRUE, /* partial_inplace */
294 0xffffffff, /* src_mask */
295 0xffffffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* A 64 bit PC relative offset. */
299 HOWTO (ALPHA_R_SREL64, /* type */
300 0, /* rightshift */
301 4, /* size (0 = byte, 1 = short, 2 = long) */
302 64, /* bitsize */
303 TRUE, /* pc_relative */
304 0, /* bitpos */
305 complain_overflow_signed, /* complain_on_overflow */
306 0, /* special_function */
307 "SREL64", /* name */
308 TRUE, /* partial_inplace */
309 ONES (64), /* src_mask */
310 ONES (64), /* dst_mask */
311 FALSE), /* pcrel_offset */
312
313 /* Push a value on the reloc evaluation stack. */
314 HOWTO (ALPHA_R_OP_PUSH, /* type */
315 0, /* rightshift */
316 0, /* size (0 = byte, 1 = short, 2 = long) */
317 0, /* bitsize */
318 FALSE, /* pc_relative */
319 0, /* bitpos */
320 complain_overflow_dont, /* complain_on_overflow */
321 0, /* special_function */
322 "OP_PUSH", /* name */
323 FALSE, /* partial_inplace */
324 0, /* src_mask */
325 0, /* dst_mask */
326 FALSE), /* pcrel_offset */
327
328 /* Store the value from the stack at the given address. Store it in
329 a bitfield of size r_size starting at bit position r_offset. */
330 HOWTO (ALPHA_R_OP_STORE, /* type */
331 0, /* rightshift */
332 4, /* size (0 = byte, 1 = short, 2 = long) */
333 64, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_dont, /* complain_on_overflow */
337 0, /* special_function */
338 "OP_STORE", /* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 ONES (64), /* dst_mask */
342 FALSE), /* pcrel_offset */
343
344 /* Subtract the reloc address from the value on the top of the
345 relocation stack. */
346 HOWTO (ALPHA_R_OP_PSUB, /* type */
347 0, /* rightshift */
348 0, /* size (0 = byte, 1 = short, 2 = long) */
349 0, /* bitsize */
350 FALSE, /* pc_relative */
351 0, /* bitpos */
352 complain_overflow_dont, /* complain_on_overflow */
353 0, /* special_function */
354 "OP_PSUB", /* name */
355 FALSE, /* partial_inplace */
356 0, /* src_mask */
357 0, /* dst_mask */
358 FALSE), /* pcrel_offset */
359
360 /* Shift the value on the top of the relocation stack right by the
361 given value. */
362 HOWTO (ALPHA_R_OP_PRSHIFT, /* type */
363 0, /* rightshift */
364 0, /* size (0 = byte, 1 = short, 2 = long) */
365 0, /* bitsize */
366 FALSE, /* pc_relative */
367 0, /* bitpos */
368 complain_overflow_dont, /* complain_on_overflow */
369 0, /* special_function */
370 "OP_PRSHIFT", /* name */
371 FALSE, /* partial_inplace */
372 0, /* src_mask */
373 0, /* dst_mask */
374 FALSE), /* pcrel_offset */
375
376 /* Adjust the GP value for a new range in the object file. */
377 HOWTO (ALPHA_R_GPVALUE, /* type */
378 0, /* rightshift */
379 0, /* size (0 = byte, 1 = short, 2 = long) */
380 0, /* bitsize */
381 FALSE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_dont, /* complain_on_overflow */
384 0, /* special_function */
385 "GPVALUE", /* name */
386 FALSE, /* partial_inplace */
387 0, /* src_mask */
388 0, /* dst_mask */
389 FALSE) /* pcrel_offset */
390 };
391
392 static reloc_howto_type nlm32_alpha_nw_howto =
393 HOWTO (ALPHA_R_NW_RELOC, /* type */
394 0, /* rightshift */
395 0, /* size (0 = byte, 1 = short, 2 = long) */
396 0, /* bitsize */
397 FALSE, /* pc_relative */
398 0, /* bitpos */
399 complain_overflow_dont, /* complain_on_overflow */
400 0, /* special_function */
401 "NW_RELOC", /* name */
402 FALSE, /* partial_inplace */
403 0, /* src_mask */
404 0, /* dst_mask */
405 FALSE); /* pcrel_offset */
406
407 /* Read an Alpha NLM reloc. This routine keeps some static data which
408 it uses when handling local relocs. This only works correctly
409 because all the local relocs are read at once. */
410
411 static bfd_boolean
nlm_alpha_read_reloc(abfd,sym,secp,rel)412 nlm_alpha_read_reloc (abfd, sym, secp, rel)
413 bfd *abfd;
414 nlmNAME(symbol_type) *sym;
415 asection **secp;
416 arelent *rel;
417 {
418 static bfd_vma gp_value;
419 static bfd_vma lita_address;
420 struct nlm32_alpha_external_reloc ext;
421 bfd_vma r_vaddr;
422 long r_symndx;
423 int r_type, r_extern, r_offset, r_size;
424 asection *code_sec, *data_sec;
425
426 /* Read the reloc from the file. */
427 if (bfd_bread (&ext, (bfd_size_type) sizeof ext, abfd) != sizeof ext)
428 return FALSE;
429
430 /* Swap in the reloc information. */
431 r_vaddr = H_GET_64 (abfd, ext.r_vaddr);
432 r_symndx = H_GET_32 (abfd, ext.r_symndx);
433
434 BFD_ASSERT (bfd_little_endian (abfd));
435
436 r_type = ((ext.r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
437 >> RELOC_BITS0_TYPE_SH_LITTLE);
438 r_extern = (ext.r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
439 r_offset = ((ext.r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
440 >> RELOC_BITS1_OFFSET_SH_LITTLE);
441 /* Ignore the reserved bits. */
442 r_size = ((ext.r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
443 >> RELOC_BITS3_SIZE_SH_LITTLE);
444
445 /* Fill in the BFD arelent structure. */
446 code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
447 data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
448 if (r_extern)
449 {
450 /* External relocations are only used for imports. */
451 BFD_ASSERT (sym != NULL);
452 /* We don't need to set sym_ptr_ptr for this case. It is set in
453 nlm_canonicalize_reloc. */
454 rel->sym_ptr_ptr = NULL;
455 rel->addend = 0;
456 }
457 else
458 {
459 /* Internal relocations are only used for local relocation
460 fixups. If they are not NW_RELOC or GPDISP or IGNORE, they
461 must be against .text or .data. */
462 BFD_ASSERT (r_type == ALPHA_R_NW_RELOC || sym == NULL);
463 if (r_type == ALPHA_R_NW_RELOC
464 || r_type == ALPHA_R_GPDISP
465 || r_type == ALPHA_R_IGNORE)
466 {
467 rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
468 rel->addend = 0;
469 }
470 else if (r_symndx == ALPHA_RELOC_SECTION_TEXT)
471 {
472 rel->sym_ptr_ptr = code_sec->symbol_ptr_ptr;
473 BFD_ASSERT (bfd_get_section_vma (abfd, code_sec) == 0);
474 rel->addend = 0;
475 }
476 else if (r_symndx == ALPHA_RELOC_SECTION_DATA)
477 {
478 rel->sym_ptr_ptr = data_sec->symbol_ptr_ptr;
479 rel->addend = - bfd_get_section_vma (abfd, data_sec);
480 }
481 else
482 {
483 BFD_ASSERT (0);
484 rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
485 rel->addend = 0;
486 }
487 }
488
489 /* We use the address to determine whether the reloc is in the .text
490 or .data section. R_NW_RELOC relocs don't really have a section,
491 so we put them in .text. */
492 if (r_type == ALPHA_R_NW_RELOC
493 || r_vaddr < bfd_section_size (abfd, code_sec))
494 {
495 *secp = code_sec;
496 rel->address = r_vaddr;
497 }
498 else
499 {
500 *secp = data_sec;
501 rel->address = r_vaddr - bfd_section_size (abfd, code_sec);
502 }
503
504 /* We must adjust the addend based on the type. */
505 BFD_ASSERT ((r_type >= 0 && r_type <= ALPHA_R_GPVALUE)
506 || r_type == ALPHA_R_NW_RELOC);
507
508 switch (r_type)
509 {
510 case ALPHA_R_BRADDR:
511 case ALPHA_R_SREL16:
512 case ALPHA_R_SREL32:
513 case ALPHA_R_SREL64:
514 /* The PC relative relocs do not seem to use the section VMA as
515 a negative addend. */
516 rel->addend = 0;
517 break;
518
519 case ALPHA_R_GPREL32:
520 /* Copy the gp value for this object file into the addend, to
521 ensure that we are not confused by the linker. */
522 if (! r_extern)
523 rel->addend += gp_value;
524 break;
525
526 case ALPHA_R_LITERAL:
527 BFD_ASSERT (! r_extern);
528 rel->addend += lita_address;
529 break;
530
531 case ALPHA_R_LITUSE:
532 case ALPHA_R_GPDISP:
533 /* The LITUSE and GPDISP relocs do not use a symbol, or an
534 addend, but they do use a special code. Put this code in the
535 addend field. */
536 rel->addend = r_symndx;
537 rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
538 break;
539
540 case ALPHA_R_OP_STORE:
541 /* The STORE reloc needs the size and offset fields. We store
542 them in the addend. */
543 BFD_ASSERT (r_offset < 256 && r_size < 256);
544 rel->addend = (r_offset << 8) + r_size;
545 break;
546
547 case ALPHA_R_OP_PUSH:
548 case ALPHA_R_OP_PSUB:
549 case ALPHA_R_OP_PRSHIFT:
550 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
551 address. I believe that the address supplied is really an
552 addend. */
553 rel->addend = r_vaddr;
554 break;
555
556 case ALPHA_R_GPVALUE:
557 /* Record the new gp value. */
558 gp_value += r_symndx;
559 rel->addend = gp_value;
560 break;
561
562 case ALPHA_R_IGNORE:
563 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
564 to the absolute section so that the reloc is ignored. For
565 some reason the address of this reloc type is not adjusted by
566 the section vma. We record the gp value for this object file
567 here, for convenience when doing the GPDISP relocation. */
568 rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
569 rel->address = r_vaddr;
570 rel->addend = gp_value;
571 break;
572
573 case ALPHA_R_NW_RELOC:
574 /* If this is SETGP, we set the addend to 0. Otherwise we set
575 the addend to the size of the .lita section (this is
576 r_symndx) plus 1. We have already set the address of the
577 reloc to r_vaddr. */
578 if (r_size == ALPHA_R_NW_RELOC_SETGP)
579 {
580 gp_value = r_vaddr;
581 rel->addend = 0;
582 }
583 else if (r_size == ALPHA_R_NW_RELOC_LITA)
584 {
585 lita_address = r_vaddr;
586 rel->addend = r_symndx + 1;
587 }
588 else
589 BFD_ASSERT (0);
590 rel->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
591 break;
592
593 default:
594 break;
595 }
596
597 if (r_type == ALPHA_R_NW_RELOC)
598 rel->howto = &nlm32_alpha_nw_howto;
599 else
600 rel->howto = &nlm32_alpha_howto_table[r_type];
601
602 return TRUE;
603 }
604
605 /* Mangle Alpha NLM relocs for output. */
606
607 static bfd_boolean
nlm_alpha_mangle_relocs(abfd,sec,data,offset,count)608 nlm_alpha_mangle_relocs (abfd, sec, data, offset, count)
609 bfd *abfd ATTRIBUTE_UNUSED;
610 asection *sec ATTRIBUTE_UNUSED;
611 const PTR data ATTRIBUTE_UNUSED;
612 bfd_vma offset ATTRIBUTE_UNUSED;
613 bfd_size_type count ATTRIBUTE_UNUSED;
614 {
615 return TRUE;
616 }
617
618 /* Read an ALPHA NLM import record */
619
620 static bfd_boolean
nlm_alpha_read_import(abfd,sym)621 nlm_alpha_read_import (abfd, sym)
622 bfd *abfd;
623 nlmNAME(symbol_type) *sym;
624 {
625 struct nlm_relent *nlm_relocs; /* relocation records for symbol */
626 bfd_size_type rcount; /* number of relocs */
627 bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* temporary 32-bit value */
628 unsigned char symlength; /* length of symbol name */
629 char *name;
630 bfd_size_type amt;
631
632 if (bfd_bread ((PTR) &symlength, (bfd_size_type) sizeof (symlength), abfd)
633 != sizeof (symlength))
634 return FALSE;
635 sym -> symbol.the_bfd = abfd;
636 name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
637 if (name == NULL)
638 return FALSE;
639 if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
640 return FALSE;
641 name[symlength] = '\0';
642 sym -> symbol.name = name;
643 sym -> symbol.flags = 0;
644 sym -> symbol.value = 0;
645 sym -> symbol.section = bfd_und_section_ptr;
646 if (bfd_bread ((PTR) temp, (bfd_size_type) sizeof (temp), abfd)
647 != sizeof (temp))
648 return FALSE;
649 rcount = H_GET_32 (abfd, temp);
650 amt = rcount * sizeof (struct nlm_relent);
651 nlm_relocs = (struct nlm_relent *) bfd_alloc (abfd, amt);
652 if (!nlm_relocs)
653 return FALSE;
654 sym -> relocs = nlm_relocs;
655 sym -> rcnt = 0;
656 while (sym -> rcnt < rcount)
657 {
658 asection *section;
659
660 if (! nlm_alpha_read_reloc (abfd, sym, §ion, &nlm_relocs -> reloc))
661 return FALSE;
662 nlm_relocs -> section = section;
663 nlm_relocs++;
664 sym -> rcnt++;
665 }
666
667 return TRUE;
668 }
669
670 /* Write an Alpha NLM reloc. */
671
672 static bfd_boolean
nlm_alpha_write_import(abfd,sec,rel)673 nlm_alpha_write_import (abfd, sec, rel)
674 bfd *abfd;
675 asection *sec;
676 arelent *rel;
677 {
678 asymbol *sym;
679 bfd_vma r_vaddr;
680 long r_symndx;
681 int r_type, r_extern, r_offset, r_size;
682 struct nlm32_alpha_external_reloc ext;
683
684 sym = *rel->sym_ptr_ptr;
685
686 /* Get values for the relocation fields. */
687 r_type = rel->howto->type;
688 if (r_type != ALPHA_R_NW_RELOC)
689 {
690 r_vaddr = bfd_get_section_vma (abfd, sec) + rel->address;
691 if ((sec->flags & SEC_CODE) == 0)
692 r_vaddr += bfd_section_size (abfd,
693 bfd_get_section_by_name (abfd,
694 NLM_CODE_NAME));
695 if (bfd_is_und_section (bfd_get_section (sym)))
696 {
697 r_extern = 1;
698 r_symndx = 0;
699 }
700 else
701 {
702 r_extern = 0;
703 if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
704 r_symndx = ALPHA_RELOC_SECTION_TEXT;
705 else
706 r_symndx = ALPHA_RELOC_SECTION_DATA;
707 }
708 r_offset = 0;
709 r_size = 0;
710
711 switch (r_type)
712 {
713 case ALPHA_R_LITUSE:
714 case ALPHA_R_GPDISP:
715 r_symndx = rel->addend;
716 break;
717
718 case ALPHA_R_OP_STORE:
719 r_size = rel->addend & 0xff;
720 r_offset = (rel->addend >> 8) & 0xff;
721 break;
722
723 case ALPHA_R_OP_PUSH:
724 case ALPHA_R_OP_PSUB:
725 case ALPHA_R_OP_PRSHIFT:
726 r_vaddr = rel->addend;
727 break;
728
729 case ALPHA_R_IGNORE:
730 r_vaddr = rel->address;
731 break;
732
733 default:
734 break;
735 }
736 }
737 else
738 {
739 /* r_type == ALPHA_R_NW_RELOC */
740 r_vaddr = rel->address;
741 if (rel->addend == 0)
742 {
743 r_symndx = 0;
744 r_size = ALPHA_R_NW_RELOC_SETGP;
745 }
746 else
747 {
748 r_symndx = rel->addend - 1;
749 r_size = ALPHA_R_NW_RELOC_LITA;
750 }
751 r_extern = 0;
752 r_offset = 0;
753 }
754
755 /* Swap out the relocation fields. */
756 H_PUT_64 (abfd, r_vaddr, ext.r_vaddr);
757 H_PUT_32 (abfd, r_symndx, ext.r_symndx);
758
759 BFD_ASSERT (bfd_little_endian (abfd));
760
761 ext.r_bits[0] = ((r_type << RELOC_BITS0_TYPE_SH_LITTLE)
762 & RELOC_BITS0_TYPE_LITTLE);
763 ext.r_bits[1] = ((r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
764 | ((r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
765 & RELOC_BITS1_OFFSET_LITTLE));
766 ext.r_bits[2] = 0;
767 ext.r_bits[3] = ((r_size << RELOC_BITS3_SIZE_SH_LITTLE)
768 & RELOC_BITS3_SIZE_LITTLE);
769
770 /* Write out the relocation. */
771 if (bfd_bwrite (&ext, (bfd_size_type) sizeof ext, abfd) != sizeof ext)
772 return FALSE;
773
774 return TRUE;
775 }
776
777 /* Alpha NetWare does not use the high bit to determine whether a
778 public symbol is in the code segment or the data segment. Instead,
779 it just uses the address. The set_public_section and
780 get_public_offset routines override the default code which uses the
781 high bit. */
782
783 /* Set the section for a public symbol. */
784
785 static bfd_boolean
nlm_alpha_set_public_section(abfd,sym)786 nlm_alpha_set_public_section (abfd, sym)
787 bfd *abfd;
788 nlmNAME(symbol_type) *sym;
789 {
790 asection *code_sec, *data_sec;
791
792 code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
793 data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
794 if (sym->symbol.value < bfd_section_size (abfd, code_sec))
795 {
796 sym->symbol.section = code_sec;
797 sym->symbol.flags |= BSF_FUNCTION;
798 }
799 else
800 {
801 sym->symbol.section = data_sec;
802 sym->symbol.value -= bfd_section_size (abfd, code_sec);
803 /* The data segment had better be aligned. */
804 BFD_ASSERT ((bfd_section_size (abfd, code_sec) & 0xf) == 0);
805 }
806 return TRUE;
807 }
808
809 /* Get the offset to write out for a public symbol. */
810
811 static bfd_vma
nlm_alpha_get_public_offset(abfd,sym)812 nlm_alpha_get_public_offset (abfd, sym)
813 bfd *abfd ATTRIBUTE_UNUSED;
814 asymbol *sym;
815 {
816 return bfd_asymbol_value (sym);
817 }
818
819 /* Write an Alpha NLM external symbol. */
820
821 static bfd_boolean
nlm_alpha_write_external(abfd,count,sym,relocs)822 nlm_alpha_write_external (abfd, count, sym, relocs)
823 bfd *abfd;
824 bfd_size_type count;
825 asymbol *sym;
826 struct reloc_and_sec *relocs;
827 {
828 bfd_size_type i;
829 bfd_byte len;
830 unsigned char temp[NLM_TARGET_LONG_SIZE];
831 arelent r;
832
833 len = strlen (sym->name);
834 if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
835 != sizeof (bfd_byte))
836 || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
837 return FALSE;
838
839 bfd_put_32 (abfd, count + 2, temp);
840 if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
841 return FALSE;
842
843 /* The first two relocs for each external symbol are the .lita
844 address and the GP value. */
845 r.sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
846 r.howto = &nlm32_alpha_nw_howto;
847
848 r.address = nlm_alpha_backend_data (abfd)->lita_address;
849 r.addend = nlm_alpha_backend_data (abfd)->lita_size + 1;
850 if (! nlm_alpha_write_import (abfd, (asection *) NULL, &r))
851 return FALSE;
852
853 r.address = nlm_alpha_backend_data (abfd)->gp;
854 r.addend = 0;
855 if (! nlm_alpha_write_import (abfd, (asection *) NULL, &r))
856 return FALSE;
857
858 for (i = 0; i < count; i++)
859 {
860 if (! nlm_alpha_write_import (abfd, relocs[i].sec, relocs[i].rel))
861 return FALSE;
862 }
863
864 return TRUE;
865 }
866
867 #include "nlmswap.h"
868
869 static const struct nlm_backend_data nlm32_alpha_backend =
870 {
871 "NetWare Alpha Module \032",
872 sizeof (Nlm32_alpha_External_Fixed_Header),
873 sizeof (struct nlm32_alpha_external_prefix_header),
874 bfd_arch_alpha,
875 0,
876 TRUE, /* no uninitialized data permitted by Alpha NetWare. */
877 nlm_alpha_backend_object_p,
878 nlm_alpha_write_prefix,
879 nlm_alpha_read_reloc,
880 nlm_alpha_mangle_relocs,
881 nlm_alpha_read_import,
882 nlm_alpha_write_import,
883 nlm_alpha_set_public_section,
884 nlm_alpha_get_public_offset,
885 nlm_swap_fixed_header_in,
886 nlm_swap_fixed_header_out,
887 nlm_alpha_write_external,
888 0, /* write_export */
889 };
890
891 #define TARGET_LITTLE_NAME "nlm32-alpha"
892 #define TARGET_LITTLE_SYM nlmNAME(alpha_vec)
893 #define TARGET_BACKEND_DATA &nlm32_alpha_backend
894
895 #include "nlm-target.h"
896