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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [bfd/] [elf32-crx.c] - Blame information for rev 271

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

Line No. Rev Author Line
1 205 julius 
/* BFD back-end for National Semiconductor's CRX ELF
2 
   Copyright 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
3 
   Written by Tomer Levi, NSC, Israel.
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 "sysdep.h"
23 
#include "bfd.h"
24 
#include "bfdlink.h"
25 
#include "libbfd.h"
26 
#include "elf-bfd.h"
27 
#include "elf/crx.h"
28 
 
29 
static reloc_howto_type *elf_crx_reloc_type_lookup
30 
  (bfd *, bfd_reloc_code_real_type);
31 
static void elf_crx_info_to_howto
32 
  (bfd *, arelent *, Elf_Internal_Rela *);
33 
static bfd_boolean elf32_crx_relax_delete_bytes
34 
  (struct bfd_link_info *, bfd *, asection *, bfd_vma, int);
35 
static bfd_reloc_status_type crx_elf_final_link_relocate
36 
  (reloc_howto_type *, bfd *, bfd *, asection *,
37 
   bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
38 
   struct bfd_link_info *, asection *, int);
39 
static bfd_boolean elf32_crx_relocate_section
40 
  (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
41 
   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
42 
static bfd_boolean elf32_crx_relax_section
43 
  (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
44 
static bfd_byte * elf32_crx_get_relocated_section_contents
45 
  (bfd *, struct bfd_link_info *, struct bfd_link_order *,
46 
   bfd_byte *, bfd_boolean, asymbol **);
47 
 
48 
/* crx_reloc_map array maps BFD relocation enum into a CRGAS relocation type.  */
49 
 
50 
struct crx_reloc_map
51 
{
52 
  bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum.  */
53 
  unsigned short crx_reloc_type;           /* CRX relocation type.  */
54 
};
55 
 
56 
static const struct crx_reloc_map crx_reloc_map[R_CRX_MAX] =
57 
{
58 
  {BFD_RELOC_NONE,          R_CRX_NONE},
59 
  {BFD_RELOC_CRX_REL4,      R_CRX_REL4},
60 
  {BFD_RELOC_CRX_REL8,      R_CRX_REL8},
61 
  {BFD_RELOC_CRX_REL8_CMP,  R_CRX_REL8_CMP},
62 
  {BFD_RELOC_CRX_REL16,     R_CRX_REL16},
63 
  {BFD_RELOC_CRX_REL24,     R_CRX_REL24},
64 
  {BFD_RELOC_CRX_REL32,     R_CRX_REL32},
65 
  {BFD_RELOC_CRX_REGREL12,  R_CRX_REGREL12},
66 
  {BFD_RELOC_CRX_REGREL22,  R_CRX_REGREL22},
67 
  {BFD_RELOC_CRX_REGREL28,  R_CRX_REGREL28},
68 
  {BFD_RELOC_CRX_REGREL32,  R_CRX_REGREL32},
69 
  {BFD_RELOC_CRX_ABS16,     R_CRX_ABS16},
70 
  {BFD_RELOC_CRX_ABS32,     R_CRX_ABS32},
71 
  {BFD_RELOC_CRX_NUM8,      R_CRX_NUM8},
72 
  {BFD_RELOC_CRX_NUM16,     R_CRX_NUM16},
73 
  {BFD_RELOC_CRX_NUM32,     R_CRX_NUM32},
74 
  {BFD_RELOC_CRX_IMM16,     R_CRX_IMM16},
75 
  {BFD_RELOC_CRX_IMM32,     R_CRX_IMM32},
76 
  {BFD_RELOC_CRX_SWITCH8,   R_CRX_SWITCH8},
77 
  {BFD_RELOC_CRX_SWITCH16,  R_CRX_SWITCH16},
78 
  {BFD_RELOC_CRX_SWITCH32,  R_CRX_SWITCH32}
79 
};
80 
 
