1 /* BFD back-end for Intel 860 COFF files. 2 Copyright 1990, 91, 92, 93, 94, 95, 97, 1999 Free Software Foundation, Inc. 3 Created mostly by substituting "860" for "386" in coff-i386.c 4 Harry Dolan <dolan@ssd.intel.com>, October 1995 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22 #include "bfd.h" 23 #include "sysdep.h" 24 #include "libbfd.h" 25 26 #include "coff/i860.h" 27 28 #include "coff/internal.h" 29 30 #include "libcoff.h" 31 32 static bfd_reloc_status_type coff_i860_reloc 33 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 34 static reloc_howto_type *coff_i860_rtype_to_howto 35 PARAMS ((bfd *, asection *, struct internal_reloc *, 36 struct coff_link_hash_entry *, struct internal_syment *, 37 bfd_vma *)); 38 39 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2) 40 /* The page size is a guess based on ELF. */ 41 42 #define COFF_PAGE_SIZE 0x1000 43 44 /* For some reason when using i860 COFF the value stored in the .text 45 section for a reference to a common symbol is the value itself plus 46 any desired offset. Ian Taylor, Cygnus Support. */ 47 48 /* If we are producing relocateable output, we need to do some 49 adjustments to the object file that are not done by the 50 bfd_perform_relocation function. This function is called by every 51 reloc type to make any required adjustments. */ 52 53 static bfd_reloc_status_type 54 coff_i860_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd, 55 error_message) 56 bfd *abfd; 57 arelent *reloc_entry; 58 asymbol *symbol; 59 PTR data; 60 asection *input_section ATTRIBUTE_UNUSED; 61 bfd *output_bfd; 62 char **error_message ATTRIBUTE_UNUSED; 63 { 64 symvalue diff; 65 66 if (output_bfd == (bfd *) NULL) 67 return bfd_reloc_continue; 68 69 70 if (bfd_is_com_section (symbol->section)) 71 { 72 /* We are relocating a common symbol. The current value in the 73 object file is ORIG + OFFSET, where ORIG is the value of the 74 common symbol as seen by the object file when it was compiled 75 (this may be zero if the symbol was undefined) and OFFSET is 76 the offset into the common symbol (normally zero, but may be 77 non-zero when referring to a field in a common structure). 78 ORIG is the negative of reloc_entry->addend, which is set by 79 the CALC_ADDEND macro below. We want to replace the value in 80 the object file with NEW + OFFSET, where NEW is the value of 81 the common symbol which we are going to put in the final 82 object file. NEW is symbol->value. */ 83 diff = symbol->value + reloc_entry->addend; 84 } 85 else 86 { 87 /* For some reason bfd_perform_relocation always effectively 88 ignores the addend for a COFF target when producing 89 relocateable output. This seems to be always wrong for 860 90 COFF, so we handle the addend here instead. */ 91 diff = reloc_entry->addend; 92 } 93 94 95 #define DOIT(x) \ 96 x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask)) 97 98 if (diff != 0) 99 { 100 reloc_howto_type *howto = reloc_entry->howto; 101 unsigned char *addr = (unsigned char *) data + reloc_entry->address; 102 103 switch (howto->size) 104 { 105 case 0: 106 { 107 char x = bfd_get_8 (abfd, addr); 108 DOIT (x); 109 bfd_put_8 (abfd, x, addr); 110 } 111 break; 112 113 case 1: 114 { 115 short x = bfd_get_16 (abfd, addr); 116 DOIT (x); 117 bfd_put_16 (abfd, x, addr); 118 } 119 break; 120 121 case 2: 122 { 123 long x = bfd_get_32 (abfd, addr); 124 DOIT (x); 125 bfd_put_32 (abfd, x, addr); 126 } 127 break; 128 129 default: 130 abort (); 131 } 132 } 133 134 /* Now let bfd_perform_relocation finish everything up. */ 135 return bfd_reloc_continue; 136 } 137 138 #ifndef PCRELOFFSET 139 #define PCRELOFFSET false 140 #endif 141 142 static reloc_howto_type howto_table[] = 143 { 144 EMPTY_HOWTO (0), 145 EMPTY_HOWTO (1), 146 EMPTY_HOWTO (2), 147 EMPTY_HOWTO (3), 148 EMPTY_HOWTO (4), 149 EMPTY_HOWTO (5), 150 HOWTO (R_DIR32, /* type */ 151 0, /* rightshift */ 152 2, /* size (0 = byte, 1 = short, 2 = long) */ 153 32, /* bitsize */ 154 false, /* pc_relative */ 155 0, /* bitpos */ 156 complain_overflow_bitfield, /* complain_on_overflow */ 157 coff_i860_reloc, /* special_function */ 158 "dir32", /* name */ 159 true, /* partial_inplace */ 160 0xffffffff, /* src_mask */ 161 0xffffffff, /* dst_mask */ 162 true), /* pcrel_offset */ 163 /* {7}, */ 164 HOWTO (R_IMAGEBASE, /* type */ 165 0, /* rightshift */ 166 2, /* size (0 = byte, 1 = short, 2 = long) */ 167 32, /* bitsize */ 168 false, /* pc_relative */ 169 0, /* bitpos */ 170 complain_overflow_bitfield, /* complain_on_overflow */ 171 coff_i860_reloc, /* special_function */ 172 "rva32", /* name */ 173 true, /* partial_inplace */ 174 0xffffffff, /* src_mask */ 175 0xffffffff, /* dst_mask */ 176 false), /* pcrel_offset */ 177 EMPTY_HOWTO (010), 178 EMPTY_HOWTO (011), 179 EMPTY_HOWTO (012), 180 EMPTY_HOWTO (013), 181 EMPTY_HOWTO (014), 182 EMPTY_HOWTO (015), 183 EMPTY_HOWTO (016), 184 HOWTO (R_RELBYTE, /* type */ 185 0, /* rightshift */ 186 0, /* size (0 = byte, 1 = short, 2 = long) */ 187 8, /* bitsize */ 188 false, /* pc_relative */ 189 0, /* bitpos */ 190 complain_overflow_bitfield, /* complain_on_overflow */ 191 coff_i860_reloc, /* special_function */ 192 "8", /* name */ 193 true, /* partial_inplace */ 194 0x000000ff, /* src_mask */ 195 0x000000ff, /* dst_mask */ 196 PCRELOFFSET), /* pcrel_offset */ 197 HOWTO (R_RELWORD, /* type */ 198 0, /* rightshift */ 199 1, /* size (0 = byte, 1 = short, 2 = long) */ 200 16, /* bitsize */ 201 false, /* pc_relative */ 202 0, /* bitpos */ 203 complain_overflow_bitfield, /* complain_on_overflow */ 204 coff_i860_reloc, /* special_function */ 205 "16", /* name */ 206 true, /* partial_inplace */ 207 0x0000ffff, /* src_mask */ 208 0x0000ffff, /* dst_mask */ 209 PCRELOFFSET), /* pcrel_offset */ 210 HOWTO (R_RELLONG, /* type */ 211 0, /* rightshift */ 212 2, /* size (0 = byte, 1 = short, 2 = long) */ 213 32, /* bitsize */ 214 false, /* pc_relative */ 215 0, /* bitpos */ 216 complain_overflow_bitfield, /* complain_on_overflow */ 217 coff_i860_reloc, /* special_function */ 218 "32", /* name */ 219 true, /* partial_inplace */ 220 0xffffffff, /* src_mask */ 221 0xffffffff, /* dst_mask */ 222 PCRELOFFSET), /* pcrel_offset */ 223 HOWTO (R_PCRBYTE, /* type */ 224 0, /* rightshift */ 225 0, /* size (0 = byte, 1 = short, 2 = long) */ 226 8, /* bitsize */ 227 true, /* pc_relative */ 228 0, /* bitpos */ 229 complain_overflow_signed, /* complain_on_overflow */ 230 coff_i860_reloc, /* special_function */ 231 "DISP8", /* name */ 232 true, /* partial_inplace */ 233 0x000000ff, /* src_mask */ 234 0x000000ff, /* dst_mask */ 235 PCRELOFFSET), /* pcrel_offset */ 236 HOWTO (R_PCRWORD, /* type */ 237 0, /* rightshift */ 238 1, /* size (0 = byte, 1 = short, 2 = long) */ 239 16, /* bitsize */ 240 true, /* pc_relative */ 241 0, /* bitpos */ 242 complain_overflow_signed, /* complain_on_overflow */ 243 coff_i860_reloc, /* special_function */ 244 "DISP16", /* name */ 245 true, /* partial_inplace */ 246 0x0000ffff, /* src_mask */ 247 0x0000ffff, /* dst_mask */ 248 PCRELOFFSET), /* pcrel_offset */ 249 HOWTO (R_PCRLONG, /* type */ 250 0, /* rightshift */ 251 2, /* size (0 = byte, 1 = short, 2 = long) */ 252 32, /* bitsize */ 253 true, /* pc_relative */ 254 0, /* bitpos */ 255 complain_overflow_signed, /* complain_on_overflow */ 256 coff_i860_reloc, /* special_function */ 257 "DISP32", /* name */ 258 true, /* partial_inplace */ 259 0xffffffff, /* src_mask */ 260 0xffffffff, /* dst_mask */ 261 PCRELOFFSET) /* pcrel_offset */ 262 }; 263 264 /* Turn a howto into a reloc nunmber */ 265 266 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; } 267 #define BADMAG(x) I860BADMAG(x) 268 #define I860 1 /* Customize coffcode.h */ 269 270 #define RTYPE2HOWTO(cache_ptr, dst) \ 271 (cache_ptr)->howto = howto_table + (dst)->r_type; 272 273 /* For 860 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared 274 library. On some other COFF targets STYP_BSS is normally 275 STYP_NOLOAD. */ 276 #define BSS_NOLOAD_IS_SHARED_LIBRARY 277 278 /* Compute the addend of a reloc. If the reloc is to a common symbol, 279 the object file contains the value of the common symbol. By the 280 time this is called, the linker may be using a different symbol 281 from a different object file with a different value. Therefore, we 282 hack wildly to locate the original symbol from this file so that we 283 can make the correct adjustment. This macro sets coffsym to the 284 symbol from the original file, and uses it to set the addend value 285 correctly. If this is not a common symbol, the usual addend 286 calculation is done, except that an additional tweak is needed for 287 PC relative relocs. 288 FIXME: This macro refers to symbols and asect; these are from the 289 calling function, not the macro arguments. */ 290 291 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 292 { \ 293 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \ 294 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 295 coffsym = (obj_symbols (abfd) \ 296 + (cache_ptr->sym_ptr_ptr - symbols)); \ 297 else if (ptr) \ 298 coffsym = coff_symbol_from (abfd, ptr); \ 299 if (coffsym != (coff_symbol_type *) NULL \ 300 && coffsym->native->u.syment.n_scnum == 0) \ 301 cache_ptr->addend = - coffsym->native->u.syment.n_value; \ 302 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 303 && ptr->section != (asection *) NULL) \ 304 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 305 else \ 306 cache_ptr->addend = 0; \ 307 if (ptr && howto_table[reloc.r_type].pc_relative) \ 308 cache_ptr->addend += asect->vma; \ 309 } 310 311 /* We use the special COFF backend linker. */ 312 #define coff_relocate_section _bfd_coff_generic_relocate_section 313 314 static reloc_howto_type * 315 coff_i860_rtype_to_howto (abfd, sec, rel, h, sym, addendp) 316 bfd *abfd ATTRIBUTE_UNUSED; 317 asection *sec; 318 struct internal_reloc *rel; 319 struct coff_link_hash_entry *h; 320 struct internal_syment *sym; 321 bfd_vma *addendp; 322 { 323 324 reloc_howto_type *howto; 325 326 howto = howto_table + rel->r_type; 327 328 if (howto->pc_relative) 329 *addendp += sec->vma; 330 331 if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0) 332 { 333 /* This is a common symbol. The section contents include the 334 size (sym->n_value) as an addend. The relocate_section 335 function will be adding in the final value of the symbol. We 336 need to subtract out the current size in order to get the 337 correct result. */ 338 339 BFD_ASSERT (h != NULL); 340 341 342 /* I think we *do* want to bypass this. If we don't, I have seen some data 343 parameters get the wrong relcation address. If I link two versions 344 with and without this section bypassed and then do a binary comparison, 345 the addresses which are different can be looked up in the map. The 346 case in which this section has been bypassed has addresses which correspond 347 to values I can find in the map */ 348 *addendp -= sym->n_value; 349 } 350 351 /* If the output symbol is common (in which case this must be a 352 relocateable link), we need to add in the final size of the 353 common symbol. */ 354 if (h != NULL && h->root.type == bfd_link_hash_common) 355 *addendp += h->root.u.c.size; 356 357 return howto; 358 } 359 360 #define coff_rtype_to_howto coff_i860_rtype_to_howto 361 362 #include "coffcode.h" 363 364 static const bfd_target * 365 i3coff_object_p(a) 366 bfd *a; 367 { 368 return coff_object_p(a); 369 } 370 371 const bfd_target 372 #ifdef TARGET_SYM 373 TARGET_SYM = 374 #else 375 i860coff_vec = 376 #endif 377 { 378 #ifdef TARGET_NAME 379 TARGET_NAME, 380 #else 381 "coff-i860", /* name */ 382 #endif 383 bfd_target_coff_flavour, 384 BFD_ENDIAN_LITTLE, /* data byte order is little */ 385 BFD_ENDIAN_LITTLE, /* header byte order is little */ 386 387 (HAS_RELOC | EXEC_P | /* object flags */ 388 HAS_LINENO | HAS_DEBUG | 389 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 390 391 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ 392 '_', /* leading underscore */ 393 '/', /* ar_pad_char */ 394 15, /* ar_max_namelen */ 395 396 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 397 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 398 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 399 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 400 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 401 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 402 403 /* Note that we allow an object file to be treated as a core file as well. */ 404 {_bfd_dummy_target, i3coff_object_p, /* bfd_check_format */ 405 bfd_generic_archive_p, i3coff_object_p}, 406 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */ 407 bfd_false}, 408 {bfd_false, coff_write_object_contents, /* bfd_write_contents */ 409 _bfd_write_archive_contents, bfd_false}, 410 411 BFD_JUMP_TABLE_GENERIC (coff), 412 BFD_JUMP_TABLE_COPY (coff), 413 BFD_JUMP_TABLE_CORE (_bfd_nocore), 414 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 415 BFD_JUMP_TABLE_SYMBOLS (coff), 416 BFD_JUMP_TABLE_RELOCS (coff), 417 BFD_JUMP_TABLE_WRITE (coff), 418 BFD_JUMP_TABLE_LINK (coff), 419 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 420 421 NULL, 422 423 COFF_SWAP_TABLE 424 }; 425