OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [nlm32-alpha.c] - Blame information for rev 156

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.