81 
static reloc_howto_type crx_elf_howto_table[] =
82 
{
83 
  HOWTO (R_CRX_NONE,            /* type */
84 
         0,                      /* rightshift */
85 
         2,                     /* size */
86 
         32,                    /* bitsize */
87 
         FALSE,                 /* pc_relative */
88 
         0,                      /* bitpos */
89 
         complain_overflow_dont,/* complain_on_overflow */
90 
         bfd_elf_generic_reloc, /* special_function */
91 
         "R_CRX_NONE",          /* name */
92 
         FALSE,                 /* partial_inplace */
93 
         0,                      /* src_mask */
94 
         0,                      /* dst_mask */
95 
         FALSE),                /* pcrel_offset */
96 
 
97 
  HOWTO (R_CRX_REL4,            /* type */
98 
         1,                     /* rightshift */
99 
         0,                      /* size */
100 
         4,                     /* bitsize */
101 
         TRUE,                  /* pc_relative */
102 
         0,                      /* bitpos */
103 
         complain_overflow_bitfield,/* complain_on_overflow */
104 
         bfd_elf_generic_reloc, /* special_function */
105 
         "R_CRX_REL4",          /* name */
106 
         FALSE,                 /* partial_inplace */
107 
         0x0,                   /* src_mask */
108 
         0xf,                   /* dst_mask */
109 
         FALSE),                /* pcrel_offset */
110 
 
111 
  HOWTO (R_CRX_REL8,            /* type */
112 
         1,                     /* rightshift */
113 
         0,                      /* size */
114 
         8,                     /* bitsize */
115 
         TRUE,                  /* pc_relative */
116 
         0,                      /* bitpos */
117 
         complain_overflow_bitfield,/* complain_on_overflow */
118 
         bfd_elf_generic_reloc, /* special_function */
119 
         "R_CRX_REL8",          /* name */
120 
         FALSE,                 /* partial_inplace */
121 
         0x0,                   /* src_mask */
122 
         0xff,                  /* dst_mask */
123 
         FALSE),                /* pcrel_offset */
124 
 
125 
  HOWTO (R_CRX_REL8_CMP,        /* type */
126 
         1,                     /* rightshift */
127 
         0,                      /* size */
128 
         8,                     /* bitsize */
129 
         TRUE,                  /* pc_relative */
130 
         0,                      /* bitpos */
131 
         complain_overflow_bitfield,/* complain_on_overflow */
132 
         bfd_elf_generic_reloc, /* special_function */
133 
         "R_CRX_REL8_CMP",      /* name */
134 
         FALSE,                 /* partial_inplace */
135 
         0x0,                   /* src_mask */
136 
         0xff,                  /* dst_mask */
137 
         FALSE),                /* pcrel_offset */
138 
 
139 
  HOWTO (R_CRX_REL16,           /* type */
140 
         1,                     /* rightshift */
141 
         1,                     /* size */
142 
         16,                    /* bitsize */
143 
         TRUE,                  /* pc_relative */
144 
         0,                      /* bitpos */
145 
         complain_overflow_bitfield,/* complain_on_overflow */
146 
         bfd_elf_generic_reloc, /* special_function */
147 
         "R_CRX_REL16",         /* name */
148 
         FALSE,                 /* partial_inplace */
149 
         0x0,                   /* src_mask */
150 
         0xffff,                /* dst_mask */
151 
         FALSE),                /* pcrel_offset */
152 
 
153 
  HOWTO (R_CRX_REL24,           /* type */
154 
         1,                     /* rightshift */
155 
         2,                     /* size */
156 
         24,                    /* bitsize */
157 
         TRUE,                  /* pc_relative */
158 
         0,                      /* bitpos */
159 
         complain_overflow_bitfield,/* complain_on_overflow */
160 
         bfd_elf_generic_reloc, /* special_function */
161 
         "R_CRX_REL24",         /* name */
162 
         FALSE,                 /* partial_inplace */
163 
         0x0,                   /* src_mask */
164 
         0xffffff,              /* dst_mask */
165 
         FALSE),                /* pcrel_offset */
166 
 
167 
  HOWTO (R_CRX_REL32,           /* type */
168 
         1,                     /* rightshift */
169 
         2,                     /* size */
170 
         32,                    /* bitsize */
171 
         TRUE,                  /* pc_relative */
172 
         0,                      /* bitpos */
173 
         complain_overflow_bitfield,/* complain_on_overflow */
174 
         bfd_elf_generic_reloc, /* special_function */
175 
         "R_CRX_REL32",         /* name */
176 
         FALSE,                 /* partial_inplace */
177 
         0x0,                   /* src_mask */
178 
         0xffffffff,            /* dst_mask */
179 
         FALSE),                /* pcrel_offset */
180 
 
181 
  HOWTO (R_CRX_REGREL12,        /* type */
182 
         0,                      /* rightshift */
183 
         1,                     /* size */
184 
         12,                    /* bitsize */
185 
         FALSE,                 /* pc_relative */
186 
         0,                      /* bitpos */
187 
         complain_overflow_bitfield,/* complain_on_overflow */
188 
         bfd_elf_generic_reloc, /* special_function */
189 
         "R_CRX_REGREL12",      /* name */
190 
         FALSE,                 /* partial_inplace */
191 
         0x0,                   /* src_mask */
192 
         0xfff,                 /* dst_mask */
193 
         FALSE),                /* pcrel_offset */
194 
 
195 
  HOWTO (R_CRX_REGREL22,        /* type */
196 
         0,                      /* rightshift */
197 
         2,                     /* size */
198 
         22,                    /* bitsize */
199 
         FALSE,                 /* pc_relative */
200 
         0,                      /* bitpos */
201 
         complain_overflow_bitfield,/* complain_on_overflow */
202 
         bfd_elf_generic_reloc, /* special_function */
203 
         "R_CRX_REGREL22",      /* name */
204 
         FALSE,                 /* partial_inplace */
205 
         0x0,                   /* src_mask */
206 
         0x3fffff,              /* dst_mask */
207 
         FALSE),                /* pcrel_offset */
208 
 
209 
  HOWTO (R_CRX_REGREL28,        /* type */
210 
         0,                      /* rightshift */
211 
         2,                     /* size */
212 
         28,                    /* bitsize */
213 
         FALSE,                 /* pc_relative */
214 
         0,                      /* bitpos */
215 
         complain_overflow_bitfield,/* complain_on_overflow */
216 
         bfd_elf_generic_reloc, /* special_function */
217 
         "R_CRX_REGREL28",      /* name */
218 
         FALSE,                 /* partial_inplace */
219 
         0x0,                   /* src_mask */
220 
         0xfffffff,             /* dst_mask */
221 
         FALSE),                /* pcrel_offset */
222 
 
223 
  HOWTO (R_CRX_REGREL32,        /* type */
224 
         0,                      /* rightshift */
225 
         2,                     /* size */
226 
         32,                    /* bitsize */
227 
         FALSE,                 /* pc_relative */
228 
         0,                      /* bitpos */
229 
         complain_overflow_bitfield,/* complain_on_overflow */
230 
         bfd_elf_generic_reloc, /* special_function */
231 
         "R_CRX_REGREL32",      /* name */
232 
         FALSE,                 /* partial_inplace */
233 
         0x0,                   /* src_mask */
234 
         0xffffffff,            /* dst_mask */
235 
         FALSE),                /* pcrel_offset */
236 
 
237 
  HOWTO (R_CRX_ABS16,           /* type */
238 
         0,                      /* rightshift */
239 
         1,                     /* size */
240 
         16,                    /* bitsize */
241 
         FALSE,                 /* pc_relative */
242 
         0,                      /* bitpos */
243 
         complain_overflow_bitfield,/* complain_on_overflow */
244 
         bfd_elf_generic_reloc, /* special_function */
245 
         "R_CRX_ABS16",         /* name */
246 
         FALSE,                 /* partial_inplace */
247 
         0x0,                   /* src_mask */
248 
         0xffff,                /* dst_mask */
249 
         FALSE),                /* pcrel_offset */
250 
 
251 
  HOWTO (R_CRX_ABS32,           /* type */
252 
         0,                      /* rightshift */
253 
         2,                     /* size */
254 
         32,                    /* bitsize */
255 
         FALSE,                 /* pc_relative */
256 
         0,                      /* bitpos */
257 
         complain_overflow_bitfield,/* complain_on_overflow */
258 
         bfd_elf_generic_reloc, /* special_function */
259 
         "R_CRX_ABS32",         /* name */
260 
         FALSE,                 /* partial_inplace */
261 
         0x0,                   /* src_mask */
262 
         0xffffffff,            /* dst_mask */
263 
         FALSE),                /* pcrel_offset */
264 
 
265 
  HOWTO (R_CRX_NUM8,            /* type */
266 
         0,                      /* rightshift */
267 
         0,                      /* size */
268 
         8,                     /* bitsize */
269 
         FALSE,                 /* pc_relative */
270 
         0,                      /* bitpos */
271 
         complain_overflow_bitfield,/* complain_on_overflow */
272 
         bfd_elf_generic_reloc, /* special_function */
273 
         "R_CRX_NUM8",          /* name */
274 
         FALSE,                 /* partial_inplace */
275 
         0x0,                   /* src_mask */
276 
         0xff,                  /* dst_mask */
277 
         FALSE),                /* pcrel_offset */
278 
 
279 
  HOWTO (R_CRX_NUM16,           /* type */
280 
         0,                      /* rightshift */
281 
         1,                     /* size */
282 
         16,                    /* bitsize */
283 
         FALSE,                 /* pc_relative */
284 
         0,                      /* bitpos */
285 
         complain_overflow_bitfield,/* complain_on_overflow */
286 
         bfd_elf_generic_reloc, /* special_function */
287 
         "R_CRX_NUM16",         /* name */
288 
         FALSE,                 /* partial_inplace */
289 
         0x0,                   /* src_mask */
290 
         0xffff,                /* dst_mask */
291 
         FALSE),                /* pcrel_offset */
292 
 
293 
  HOWTO (R_CRX_NUM32,           /* type */
294 
         0,                      /* rightshift */
295 
         2,                     /* size */
296 
         32,                    /* bitsize */
297 
         FALSE,                 /* pc_relative */
298 
         0,                      /* bitpos */
299 
         complain_overflow_bitfield,/* complain_on_overflow */
300 
         bfd_elf_generic_reloc, /* special_function */
301 
         "R_CRX_NUM32",         /* name */
302 
         FALSE,                 /* partial_inplace */
303 
         0x0,                   /* src_mask */
304 
         0xffffffff,            /* dst_mask */
305 
         FALSE),                /* pcrel_offset */
306 
 
307 
  HOWTO (R_CRX_IMM16,           /* type */
308 
         0,                      /* rightshift */
309 
         1,                     /* size */
310 
         16,                    /* bitsize */
311 
         FALSE,                 /* pc_relative */
312 
         0,                      /* bitpos */
313 
         complain_overflow_bitfield,/* complain_on_overflow */
314 
         bfd_elf_generic_reloc, /* special_function */
315 
         "R_CRX_IMM16",         /* name */
316 
         FALSE,                 /* partial_inplace */
317 
         0x0,                   /* src_mask */
318 
         0xffff,                /* dst_mask */
319 
         FALSE),                /* pcrel_offset */
320 
 
321 
  HOWTO (R_CRX_IMM32,           /* type */
322 
         0,                      /* rightshift */
323 
         2,                     /* size */
324 
         32,                    /* bitsize */
325 
         FALSE,                 /* pc_relative */
326 
         0,                      /* bitpos */
327 
         complain_overflow_bitfield,/* complain_on_overflow */
328 
         bfd_elf_generic_reloc, /* special_function */
329 
         "R_CRX_IMM32",         /* name */
330 
         FALSE,                 /* partial_inplace */
331 
         0x0,                   /* src_mask */
332 
         0xffffffff,            /* dst_mask */
333 
         FALSE),                /* pcrel_offset */
334 
 
335 
  /* An 8 bit switch table entry.  This is generated for an expression
336 
     such as ``.byte L1 - L2''.  The offset holds the difference
337 
     between the reloc address and L2.  */
338 
  HOWTO (R_CRX_SWITCH8,         /* type */
339 
         0,                      /* rightshift */
340 
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
341 
         8,                     /* bitsize */
342 
         FALSE,                 /* pc_relative */
343 
         0,                      /* bitpos */
344 
         complain_overflow_unsigned, /* complain_on_overflow */
345 
         bfd_elf_generic_reloc, /* special_function */
346 
         "R_CRX_SWITCH8",       /* name */
347 
         FALSE,                 /* partial_inplace */
348 
         0x0,                   /* src_mask */
349 
         0xff,                  /* dst_mask */
350 
         TRUE),                 /* pcrel_offset */
351 
 
352 
  /* A 16 bit switch table entry.  This is generated for an expression
353 
     such as ``.word L1 - L2''.  The offset holds the difference
354 
     between the reloc address and L2.  */
355 
  HOWTO (R_CRX_SWITCH16,        /* type */
356 
         0,                      /* rightshift */
357 
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
358 
         16,                    /* bitsize */
359 
         FALSE,                 /* pc_relative */
360 
         0,                      /* bitpos */
361 
         complain_overflow_unsigned, /* complain_on_overflow */
362 
         bfd_elf_generic_reloc, /* special_function */
363 
         "R_CRX_SWITCH16",      /* name */
364 
         FALSE,                 /* partial_inplace */
365 
         0x0,                   /* src_mask */
366 
         0xffff,                /* dst_mask */
367 
         TRUE),                 /* pcrel_offset */
368 
 
369 
  /* A 32 bit switch table entry.  This is generated for an expression
370 
     such as ``.long L1 - L2''.  The offset holds the difference
371 
     between the reloc address and L2.  */
372 
  HOWTO (R_CRX_SWITCH32,        /* type */
373 
         0,                      /* rightshift */
374 
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
375 
         32,                    /* bitsize */
376 
         FALSE,                 /* pc_relative */
377 
         0,                      /* bitpos */
378 
         complain_overflow_unsigned, /* complain_on_overflow */
379 
         bfd_elf_generic_reloc, /* special_function */
380 
         "R_CRX_SWITCH32",      /* name */
381 
         FALSE,                 /* partial_inplace */
382 
         0x0,                   /* src_mask */
383 
         0xffffffff,            /* dst_mask */
384 
         TRUE)                  /* pcrel_offset */
385 
};
386 
 
