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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [nlm32-ppc.c] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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