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