387 
/* Retrieve a howto ptr using a BFD reloc_code.  */
388 
 
389 
static reloc_howto_type *
390 
elf_crx_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
391 
                           bfd_reloc_code_real_type code)
392 
{
393 
  unsigned int i;
394 
 
395 
  for (i = 0; i < R_CRX_MAX; i++)
396 
    if (code == crx_reloc_map[i].bfd_reloc_enum)
397 
      return &crx_elf_howto_table[crx_reloc_map[i].crx_reloc_type];
398 
 
399 
  printf ("This relocation Type is not supported -0x%x\n", code);
400 
  return 0;
401 
}
402 
 
403 
static reloc_howto_type *
404 
elf_crx_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
405 
                           const char *r_name)
406 
{
407 
  unsigned int i;
408 
 
409 
  for (i = 0;
410 
       i < sizeof (crx_elf_howto_table) / sizeof (crx_elf_howto_table[0]);
411 
       i++)
412 
    if (crx_elf_howto_table[i].name != NULL
413 
        && strcasecmp (crx_elf_howto_table[i].name, r_name) == 0)
414 
      return &crx_elf_howto_table[i];
415 
 
416 
  return NULL;
417 
}
418 
 
419 
/* Retrieve a howto ptr using an internal relocation entry.  */
420 
 
421 
static void
422 
elf_crx_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
423 
                       Elf_Internal_Rela *dst)
424 
{
425 
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
426 
  BFD_ASSERT (r_type < (unsigned int) R_CRX_MAX);
427 
  cache_ptr->howto = &crx_elf_howto_table[r_type];
428 
}
429 
 
430 
/* Perform a relocation as part of a final link.  */
431 
 
432 
static bfd_reloc_status_type
433 
crx_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
434 
                             bfd *output_bfd ATTRIBUTE_UNUSED,
435 
                             asection *input_section, bfd_byte *contents,
436 
                             bfd_vma offset, bfd_vma Rvalue, bfd_vma addend,
437 
                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
438 
                             asection *sec ATTRIBUTE_UNUSED,
439 
                             int is_local ATTRIBUTE_UNUSED)
