bfd/coff-z8k.c

   1 /* BFD back-end for Zilog Z800n COFF binaries.
   2    Copyright 1992, 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4    Contributed by Cygnus Support.
   5    Written by Steve Chamberlain, <sac@cygnus.com>.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26 #include "bfdlink.h"
  27 #include "coff/z8k.h"
  28 #include "coff/internal.h"
  29 #include "libcoff.h"
  30
  31 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (1)
  32
  33 static reloc_howto_type r_imm32 =
  34 HOWTO (R_IMM32, 0, 2, 32, FALSE, 0,
  35        complain_overflow_bitfield, 0, "r_imm32", TRUE, 0xffffffff,
  36        0xffffffff, FALSE);
  37
  38 static reloc_howto_type r_imm4l =
  39 HOWTO (R_IMM4L, 0, 0, 4, FALSE, 0,
  40        complain_overflow_bitfield, 0, "r_imm4l", TRUE, 0xf, 0xf, FALSE);
  41
  42 static reloc_howto_type r_da =
  43 HOWTO (R_IMM16, 0, 1, 16, FALSE, 0,
  44        complain_overflow_bitfield, 0, "r_da", TRUE, 0x0000ffff, 0x0000ffff,
  45        FALSE);
  46
  47 static reloc_howto_type r_imm8 =
  48 HOWTO (R_IMM8, 0, 0, 8, FALSE, 0,
  49        complain_overflow_bitfield, 0, "r_imm8", TRUE, 0x000000ff, 0x000000ff,
  50        FALSE);
  51
  52 static reloc_howto_type r_rel16 =
  53 HOWTO (R_REL16, 0, 1, 16, FALSE, 0,
  54        complain_overflow_bitfield, 0, "r_rel16", TRUE, 0x0000ffff, 0x0000ffff,
  55        TRUE);
  56
  57 static reloc_howto_type r_jr =
  58 HOWTO (R_JR, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0,
  59        "r_jr", TRUE, 0, 0, TRUE);
  60
  61 static reloc_howto_type r_disp7 =
  62 HOWTO (R_DISP7, 0, 0, 7, TRUE, 0, complain_overflow_bitfield, 0,
  63        "r_disp7", TRUE, 0, 0, TRUE);
  64
  65 static reloc_howto_type r_callr =
  66 HOWTO (R_CALLR, 0, 1, 12, TRUE, 0, complain_overflow_signed, 0,
  67        "r_callr", TRUE, 0xfff, 0xfff, TRUE);
  68
  69 /* Turn a howto into a reloc number */
  70
  71 static int
  72 coff_z8k_select_reloc (reloc_howto_type *howto)
  73 {
  74   return howto->type;
  75 }
  76
  77 #define SELECT_RELOC(x,howto) x.r_type = coff_z8k_select_reloc(howto)
  78
  79 #define BADMAG(x) Z8KBADMAG(x)
  80 #define Z8K 1                   /* Customize coffcode.h */
  81 #define __A_MAGIC_SET__
  82
  83 /* Code to swap in the reloc.  */
  84 #define SWAP_IN_RELOC_OFFSET    H_GET_32
  85 #define SWAP_OUT_RELOC_OFFSET   H_PUT_32
  86 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
  87   dst->r_stuff[0] = 'S'; \
  88   dst->r_stuff[1] = 'C';
  89
  90 /* Code to turn a r_type into a howto ptr, uses the above howto table.  */
  91
  92 static void
  93 rtype2howto (arelent *internal, struct internal_reloc *dst)
  94 {
  95   switch (dst->r_type)
  96     {
  97     default:
  98       abort ();
  99       break;
 100     case R_IMM8:
 101       internal->howto = &r_imm8;
 102       break;
 103      case R_IMM16:
 104       internal->howto = &r_da;
 105       break;
 106     case R_JR:
 107       internal->howto = &r_jr;
 108       break;
 109     case R_DISP7:
 110       internal->howto = &r_disp7;
 111       break;
 112     case R_CALLR:
 113       internal->howto = &r_callr;
 114       break;
 115     case R_REL16:
 116       internal->howto = &r_rel16;
 117       break;
 118     case R_IMM32:
 119       internal->howto = &r_imm32;
 120       break;
 121     case R_IMM4L:
 122       internal->howto = &r_imm4l;
 123       break;
 124     }
 125 }
 126
 127 #define RTYPE2HOWTO(internal, relocentry) rtype2howto (internal, relocentry)
 128
 129 /* Perform any necessary magic to the addend in a reloc entry.  */
 130
 131 #define CALC_ADDEND(abfd, symbol, ext_reloc, cache_ptr) \
 132  cache_ptr->addend =  ext_reloc.r_offset;
 133
 134 #define RELOC_PROCESSING(relent,reloc,symbols,abfd,section) \
 135  reloc_processing(relent, reloc, symbols, abfd, section)
 136
 137 static void
 138 reloc_processing (arelent *relent,
 139                   struct internal_reloc *reloc,
 140                   asymbol **symbols,
 141                   bfd *abfd,
 142                   asection *section)
 143 {
 144   relent->address = reloc->r_vaddr;
 145   rtype2howto (relent, reloc);
 146
 147   if (reloc->r_symndx > 0)
 148     relent->sym_ptr_ptr = symbols + obj_convert (abfd)[reloc->r_symndx];
 149   else
 150     relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 151
 152   relent->addend = reloc->r_offset;
 153   relent->address -= section->vma;
 154 }
 155
 156 static void
 157 extra_case (bfd *in_abfd,
 158             struct bfd_link_info *link_info,
 159             struct bfd_link_order *link_order,
 160             arelent *reloc,
 161             bfd_byte *data,
 162             unsigned int *src_ptr,
 163             unsigned int *dst_ptr)
 164 {
 165   asection * input_section = link_order->u.indirect.section;
 166
 167   switch (reloc->howto->type)
 168     {
 169     case R_IMM8:
 170       bfd_put_8 (in_abfd,
 171                  bfd_coff_reloc16_get_value (reloc, link_info, input_section),
 172                  data + *dst_ptr);
 173       (*dst_ptr) += 1;
 174       (*src_ptr) += 1;
 175       break;
 176
 177     case R_IMM32:
 178       /* If no flags are set, assume immediate value.  */
 179       if (! (*reloc->sym_ptr_ptr)->section->flags)
 180         {
 181           bfd_put_32 (in_abfd,
 182                       bfd_coff_reloc16_get_value (reloc, link_info,
 183                                                   input_section),
 184                       data + *dst_ptr);
 185         }
 186       else
 187         {
 188           bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
 189                                                     input_section);
 190           /* Addresses are 23 bit, and the layout of those in a 32-bit
 191              value is as follows:
 192                1AAAAAAA xxxxxxxx AAAAAAAA AAAAAAAA
 193              (A - address bits,  x - ignore).  */
 194           dst = (dst & 0xffff) | ((dst & 0xff0000) << 8) | 0x80000000;
 195           bfd_put_32 (in_abfd, dst, data + *dst_ptr);
 196         }
 197       (*dst_ptr) += 4;
 198       (*src_ptr) += 4;
 199       break;
 200
 201     case R_IMM4L:
 202       bfd_put_8 (in_abfd,
 203                  ((bfd_get_8 (in_abfd, data + *dst_ptr) & 0xf0)
 204                   | (0x0f
 205                      & bfd_coff_reloc16_get_value (reloc, link_info,
 206                                                    input_section))),
 207                  data + *dst_ptr);
 208       (*dst_ptr) += 1;
 209       (*src_ptr) += 1;
 210       break;
 211
 212     case R_IMM16:
 213       bfd_put_16 (in_abfd,
 214                   bfd_coff_reloc16_get_value (reloc, link_info, input_section),
 215                   data + *dst_ptr);
 216       (*dst_ptr) += 2;
 217       (*src_ptr) += 2;
 218       break;
 219
 220     case R_JR:
 221       {
 222         bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
 223                                                   input_section);
 224         bfd_vma dot = (link_order->offset
 225                        + *dst_ptr
 226                        + input_section->output_section->vma);
 227         int gap = dst - dot - 1;  /* -1, since we're in the odd byte of the
 228                                      word and the pc's been incremented.  */
 229
 230         if (gap & 1)
 231           abort ();
 232         gap /= 2;
 233         if (gap > 128 || gap < -128)
 234           {
 235             if (! ((*link_info->callbacks->reloc_overflow)
 236                    (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
 237                     reloc->howto->name, reloc->addend, input_section->owner,
 238                     input_section, reloc->address)))
 239               abort ();
 240           }
 241         bfd_put_8 (in_abfd, gap, data + *dst_ptr);
 242         (*dst_ptr)++;
 243         (*src_ptr)++;
 244         break;
 245       }
 246
 247     case R_DISP7:
 248       {
 249         bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
 250                                                   input_section);
 251         bfd_vma dot = (link_order->offset
 252                        + *dst_ptr
 253                        + input_section->output_section->vma);
 254         int gap = dst - dot - 1;  /* -1, since we're in the odd byte of the
 255                                      word and the pc's been incremented.  */
 256
 257         if (gap & 1)
 258           abort ();
 259         gap /= 2;
 260
 261         if (gap > 0 || gap < -127)
 262           {
 263             if (! ((*link_info->callbacks->reloc_overflow)
 264                    (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
 265                     reloc->howto->name, reloc->addend, input_section->owner,
 266                     input_section, reloc->address)))
 267               abort ();
 268           }
 269         bfd_put_8 (in_abfd,
 270                    (bfd_get_8 ( in_abfd, data + *dst_ptr) & 0x80) + (-gap & 0x7f),
 271                    data + *dst_ptr);
 272         (*dst_ptr)++;
 273         (*src_ptr)++;
 274         break;
 275       }
 276
 277     case R_CALLR:
 278       {
 279         bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
 280                                                   input_section);
 281         bfd_vma dot = (link_order->offset
 282                        + *dst_ptr
 283                        + input_section->output_section->vma);
 284         int gap = dst - dot - 2;
 285
 286         if (gap & 1)
 287           abort ();
 288         if (gap > 4096 || gap < -4095)
 289           {
 290             if (! ((*link_info->callbacks->reloc_overflow)
 291                    (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
 292                     reloc->howto->name, reloc->addend, input_section->owner,
 293                     input_section, reloc->address)))
 294               abort ();
 295           }
 296         gap /= 2;
 297         bfd_put_16 (in_abfd,
 298                     (bfd_get_16 ( in_abfd, data + *dst_ptr) & 0xf000) | (-gap & 0x0fff),
 299                     data + *dst_ptr);
 300         (*dst_ptr) += 2;
 301         (*src_ptr) += 2;
 302         break;
 303       }
 304
 305     case R_REL16:
 306       {
 307         bfd_vma dst = bfd_coff_reloc16_get_value (reloc, link_info,
 308                                                   input_section);
 309         bfd_vma dot = (link_order->offset
 310                        + *dst_ptr
 311                        + input_section->output_section->vma);
 312         int gap = dst - dot - 2;
 313
 314         if (gap > 32767 || gap < -32768)
 315           {
 316             if (! ((*link_info->callbacks->reloc_overflow)
 317                    (link_info, bfd_asymbol_name (*reloc->sym_ptr_ptr),
 318                     reloc->howto->name, reloc->addend, input_section->owner,
 319                     input_section, reloc->address)))
 320               abort ();
 321           }
 322         bfd_put_16 (in_abfd, (bfd_vma) gap, data + *dst_ptr);
 323         (*dst_ptr) += 2;
 324         (*src_ptr) += 2;
 325         break;
 326       }
 327
 328     default:
 329       abort ();
 330     }
 331 }
 332
 333 #define coff_reloc16_extra_cases extra_case
 334
 335 #include "coffcode.h"
 336
 337 #undef  coff_bfd_get_relocated_section_contents
 338 #undef coff_bfd_relax_section
 339 #define coff_bfd_get_relocated_section_contents \
 340   bfd_coff_reloc16_get_relocated_section_contents
 341 #define coff_bfd_relax_section bfd_coff_reloc16_relax_section
 342
 343 CREATE_BIG_COFF_TARGET_VEC (z8kcoff_vec, "coff-z8k", 0, 0, '_', NULL, COFF_SWAP_TABLE)