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) 344