440 
{
441 
  unsigned short r_type = howto->type;
442 
  bfd_byte *hit_data = contents + offset;
443 
  bfd_vma reloc_bits, check;
444 
 
445 
  switch (r_type)
446 
    {
447 
     case R_CRX_IMM16:
448 
     case R_CRX_IMM32:
449 
     case R_CRX_ABS16:
450 
     case R_CRX_ABS32:
451 
     case R_CRX_REL8_CMP:
452 
     case R_CRX_REL16:
453 
     case R_CRX_REL24:
454 
     case R_CRX_REL32:
455 
     case R_CRX_REGREL12:
456 
     case R_CRX_REGREL22:
457 
     case R_CRX_REGREL28:
458 
     case R_CRX_REGREL32:
459 
       /* 'hit_data' is relative to the start of the instruction, not the
460 
          relocation offset. Advance it to account for the exact offset.  */
461 
       hit_data += 2;
462 
       break;
463 
 
464 
     case R_CRX_REL4:
465 
       /* This relocation type is used only in 'Branch if Equal to 0'
466 
          instructions and requires special handling.  */
467 
       Rvalue -= 1;
468 
       break;
469 
 
470 
     case R_CRX_NONE:
471 
       return bfd_reloc_ok;
472 
       break;
473 
 
474 
     case R_CRX_SWITCH8:
475 
     case R_CRX_SWITCH16:
476 
     case R_CRX_SWITCH32:
477 
       /* We only care about the addend, where the difference between
478 
          expressions is kept.  */
479 
       Rvalue = 0;
480 
 
481 
     default:
482 
       break;
483 
    }
484 
 
485 
  if (howto->pc_relative)
486 
    {
487 
      /* Subtract the address of the section containing the location.  */
488 
      Rvalue -= (input_section->output_section->vma
489 
                 + input_section->output_offset);
490 
      /* Subtract the position of the location within the section.  */
491 
      Rvalue -= offset;
492 
    }
493 
 
494 
  /* Add in supplied addend.  */
495 
  Rvalue += addend;
496 
 
497 
  /* Complain if the bitfield overflows, whether it is considered
498 
     as signed or unsigned.  */
499 
  check = Rvalue >> howto->rightshift;
500 
 
501 
  /* Assumes two's complement.  This expression avoids
502 
     overflow if howto->bitsize is the number of bits in
503 
     bfd_vma.  */
504 
  reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
505 
 
506 
  if (((bfd_vma) check & ~reloc_bits) != 0
507 
      && (((bfd_vma) check & ~reloc_bits)
508 
          != (-(bfd_vma) 1 & ~reloc_bits)))
509 
    {
510 
      /* The above right shift is incorrect for a signed
511 
         value.  See if turning on the upper bits fixes the
512 
         overflow.  */
513 
      if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
514 
        {
515 
          check |= ((bfd_vma) - 1
516 
                    & ~((bfd_vma) - 1
517 
                        >> howto->rightshift));
518 
          if (((bfd_vma) check & ~reloc_bits)
519 
              != (-(bfd_vma) 1 & ~reloc_bits))
520 
            return bfd_reloc_overflow;
521 
        }
522 
      else
523 
        return bfd_reloc_overflow;
524 
    }
525 
 
526 
  /* Drop unwanted bits from the value we are relocating to.  */
527 
  Rvalue >>= (bfd_vma) howto->rightshift;
528 
 
529 
  /* Apply dst_mask to select only relocatable part of the insn.  */
530 
  Rvalue &= howto->dst_mask;
531 
 
532 
  switch (howto->size)
533 
    {
534 
     case 0:
535 
       if (r_type == R_CRX_REL4)
536 
         {
537 
           Rvalue <<= 4;
538 
           Rvalue |= (bfd_get_8 (input_bfd, hit_data) & 0x0f);
539 
         }
540 
 
541 
       bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
542 
       break;
543 
 
544 
     case 1:
545 
       if (r_type == R_CRX_REGREL12)
546 
         Rvalue |= (bfd_get_16 (input_bfd, hit_data) & 0xf000);
547 
 
548 
       bfd_put_16 (input_bfd, Rvalue, hit_data);
549 
       break;
550 
 
551 
     case 2:
552 
       if (r_type == R_CRX_REL24
553 
           || r_type == R_CRX_REGREL22
554 
           || r_type == R_CRX_REGREL28)
555 
         Rvalue |= (((bfd_get_16 (input_bfd, hit_data) << 16) |
556 
                      bfd_get_16 (input_bfd, hit_data + 2)) & ~howto->dst_mask);
557 
 
558 
       if (r_type == R_CRX_NUM32 || r_type == R_CRX_SWITCH32)
559 
         /* Relocation on DATA is purely little-endian, that is, for a
560 
            multi-byte datum, the lowest address in memory contains the
561 
            little end of the datum, that is, the least significant byte.
562 
            Therefore we use BFD's byte Putting functions.  */
563 
         bfd_put_32 (input_bfd, Rvalue, hit_data);
564 
       else
565 
         /* Relocation on INSTRUCTIONS is different : Instructions are
566 
            word-addressable, that is, each word itself is arranged according
567 
            to little-endian convention, whereas the words are arranged with
568 
            respect to one another in BIG ENDIAN fashion.
569 
            When there is an immediate value that spans a word boundary, it is
570 
            split in a big-endian way with respect to the words.  */
571 
         {
572 
           bfd_put_16 (input_bfd, (Rvalue >> 16) & 0xffff, hit_data);
573 
           bfd_put_16 (input_bfd, Rvalue & 0xffff, hit_data + 2);
574 
         }
575 
     break;
576 
 
577 
     default:
578 
       return bfd_reloc_notsupported;
579 
    }
580 
 
581 
  return bfd_reloc_ok;
582 
}
583 
 
584 
/* Delete some bytes from a section while relaxing.  */
585 
 
586 
static bfd_boolean
587 
elf32_crx_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
588 
                              asection *sec, bfd_vma addr, int count)
589 
{
590 
  Elf_Internal_Shdr *symtab_hdr;
591 
  unsigned int sec_shndx;
592 
  bfd_byte *contents;
593 
  Elf_Internal_Rela *irel, *irelend;
594 
  Elf_Internal_Rela *irelalign;
595 
  bfd_vma toaddr;
596 
  Elf_Internal_Sym *isym;
597 
  Elf_Internal_Sym *isymend;
598 
  struct elf_link_hash_entry **sym_hashes;
599 
  struct elf_link_hash_entry **end_hashes;
600 
  struct elf_link_hash_entry **start_hashes;
601 
  unsigned int symcount;
602 
 
603 
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
604 
 
605 
  contents = elf_section_data (sec)->this_hdr.contents;
606 
 
607 
  /* The deletion must stop at the next ALIGN reloc for an aligment
608 
     power larger than the number of bytes we are deleting.  */
609 
 
610 
  irelalign = NULL;
611 
  toaddr = sec->size;
612 
 
613 
  irel = elf_section_data (sec)->relocs;
614 
  irelend = irel + sec->reloc_count;
615 
 
616 
  /* Actually delete the bytes.  */
617 
  memmove (contents + addr, contents + addr + count,
618 
           (size_t) (toaddr - addr - count));
619 
  sec->size -= count;
620 
 
621 
  /* Adjust all the relocs.  */
622 
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
623 
    {
624 
      /* Get the new reloc address.  */
625 
      if ((irel->r_offset > addr
626 
           && irel->r_offset < toaddr))
627 
        irel->r_offset -= count;
628 
    }
629 
 
630 
  /* Adjust the local symbols defined in this section.  */
631 
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
632 
  isym = (Elf_Internal_Sym *) symtab_hdr->contents;
633 
  for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
634 
    {
635 
      if (isym->st_shndx == sec_shndx
636 
          && isym->st_value > addr
637 
          && isym->st_value < toaddr)
638 
        {
639 
          /* Adjust the addend of SWITCH relocations in this section,
640 
             which reference this local symbol.  */
641 
          for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
642 
            {
643 
              unsigned long r_symndx;
644 
              Elf_Internal_Sym *rsym;
645 
              bfd_vma addsym, subsym;
646 
 
647 
              /* Skip if not a SWITCH relocation.  */
648 
              if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH8
649 
                  && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH16
650 
                  && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH32)
651 
                  continue;
652 
 
653 
              r_symndx = ELF32_R_SYM (irel->r_info);
654 
              rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
655 
 
656 
              /* Skip if not the local adjusted symbol.  */
657 
              if (rsym != isym)
658 
                continue;
659 
 
660 
              addsym = isym->st_value;
661 
              subsym = addsym - irel->r_addend;
662 
 
663 
              /* Fix the addend only when -->> (addsym > addr >= subsym).  */
664 
              if (subsym <= addr)
665 
                irel->r_addend -= count;
666 
              else
667 
                continue;
668 
            }
669 
 
670 
          isym->st_value -= count;
671 
        }
672 
    }
673 
 
674 
  /* Now adjust the global symbols defined in this section.  */
675 
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
676 
              - symtab_hdr->sh_info);
677 
  sym_hashes = start_hashes = elf_sym_hashes (abfd);
678 
  end_hashes = sym_hashes + symcount;
679 
 
680 
  for (; sym_hashes < end_hashes; sym_hashes++)
681 
    {
682 
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
683 
 
684 
      /* The '--wrap SYMBOL' option is causing a pain when the object file,
685 
         containing the definition of __wrap_SYMBOL, includes a direct
686 
         call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
687 
         the same symbol (which is __wrap_SYMBOL), but still exist as two
688 
         different symbols in 'sym_hashes', we don't want to adjust
689 
         the global symbol __wrap_SYMBOL twice.
690 
         This check is only relevant when symbols are being wrapped.  */
691 
      if (link_info->wrap_hash != NULL)
692 
        {
693 
          struct elf_link_hash_entry **cur_sym_hashes;
694 
 
695 
          /* Loop only over the symbols whom been already checked.  */
696 
          for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
697 
               cur_sym_hashes++)
698 
            {
699 
              /* If the current symbol is identical to 'sym_hash', that means
700 
                 the symbol was already adjusted (or at least checked).  */
701 
              if (*cur_sym_hashes == sym_hash)
702 
                break;
703 
            }
704 
          /* Don't adjust the symbol again.  */
705 
          if (cur_sym_hashes < sym_hashes)
706 
            continue;
707 
        }
708 
 
709 
      if ((sym_hash->root.type == bfd_link_hash_defined
710 
           || sym_hash->root.type == bfd_link_hash_defweak)
711 
          && sym_hash->root.u.def.section == sec
712 
          && sym_hash->root.u.def.value > addr
713 
          && sym_hash->root.u.def.value < toaddr)
714 
        sym_hash->root.u.def.value -= count;
715 
    }
716 
 
717 
  return TRUE;
718 
}
719 
 
720 
/* This is a version of bfd_generic_get_relocated_section_contents
721 
   which uses elf32_crx_relocate_section.  */
722 
 
723 
static bfd_byte *
724 
elf32_crx_get_relocated_section_contents (bfd *output_bfd,
725 
                                          struct bfd_link_info *link_info,
726 
                                          struct bfd_link_order *link_order,
727 
                                          bfd_byte *data,
728 
                                          bfd_boolean relocatable,
729 
                                          asymbol **symbols)
730 
{
731 
  Elf_Internal_Shdr *symtab_hdr;
732 
  asection *input_section = link_order->u.indirect.section;
733 
  bfd *input_bfd = input_section->owner;
734 
  asection **sections = NULL;
735 
  Elf_Internal_Rela *internal_relocs = NULL;
736 
  Elf_Internal_Sym *isymbuf = NULL;
737 
 
738 
  /* We only need to handle the case of relaxing, or of having a
739 
     particular set of section contents, specially.  */
740 
  if (relocatable
741 
      || elf_section_data (input_section)->this_hdr.contents == NULL)
742 
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
743 
                                                       link_order, data,
744 
                                                       relocatable,
745 
                                                       symbols);
746 
 
747 
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
748 
 
749 
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
750 
          (size_t) input_section->size);
751 
 
752 
  if ((input_section->flags & SEC_RELOC) != 0
753 
      && input_section->reloc_count > 0)
754 
    {
755 
      Elf_Internal_Sym *isym;
756 
      Elf_Internal_Sym *isymend;
757 
      asection **secpp;
758 
      bfd_size_type amt;
759 
 
760 
      internal_relocs = (_bfd_elf_link_read_relocs
761 
                         (input_bfd, input_section, (PTR) NULL,
762 
                          (Elf_Internal_Rela *) NULL, FALSE));
763 
      if (internal_relocs == NULL)
764 
        goto error_return;
765 
 
766 
      if (symtab_hdr->sh_info != 0)
767 
        {
768 
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
769 
          if (isymbuf == NULL)
770 
            isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
771 
                                            symtab_hdr->sh_info, 0,
772 
                                            NULL, NULL, NULL);
773 
          if (isymbuf == NULL)
774 
            goto error_return;
775 
        }
776 
 
777 
      amt = symtab_hdr->sh_info;
778 
      amt *= sizeof (asection *);
779 
      sections = bfd_malloc (amt);
780 
      if (sections == NULL && amt != 0)
781 
        goto error_return;
782 
 
783 
      isymend = isymbuf + symtab_hdr->sh_info;
784 
      for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
785 
        {
786 
          asection *isec;
787 
 
788 
          if (isym->st_shndx == SHN_UNDEF)
789 
            isec = bfd_und_section_ptr;
790 
          else if (isym->st_shndx == SHN_ABS)
791 
            isec = bfd_abs_section_ptr;
792 
          else if (isym->st_shndx == SHN_COMMON)
793 
            isec = bfd_com_section_ptr;
794 
          else
795 
            isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
796 
 
797 
          *secpp = isec;
798 
        }
799 
 
800 
      if (! elf32_crx_relocate_section (output_bfd, link_info, input_bfd,
801 
                                     input_section, data, internal_relocs,
802 
                                     isymbuf, sections))
803 
        goto error_return;
804 
 
805 
      if (sections != NULL)
806 
        free (sections);
807 
      if (isymbuf != NULL
808 
          && symtab_hdr->contents != (unsigned char *) isymbuf)
809 
        free (isymbuf);
810 
      if (elf_section_data (input_section)->relocs != internal_relocs)
811 
        free (internal_relocs);
812 
    }
813 
 
814 
  return data;
815 
 
816 
 error_return:
817 
  if (sections != NULL)
818 
    free (sections);
819 
  if (isymbuf != NULL
820 
      && symtab_hdr->contents != (unsigned char *) isymbuf)
821 
    free (isymbuf);
822 
  if (internal_relocs != NULL
823 
      && elf_section_data (input_section)->relocs != internal_relocs)
824 
    free (internal_relocs);
825 
  return NULL;
826 
}
827 
 
828 
/* Relocate a CRX ELF section.  */
829 
 
830 
static bfd_boolean
831 
elf32_crx_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
832 
                            bfd *input_bfd, asection *input_section,
833 
                            bfd_byte *contents, Elf_Internal_Rela *relocs,
834 
                            Elf_Internal_Sym *local_syms,
835 
                            asection **local_sections)
836 
{
837 
  Elf_Internal_Shdr *symtab_hdr;
838 
  struct elf_link_hash_entry **sym_hashes;
839 
  Elf_Internal_Rela *rel, *relend;
840 
 
841 
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
842 
  sym_hashes = elf_sym_hashes (input_bfd);
843 
 
844 
  rel = relocs;
845 
  relend = relocs + input_section->reloc_count;
846 
  for (; rel < relend; rel++)
847 
    {
848 
      int r_type;
849 
      reloc_howto_type *howto;
850 
      unsigned long r_symndx;
851 
      Elf_Internal_Sym *sym;
852 
      asection *sec;
853 
      struct elf_link_hash_entry *h;
854 
      bfd_vma relocation;
855 
      bfd_reloc_status_type r;
856 
 
857 
      r_symndx = ELF32_R_SYM (rel->r_info);
858 
      r_type = ELF32_R_TYPE (rel->r_info);
859 
      howto = crx_elf_howto_table + (r_type);
860 
 
861 
      h = NULL;
862 
      sym = NULL;
863 
      sec = NULL;
864 
      if (r_symndx < symtab_hdr->sh_info)
865 
        {
866 
          sym = local_syms + r_symndx;
867 
          sec = local_sections[r_symndx];
868 
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
869 
        }
870 
      else
871 
        {
872 
          bfd_boolean unresolved_reloc, warned;
873 
 
874 
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
875 
                                   r_symndx, symtab_hdr, sym_hashes,
876 
                                   h, sec, relocation,
877 
                                   unresolved_reloc, warned);
878 
        }
879 
 
880 
      if (sec != NULL && elf_discarded_section (sec))
881 
        {
882 
          /* For relocs against symbols from removed linkonce sections,
883 
             or sections discarded by a linker script, we just want the
884 
             section contents zeroed.  Avoid any special processing.  */
885 
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
886 
          rel->r_info = 0;
887 
          rel->r_addend = 0;
888 
          continue;
889 
        }
890 
 
891 
      if (info->relocatable)
892 
        continue;
893 
 
894 
      r = crx_elf_final_link_relocate (howto, input_bfd, output_bfd,
895 
                                        input_section,
896 
                                        contents, rel->r_offset,
897 
                                        relocation, rel->r_addend,
898 
                                        info, sec, h == NULL);
899 
 
900 
      if (r != bfd_reloc_ok)
901 
        {
902 
          const char *name;
903 
          const char *msg = (const char *) 0;
904 
 
905 
          if (h != NULL)
906 
            name = h->root.root.string;
907 
          else
908 
            {
909 
              name = (bfd_elf_string_from_elf_section
910 
                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
911 
              if (name == NULL || *name == '\0')
912 
                name = bfd_section_name (input_bfd, sec);
913 
            }
914 
 
915 
          switch (r)
916 
            {
917 
             case bfd_reloc_overflow:
918 
               if (!((*info->callbacks->reloc_overflow)
919 
                     (info, (h ? &h->root : NULL), name, howto->name,
920 
                      (bfd_vma) 0, input_bfd, input_section,
921 
                      rel->r_offset)))
922 
                 return FALSE;
923 
               break;
924 
 
925 
             case bfd_reloc_undefined:
926 
               if (!((*info->callbacks->undefined_symbol)
927 
                     (info, name, input_bfd, input_section,
928 
                      rel->r_offset, TRUE)))
929 
                 return FALSE;
930 
               break;
931 
 
932 
             case bfd_reloc_outofrange:
933 
               msg = _("internal error: out of range error");
934 
               goto common_error;
935 
 
936 
             case bfd_reloc_notsupported:
937 
               msg = _("internal error: unsupported relocation error");
938 
               goto common_error;
939 
 
940 
             case bfd_reloc_dangerous:
941 
               msg = _("internal error: dangerous error");
942 
               goto common_error;
943 
 
944 
             default:
945 
               msg = _("internal error: unknown error");
946 
               /* Fall through.  */
947 
 
948 
             common_error:
949 
               if (!((*info->callbacks->warning)
950 
                     (info, msg, name, input_bfd, input_section,
951 
                      rel->r_offset)))
952 
                 return FALSE;
953 
               break;
954 
            }
955 
        }
956 
    }
957 
 
958 
  return TRUE;
959 
}
960 
 
961 
/* This function handles relaxing for the CRX.
962 
 
963 
   There's quite a few relaxing opportunites available on the CRX:
964 
 
965 
        * bal/bcond:32 -> bal/bcond:16                             2 bytes
966 
        * bcond:16 -> bcond:8                                      2 bytes
967 
        * cmpbcond:24 -> cmpbcond:8                                2 bytes
968 
        * arithmetic imm32 -> arithmetic imm16                     2 bytes
969 
 
970 
   Symbol- and reloc-reading infrastructure copied from elf-m10200.c.  */
971 
 
972 
static bfd_boolean
973 
elf32_crx_relax_section (bfd *abfd, asection *sec,
974 
                         struct bfd_link_info *link_info, bfd_boolean *again)
975 
{
976 
  Elf_Internal_Shdr *symtab_hdr;
977 
  Elf_Internal_Rela *internal_relocs;
978 
  Elf_Internal_Rela *irel, *irelend;
979 
  bfd_byte *contents = NULL;
980 
  Elf_Internal_Sym *isymbuf = NULL;
981 
 
982 
  /* Assume nothing changes.  */
983 
  *again = FALSE;
984 
 
985 
  /* We don't have to do anything for a relocatable link, if
986 
     this section does not have relocs, or if this is not a
987 
     code section.  */
988 
  if (link_info->relocatable
989 
      || (sec->flags & SEC_RELOC) == 0
990 
      || sec->reloc_count == 0
991 
      || (sec->flags & SEC_CODE) == 0)
992 
    return TRUE;
993 
 
994 
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
995 
 
996 
  /* Get a copy of the native relocations.  */
997 
  internal_relocs = (_bfd_elf_link_read_relocs
998 
                     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
999 
                      link_info->keep_memory));
1000 
  if (internal_relocs == NULL)
1001 
    goto error_return;
1002 
 
1003 
  /* Walk through them looking for relaxing opportunities.  */
1004 
  irelend = internal_relocs + sec->reloc_count;
1005 
  for (irel = internal_relocs; irel < irelend; irel++)
1006 
    {
1007 
      bfd_vma symval;
1008 
 
1009 
      /* If this isn't something that can be relaxed, then ignore
1010 
         this reloc.  */
1011 
      if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL32
1012 
          && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL16
1013 
          && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL24
1014 
          && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_IMM32)
1015 
        continue;
1016 
 
1017 
      /* Get the section contents if we haven't done so already.  */
1018 
      if (contents == NULL)
1019 
        {
1020 
          /* Get cached copy if it exists.  */
1021 
          if (elf_section_data (sec)->this_hdr.contents != NULL)
1022 
            contents = elf_section_data (sec)->this_hdr.contents;
1023 
          /* Go get them off disk.  */
1024 
          else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1025 
            goto error_return;
1026 
        }
1027 
 
1028 
      /* Read this BFD's local symbols if we haven't done so already.  */
1029 
      if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1030 
        {
1031 
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1032 
          if (isymbuf == NULL)
1033 
            isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1034 
                                            symtab_hdr->sh_info, 0,
1035 
                                            NULL, NULL, NULL);
1036 
          if (isymbuf == NULL)
1037 
            goto error_return;
1038 
        }
1039 
 
1040 
      /* Get the value of the symbol referred to by the reloc.  */
1041 
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1042 
        {
1043 
          /* A local symbol.  */
1044 
          Elf_Internal_Sym *isym;
1045 
          asection *sym_sec;
1046 
 
1047 
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
1048 
          if (isym->st_shndx == SHN_UNDEF)
1049 
            sym_sec = bfd_und_section_ptr;
1050 
          else if (isym->st_shndx == SHN_ABS)
1051 
            sym_sec = bfd_abs_section_ptr;
1052 
          else if (isym->st_shndx == SHN_COMMON)
1053 
            sym_sec = bfd_com_section_ptr;
1054 
          else
1055 
            sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1056 
          symval = (isym->st_value
1057 
                    + sym_sec->output_section->vma
1058 
                    + sym_sec->output_offset);
1059 
        }
1060 
      else
1061 
        {
1062 
          unsigned long indx;
1063 
          struct elf_link_hash_entry *h;
1064 
 
1065 
          /* An external symbol.  */
1066 
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1067 
          h = elf_sym_hashes (abfd)[indx];
1068 
          BFD_ASSERT (h != NULL);
1069 
 
1070 
          if (h->root.type != bfd_link_hash_defined
1071 
              && h->root.type != bfd_link_hash_defweak)
1072 
            /* This appears to be a reference to an undefined
1073 
               symbol.  Just ignore it--it will be caught by the
1074 
               regular reloc processing.  */
1075 
            continue;
1076 
 
1077 
          symval = (h->root.u.def.value
1078 
                    + h->root.u.def.section->output_section->vma
1079 
                    + h->root.u.def.section->output_offset);
1080 
        }
1081 
 
1082 
      /* For simplicity of coding, we are going to modify the section
1083 
         contents, the section relocs, and the BFD symbol table.  We
1084 
         must tell the rest of the code not to free up this
1085 
         information.  It would be possible to instead create a table
1086 
         of changes which have to be made, as is done in coff-mips.c;
1087 
         that would be more work, but would require less memory when
1088 
         the linker is run.  */
1089 
 
1090 
      /* Try to turn a 32bit pc-relative branch/call into
1091 
         a 16bit pc-relative branch/call.  */
1092 
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL32)
1093 
        {
1094 
          bfd_vma value = symval;
1095 
 
1096 
          /* Deal with pc-relative gunk.  */
1097 
          value -= (sec->output_section->vma + sec->output_offset);
1098 
          value -= irel->r_offset;
1099 
          value += irel->r_addend;
1100 
 
1101 
          /* See if the value will fit in 16 bits, note the high value is
1102 
             0xfffe + 2 as the target will be two bytes closer if we are
1103 
             able to relax.  */
1104 
          if ((long) value < 0x10000 && (long) value > -0x10002)
1105 
            {
1106 
              unsigned short code;
1107 
 
1108 
              /* Get the opcode.  */
1109 
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1110 
 
1111 
              /* Verify it's a 'bal'/'bcond' and fix the opcode.  */
1112 
              if ((code & 0xfff0) == 0x3170)
1113 
                bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1114 
              else if ((code & 0xf0ff) == 0x707f)
1115 
                bfd_put_8 (abfd, 0x7e, contents + irel->r_offset);
1116 
              else
1117 
                continue;
1118 
 
1119 
              /* Note that we've changed the relocs, section contents, etc.  */
1120 
              elf_section_data (sec)->relocs = internal_relocs;
1121 
              elf_section_data (sec)->this_hdr.contents = contents;
1122 
              symtab_hdr->contents = (unsigned char *) isymbuf;
1123 
 
1124 
              /* Fix the relocation's type.  */
1125 
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1126 
                                           R_CRX_REL16);
1127 
 
1128 
              /* Delete two bytes of data.  */
1129 
              if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1130 
                                                   irel->r_offset + 2, 2))
1131 
                goto error_return;
1132 
 
1133 
              /* That will change things, so, we should relax again.
1134 
                 Note that this is not required, and it may be slow.  */
1135 
              *again = TRUE;
1136 
            }
1137 
        }
1138 
 
1139 
      /* Try to turn a 16bit pc-relative branch into an
1140 
         8bit pc-relative branch.  */
1141 
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL16)
1142 
        {
1143 
          bfd_vma value = symval;
1144 
 
1145 
          /* Deal with pc-relative gunk.  */
1146 
          value -= (sec->output_section->vma + sec->output_offset);
1147 
          value -= irel->r_offset;
1148 
          value += irel->r_addend;
1149 
 
1150 
          /* See if the value will fit in 8 bits, note the high value is
1151 
             0xfc + 2 as the target will be two bytes closer if we are
1152 
             able to relax.  */
1153 
          if ((long) value < 0xfe && (long) value > -0x100)
1154 
            {
1155 
              unsigned short code;
1156 
 
1157 
              /* Get the opcode.  */
1158 
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1159 
 
1160 
              /* Verify it's a 'bcond' opcode.  */
1161 
              if ((code & 0xf0ff) != 0x707e)
1162 
                continue;
1163 
 
1164 
              /* Note that we've changed the relocs, section contents, etc.  */
1165 
              elf_section_data (sec)->relocs = internal_relocs;
1166 
              elf_section_data (sec)->this_hdr.contents = contents;
1167 
              symtab_hdr->contents = (unsigned char *) isymbuf;
1168 
 
1169 
              /* Fix the relocation's type.  */
1170 
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1171 
                                           R_CRX_REL8);
1172 
 
1173 
              /* Delete two bytes of data.  */
1174 
              if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1175 
                                                   irel->r_offset + 2, 2))
1176 
                goto error_return;
1177 
 
1178 
              /* That will change things, so, we should relax again.
1179 
                 Note that this is not required, and it may be slow.  */
1180 
              *again = TRUE;
1181 
            }
1182 
        }
1183 
 
1184 
      /* Try to turn a 24bit pc-relative cmp&branch into
1185 
         an 8bit pc-relative cmp&branch.  */
1186 
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL24)
1187 
        {
1188 
          bfd_vma value = symval;
1189 
 
1190 
          /* Deal with pc-relative gunk.  */
1191 
          value -= (sec->output_section->vma + sec->output_offset);
1192 
          value -= irel->r_offset;
1193 
          value += irel->r_addend;
1194 
 
1195 
          /* See if the value will fit in 8 bits, note the high value is
1196 
             0x7e + 2 as the target will be two bytes closer if we are
1197 
             able to relax.  */
1198 
          if ((long) value < 0x100 && (long) value > -0x100)
1199 
            {
1200 
              unsigned short code;
1201 
 
1202 
              /* Get the opcode.  */
1203 
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1204 
 
1205 
              /* Verify it's a 'cmp&branch' opcode.  */
1206 
              if ((code & 0xfff0) != 0x3180 && (code & 0xfff0) != 0x3190
1207 
               && (code & 0xfff0) != 0x31a0 && (code & 0xfff0) != 0x31c0
1208 
               && (code & 0xfff0) != 0x31d0 && (code & 0xfff0) != 0x31e0
1209 
               /* Or a Co-processor branch ('bcop').  */
1210 
               && (code & 0xfff0) != 0x3010 && (code & 0xfff0) != 0x3110)
1211 
                continue;
1212 
 
1213 
              /* Note that we've changed the relocs, section contents, etc.  */
1214 
              elf_section_data (sec)->relocs = internal_relocs;
1215 
              elf_section_data (sec)->this_hdr.contents = contents;
1216 
              symtab_hdr->contents = (unsigned char *) isymbuf;
1217 
 
1218 
              /* Fix the opcode.  */
1219 
              bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1220 
 
1221 
              /* Fix the relocation's type.  */
1222 
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1223 
                                           R_CRX_REL8_CMP);
1224 
 
1225 
              /* Delete two bytes of data.  */
1226 
              if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1227 
                                                   irel->r_offset + 4, 2))
1228 
                goto error_return;
1229 
 
1230 
              /* That will change things, so, we should relax again.
1231 
                 Note that this is not required, and it may be slow.  */
1232 
              *again = TRUE;
1233 
            }
1234 
        }
1235 
 
1236 
      /* Try to turn a 32bit immediate address into
1237 
         a 16bit immediate address.  */
1238 
      if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_IMM32)
1239 
        {
1240 
          bfd_vma value = symval;
1241 
 
1242 
          /* See if the value will fit in 16 bits.  */
1243 
          if ((long) value < 0x7fff && (long) value > -0x8000)
1244 
            {
1245 
              unsigned short code;
1246 
 
1247 
              /* Get the opcode.  */
1248 
              code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1249 
 
1250 
              /* Verify it's a 'arithmetic double'.  */
1251 
              if ((code & 0xf0f0) != 0x20f0)
1252 
                continue;
1253 
 
1254 
              /* Note that we've changed the relocs, section contents, etc.  */
1255 
              elf_section_data (sec)->relocs = internal_relocs;
1256 
              elf_section_data (sec)->this_hdr.contents = contents;
1257 
              symtab_hdr->contents = (unsigned char *) isymbuf;
1258 
 
1259 
              /* Fix the opcode.  */
1260 
              bfd_put_8 (abfd, (code & 0xff) - 0x10, contents + irel->r_offset);
1261 
 
1262 
              /* Fix the relocation's type.  */
1263 
              irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1264 
                                           R_CRX_IMM16);
1265 
 
1266 
              /* Delete two bytes of data.  */
1267 
              if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1268 
                                                   irel->r_offset + 2, 2))
1269 
                goto error_return;
1270 
 
1271 
              /* That will change things, so, we should relax again.
1272 
                 Note that this is not required, and it may be slow.  */
1273 
              *again = TRUE;
1274 
            }
1275 
        }
1276 
    }
1277 
 
1278 
  if (isymbuf != NULL
1279 
      && symtab_hdr->contents != (unsigned char *) isymbuf)
1280 
    {
1281 
      if (! link_info->keep_memory)
1282 
        free (isymbuf);
1283 
      else
1284 
        {
1285 
          /* Cache the symbols for elf_link_input_bfd.  */
1286 
          symtab_hdr->contents = (unsigned char *) isymbuf;
1287 
        }
1288 
    }
1289 
 
1290 
  if (contents != NULL
1291 
      && elf_section_data (sec)->this_hdr.contents != contents)
1292 
    {
1293 
      if (! link_info->keep_memory)
1294 
        free (contents);
1295 
      else
1296 
        {
1297 
          /* Cache the section contents for elf_link_input_bfd.  */
1298 
          elf_section_data (sec)->this_hdr.contents = contents;
1299 
        }
1300 
    }
1301 
 
1302 
  if (internal_relocs != NULL
1303 
      && elf_section_data (sec)->relocs != internal_relocs)
1304 
    free (internal_relocs);
1305 
 
1306 
  return TRUE;
1307 
 
1308 
 error_return:
1309 
  if (isymbuf != NULL
1310 
      && symtab_hdr->contents != (unsigned char *) isymbuf)
1311 
    free (isymbuf);
1312 
  if (contents != NULL
1313 
      && elf_section_data (sec)->this_hdr.contents != contents)
1314 
    free (contents);
1315 
  if (internal_relocs != NULL
1316 
      && elf_section_data (sec)->relocs != internal_relocs)
1317 
    free (internal_relocs);
1318 
 
1319 
  return FALSE;
1320 
}
1321 
 
1322 
/* Definitions for setting CRX target vector.  */
1323 
#define TARGET_LITTLE_SYM               bfd_elf32_crx_vec
1324 
#define TARGET_LITTLE_NAME              "elf32-crx"
1325 
#define ELF_ARCH                        bfd_arch_crx
1326 
#define ELF_MACHINE_CODE                EM_CRX
1327 
#define ELF_MAXPAGESIZE                 0x1
1328 
#define elf_symbol_leading_char         '_'
1329 
 
1330 
#define bfd_elf32_bfd_reloc_type_lookup elf_crx_reloc_type_lookup
1331 
#define bfd_elf32_bfd_reloc_name_lookup \
1332 
                                        elf_crx_reloc_name_lookup
1333 
#define elf_info_to_howto               elf_crx_info_to_howto
1334 
#define elf_info_to_howto_rel           0
1335 
#define elf_backend_relocate_section    elf32_crx_relocate_section
1336 
#define bfd_elf32_bfd_relax_section     elf32_crx_relax_section
1337 
#define bfd_elf32_bfd_get_relocated_section_contents \
1338 
                                elf32_crx_get_relocated_section_contents
1339 
#define elf_backend_can_gc_sections     1
1340 
#define elf_backend_rela_normal         1
1341 
 
1342 
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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