1 /* Generic ECOFF swapping routines, for BFD. 2 Copyright 1992, 1993, 1994, 1995, 1996, 2000, 2001, 2002, 2004, 2005, 3 2007 Free Software Foundation, Inc. 4 Written by Cygnus Support. 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 3 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., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 24 /* NOTE: This is a header file, but it contains executable routines. 25 This is done this way because these routines are substantially 26 similar, but are not identical, for all ECOFF targets. 27 28 These are routines to swap the ECOFF symbolic information in and 29 out. The routines are defined statically. You can set breakpoints 30 on them in gdb by naming the including source file; e.g., 31 'coff-mips.c':ecoff_swap_hdr_in. 32 33 Before including this header file, one of ECOFF_32, ECOFF_64, 34 ECOFF_SIGNED_32 or ECOFF_SIGNED_64 must be defined. These are 35 checked when swapping information that depends upon the target 36 size. This code works for 32 bit and 64 bit ECOFF, but may need to 37 be generalized in the future. 38 39 Some header file which defines the external forms of these 40 structures must also be included before including this header file. 41 Currently this is either coff/mips.h or coff/alpha.h. 42 43 If the symbol TEST is defined when this file is compiled, a 44 comparison is made to ensure that, in fact, the output is 45 bit-for-bit the same as the input. Of course, this symbol should 46 only be defined when deliberately testing the code on a machine 47 with the proper byte sex and such. */ 48 49 #ifdef ECOFF_32 50 #define ECOFF_GET_OFF H_GET_32 51 #define ECOFF_PUT_OFF H_PUT_32 52 #endif 53 #ifdef ECOFF_64 54 #define ECOFF_GET_OFF H_GET_64 55 #define ECOFF_PUT_OFF H_PUT_64 56 #endif 57 #ifdef ECOFF_SIGNED_32 58 #define ECOFF_GET_OFF H_GET_S32 59 #define ECOFF_PUT_OFF H_PUT_S32 60 #endif 61 #ifdef ECOFF_SIGNED_64 62 #define ECOFF_GET_OFF H_GET_S64 63 #define ECOFF_PUT_OFF H_PUT_S64 64 #endif 65 66 /* ECOFF auxiliary information swapping routines. These are the same 67 for all ECOFF targets, so they are defined in ecofflink.c. */ 68 69 extern void _bfd_ecoff_swap_tir_in 70 (int, const struct tir_ext *, TIR *); 71 extern void _bfd_ecoff_swap_tir_out 72 (int, const TIR *, struct tir_ext *); 73 extern void _bfd_ecoff_swap_rndx_in 74 (int, const struct rndx_ext *, RNDXR *); 75 extern void _bfd_ecoff_swap_rndx_out 76 (int, const RNDXR *, struct rndx_ext *); 77 78 /* Prototypes for functions defined in this file. */ 79 80 static void ecoff_swap_hdr_in (bfd *, void *, HDRR *); 81 static void ecoff_swap_hdr_out (bfd *, const HDRR *, void *); 82 static void ecoff_swap_fdr_in (bfd *, void *, FDR *); 83 static void ecoff_swap_fdr_out (bfd *, const FDR *, void *); 84 static void ecoff_swap_pdr_in (bfd *, void *, PDR *); 85 static void ecoff_swap_pdr_out (bfd *, const PDR *, void *); 86 static void ecoff_swap_sym_in (bfd *, void *, SYMR *); 87 static void ecoff_swap_sym_out (bfd *, const SYMR *, void *); 88 static void ecoff_swap_ext_in (bfd *, void *, EXTR *); 89 static void ecoff_swap_ext_out (bfd *, const EXTR *, void *); 90 static void ecoff_swap_rfd_in (bfd *, void *, RFDT *); 91 static void ecoff_swap_rfd_out (bfd *, const RFDT *, void *); 92 static void ecoff_swap_opt_in (bfd *, void *, OPTR *); 93 static void ecoff_swap_opt_out (bfd *, const OPTR *, void *); 94 static void ecoff_swap_dnr_in (bfd *, void *, DNR *); 95 static void ecoff_swap_dnr_out (bfd *, const DNR *, void *); 96 97 /* Swap in the symbolic header. */ 98 99 static void 100 ecoff_swap_hdr_in (bfd *abfd, void * ext_copy, HDRR *intern) 101 { 102 struct hdr_ext ext[1]; 103 104 *ext = *(struct hdr_ext *) ext_copy; 105 106 intern->magic = H_GET_S16 (abfd, ext->h_magic); 107 intern->vstamp = H_GET_S16 (abfd, ext->h_vstamp); 108 intern->ilineMax = H_GET_32 (abfd, ext->h_ilineMax); 109 intern->cbLine = ECOFF_GET_OFF (abfd, ext->h_cbLine); 110 intern->cbLineOffset = ECOFF_GET_OFF (abfd, ext->h_cbLineOffset); 111 intern->idnMax = H_GET_32 (abfd, ext->h_idnMax); 112 intern->cbDnOffset = ECOFF_GET_OFF (abfd, ext->h_cbDnOffset); 113 intern->ipdMax = H_GET_32 (abfd, ext->h_ipdMax); 114 intern->cbPdOffset = ECOFF_GET_OFF (abfd, ext->h_cbPdOffset); 115 intern->isymMax = H_GET_32 (abfd, ext->h_isymMax); 116 intern->cbSymOffset = ECOFF_GET_OFF (abfd, ext->h_cbSymOffset); 117 intern->ioptMax = H_GET_32 (abfd, ext->h_ioptMax); 118 intern->cbOptOffset = ECOFF_GET_OFF (abfd, ext->h_cbOptOffset); 119 intern->iauxMax = H_GET_32 (abfd, ext->h_iauxMax); 120 intern->cbAuxOffset = ECOFF_GET_OFF (abfd, ext->h_cbAuxOffset); 121 intern->issMax = H_GET_32 (abfd, ext->h_issMax); 122 intern->cbSsOffset = ECOFF_GET_OFF (abfd, ext->h_cbSsOffset); 123 intern->issExtMax = H_GET_32 (abfd, ext->h_issExtMax); 124 intern->cbSsExtOffset = ECOFF_GET_OFF (abfd, ext->h_cbSsExtOffset); 125 intern->ifdMax = H_GET_32 (abfd, ext->h_ifdMax); 126 intern->cbFdOffset = ECOFF_GET_OFF (abfd, ext->h_cbFdOffset); 127 intern->crfd = H_GET_32 (abfd, ext->h_crfd); 128 intern->cbRfdOffset = ECOFF_GET_OFF (abfd, ext->h_cbRfdOffset); 129 intern->iextMax = H_GET_32 (abfd, ext->h_iextMax); 130 intern->cbExtOffset = ECOFF_GET_OFF (abfd, ext->h_cbExtOffset); 131 132 #ifdef TEST 133 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 134 abort (); 135 #endif 136 } 137 138 /* Swap out the symbolic header. */ 139 140 static void 141 ecoff_swap_hdr_out (bfd *abfd, const HDRR *intern_copy, void * ext_ptr) 142 { 143 struct hdr_ext *ext = (struct hdr_ext *) ext_ptr; 144 HDRR intern[1]; 145 146 *intern = *intern_copy; 147 148 H_PUT_S16 (abfd, intern->magic, ext->h_magic); 149 H_PUT_S16 (abfd, intern->vstamp, ext->h_vstamp); 150 H_PUT_32 (abfd, intern->ilineMax, ext->h_ilineMax); 151 ECOFF_PUT_OFF (abfd, intern->cbLine, ext->h_cbLine); 152 ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->h_cbLineOffset); 153 H_PUT_32 (abfd, intern->idnMax, ext->h_idnMax); 154 ECOFF_PUT_OFF (abfd, intern->cbDnOffset, ext->h_cbDnOffset); 155 H_PUT_32 (abfd, intern->ipdMax, ext->h_ipdMax); 156 ECOFF_PUT_OFF (abfd, intern->cbPdOffset, ext->h_cbPdOffset); 157 H_PUT_32 (abfd, intern->isymMax, ext->h_isymMax); 158 ECOFF_PUT_OFF (abfd, intern->cbSymOffset, ext->h_cbSymOffset); 159 H_PUT_32 (abfd, intern->ioptMax, ext->h_ioptMax); 160 ECOFF_PUT_OFF (abfd, intern->cbOptOffset, ext->h_cbOptOffset); 161 H_PUT_32 (abfd, intern->iauxMax, ext->h_iauxMax); 162 ECOFF_PUT_OFF (abfd, intern->cbAuxOffset, ext->h_cbAuxOffset); 163 H_PUT_32 (abfd, intern->issMax, ext->h_issMax); 164 ECOFF_PUT_OFF (abfd, intern->cbSsOffset, ext->h_cbSsOffset); 165 H_PUT_32 (abfd, intern->issExtMax, ext->h_issExtMax); 166 ECOFF_PUT_OFF (abfd, intern->cbSsExtOffset, ext->h_cbSsExtOffset); 167 H_PUT_32 (abfd, intern->ifdMax, ext->h_ifdMax); 168 ECOFF_PUT_OFF (abfd, intern->cbFdOffset, ext->h_cbFdOffset); 169 H_PUT_32 (abfd, intern->crfd, ext->h_crfd); 170 ECOFF_PUT_OFF (abfd, intern->cbRfdOffset, ext->h_cbRfdOffset); 171 H_PUT_32 (abfd, intern->iextMax, ext->h_iextMax); 172 ECOFF_PUT_OFF (abfd, intern->cbExtOffset, ext->h_cbExtOffset); 173 174 #ifdef TEST 175 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 176 abort (); 177 #endif 178 } 179 180 /* Swap in the file descriptor record. */ 181 182 static void 183 ecoff_swap_fdr_in (bfd *abfd, void * ext_copy, FDR *intern) 184 { 185 struct fdr_ext ext[1]; 186 187 *ext = *(struct fdr_ext *) ext_copy; 188 189 intern->adr = ECOFF_GET_OFF (abfd, ext->f_adr); 190 intern->rss = H_GET_32 (abfd, ext->f_rss); 191 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 192 if (intern->rss == (signed long) 0xffffffff) 193 intern->rss = -1; 194 #endif 195 intern->issBase = H_GET_32 (abfd, ext->f_issBase); 196 intern->cbSs = ECOFF_GET_OFF (abfd, ext->f_cbSs); 197 intern->isymBase = H_GET_32 (abfd, ext->f_isymBase); 198 intern->csym = H_GET_32 (abfd, ext->f_csym); 199 intern->ilineBase = H_GET_32 (abfd, ext->f_ilineBase); 200 intern->cline = H_GET_32 (abfd, ext->f_cline); 201 intern->ioptBase = H_GET_32 (abfd, ext->f_ioptBase); 202 intern->copt = H_GET_32 (abfd, ext->f_copt); 203 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32) 204 intern->ipdFirst = H_GET_16 (abfd, ext->f_ipdFirst); 205 intern->cpd = H_GET_16 (abfd, ext->f_cpd); 206 #endif 207 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 208 intern->ipdFirst = H_GET_32 (abfd, ext->f_ipdFirst); 209 intern->cpd = H_GET_32 (abfd, ext->f_cpd); 210 #endif 211 intern->iauxBase = H_GET_32 (abfd, ext->f_iauxBase); 212 intern->caux = H_GET_32 (abfd, ext->f_caux); 213 intern->rfdBase = H_GET_32 (abfd, ext->f_rfdBase); 214 intern->crfd = H_GET_32 (abfd, ext->f_crfd); 215 216 /* Now the fun stuff... */ 217 if (bfd_header_big_endian (abfd)) 218 { 219 intern->lang = ((ext->f_bits1[0] & FDR_BITS1_LANG_BIG) 220 >> FDR_BITS1_LANG_SH_BIG); 221 intern->fMerge = 0 != (ext->f_bits1[0] & FDR_BITS1_FMERGE_BIG); 222 intern->fReadin = 0 != (ext->f_bits1[0] & FDR_BITS1_FREADIN_BIG); 223 intern->fBigendian = 0 != (ext->f_bits1[0] & FDR_BITS1_FBIGENDIAN_BIG); 224 intern->glevel = ((ext->f_bits2[0] & FDR_BITS2_GLEVEL_BIG) 225 >> FDR_BITS2_GLEVEL_SH_BIG); 226 } 227 else 228 { 229 intern->lang = ((ext->f_bits1[0] & FDR_BITS1_LANG_LITTLE) 230 >> FDR_BITS1_LANG_SH_LITTLE); 231 intern->fMerge = 0 != (ext->f_bits1[0] & FDR_BITS1_FMERGE_LITTLE); 232 intern->fReadin = 0 != (ext->f_bits1[0] & FDR_BITS1_FREADIN_LITTLE); 233 intern->fBigendian = 0 != (ext->f_bits1[0] & FDR_BITS1_FBIGENDIAN_LITTLE); 234 intern->glevel = ((ext->f_bits2[0] & FDR_BITS2_GLEVEL_LITTLE) 235 >> FDR_BITS2_GLEVEL_SH_LITTLE); 236 } 237 intern->reserved = 0; 238 239 intern->cbLineOffset = ECOFF_GET_OFF (abfd, ext->f_cbLineOffset); 240 intern->cbLine = ECOFF_GET_OFF (abfd, ext->f_cbLine); 241 242 #ifdef TEST 243 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 244 abort (); 245 #endif 246 } 247 248 /* Swap out the file descriptor record. */ 249 250 static void 251 ecoff_swap_fdr_out (bfd *abfd, const FDR *intern_copy, void * ext_ptr) 252 { 253 struct fdr_ext *ext = (struct fdr_ext *) ext_ptr; 254 FDR intern[1]; 255 256 /* Make it reasonable to do in-place. */ 257 *intern = *intern_copy; 258 259 ECOFF_PUT_OFF (abfd, intern->adr, ext->f_adr); 260 H_PUT_32 (abfd, intern->rss, ext->f_rss); 261 H_PUT_32 (abfd, intern->issBase, ext->f_issBase); 262 ECOFF_PUT_OFF (abfd, intern->cbSs, ext->f_cbSs); 263 H_PUT_32 (abfd, intern->isymBase, ext->f_isymBase); 264 H_PUT_32 (abfd, intern->csym, ext->f_csym); 265 H_PUT_32 (abfd, intern->ilineBase, ext->f_ilineBase); 266 H_PUT_32 (abfd, intern->cline, ext->f_cline); 267 H_PUT_32 (abfd, intern->ioptBase, ext->f_ioptBase); 268 H_PUT_32 (abfd, intern->copt, ext->f_copt); 269 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32) 270 H_PUT_16 (abfd, intern->ipdFirst, ext->f_ipdFirst); 271 H_PUT_16 (abfd, intern->cpd, ext->f_cpd); 272 #endif 273 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 274 H_PUT_32 (abfd, intern->ipdFirst, ext->f_ipdFirst); 275 H_PUT_32 (abfd, intern->cpd, ext->f_cpd); 276 #endif 277 H_PUT_32 (abfd, intern->iauxBase, ext->f_iauxBase); 278 H_PUT_32 (abfd, intern->caux, ext->f_caux); 279 H_PUT_32 (abfd, intern->rfdBase, ext->f_rfdBase); 280 H_PUT_32 (abfd, intern->crfd, ext->f_crfd); 281 282 /* Now the fun stuff... */ 283 if (bfd_header_big_endian (abfd)) 284 { 285 ext->f_bits1[0] = (((intern->lang << FDR_BITS1_LANG_SH_BIG) 286 & FDR_BITS1_LANG_BIG) 287 | (intern->fMerge ? FDR_BITS1_FMERGE_BIG : 0) 288 | (intern->fReadin ? FDR_BITS1_FREADIN_BIG : 0) 289 | (intern->fBigendian ? FDR_BITS1_FBIGENDIAN_BIG : 0)); 290 ext->f_bits2[0] = ((intern->glevel << FDR_BITS2_GLEVEL_SH_BIG) 291 & FDR_BITS2_GLEVEL_BIG); 292 ext->f_bits2[1] = 0; 293 ext->f_bits2[2] = 0; 294 } 295 else 296 { 297 ext->f_bits1[0] = (((intern->lang << FDR_BITS1_LANG_SH_LITTLE) 298 & FDR_BITS1_LANG_LITTLE) 299 | (intern->fMerge ? FDR_BITS1_FMERGE_LITTLE : 0) 300 | (intern->fReadin ? FDR_BITS1_FREADIN_LITTLE : 0) 301 | (intern->fBigendian ? FDR_BITS1_FBIGENDIAN_LITTLE : 0)); 302 ext->f_bits2[0] = ((intern->glevel << FDR_BITS2_GLEVEL_SH_LITTLE) 303 & FDR_BITS2_GLEVEL_LITTLE); 304 ext->f_bits2[1] = 0; 305 ext->f_bits2[2] = 0; 306 } 307 308 ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->f_cbLineOffset); 309 ECOFF_PUT_OFF (abfd, intern->cbLine, ext->f_cbLine); 310 311 #ifdef TEST 312 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 313 abort (); 314 #endif 315 } 316 317 /* Swap in the procedure descriptor record. */ 318 319 static void 320 ecoff_swap_pdr_in (bfd *abfd, void * ext_copy, PDR *intern) 321 { 322 struct pdr_ext ext[1]; 323 324 *ext = *(struct pdr_ext *) ext_copy; 325 326 memset ((void *) intern, 0, sizeof (*intern)); 327 328 intern->adr = ECOFF_GET_OFF (abfd, ext->p_adr); 329 intern->isym = H_GET_32 (abfd, ext->p_isym); 330 intern->iline = H_GET_32 (abfd, ext->p_iline); 331 intern->regmask = H_GET_32 (abfd, ext->p_regmask); 332 intern->regoffset = H_GET_S32 (abfd, ext->p_regoffset); 333 intern->iopt = H_GET_S32 (abfd, ext->p_iopt); 334 intern->fregmask = H_GET_32 (abfd, ext->p_fregmask); 335 intern->fregoffset = H_GET_S32 (abfd, ext->p_fregoffset); 336 intern->frameoffset = H_GET_S32 (abfd, ext->p_frameoffset); 337 intern->framereg = H_GET_16 (abfd, ext->p_framereg); 338 intern->pcreg = H_GET_16 (abfd, ext->p_pcreg); 339 intern->lnLow = H_GET_32 (abfd, ext->p_lnLow); 340 intern->lnHigh = H_GET_32 (abfd, ext->p_lnHigh); 341 intern->cbLineOffset = ECOFF_GET_OFF (abfd, ext->p_cbLineOffset); 342 343 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 344 if (intern->isym == (signed long) 0xffffffff) 345 intern->isym = -1; 346 if (intern->iline == (signed long) 0xffffffff) 347 intern->iline = -1; 348 349 intern->gp_prologue = H_GET_8 (abfd, ext->p_gp_prologue); 350 if (bfd_header_big_endian (abfd)) 351 { 352 intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_BIG); 353 intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_BIG); 354 intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_BIG); 355 intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_BIG) 356 << PDR_BITS1_RESERVED_SH_LEFT_BIG) 357 | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_BIG) 358 >> PDR_BITS2_RESERVED_SH_BIG)); 359 } 360 else 361 { 362 intern->gp_used = 0 != (ext->p_bits1[0] & PDR_BITS1_GP_USED_LITTLE); 363 intern->reg_frame = 0 != (ext->p_bits1[0] & PDR_BITS1_REG_FRAME_LITTLE); 364 intern->prof = 0 != (ext->p_bits1[0] & PDR_BITS1_PROF_LITTLE); 365 intern->reserved = (((ext->p_bits1[0] & PDR_BITS1_RESERVED_LITTLE) 366 >> PDR_BITS1_RESERVED_SH_LITTLE) 367 | ((ext->p_bits2[0] & PDR_BITS2_RESERVED_LITTLE) 368 << PDR_BITS2_RESERVED_SH_LEFT_LITTLE)); 369 } 370 intern->localoff = H_GET_8 (abfd, ext->p_localoff); 371 #endif 372 373 #ifdef TEST 374 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 375 abort (); 376 #endif 377 } 378 379 /* Swap out the procedure descriptor record. */ 380 381 static void 382 ecoff_swap_pdr_out (bfd *abfd, const PDR *intern_copy, void * ext_ptr) 383 { 384 struct pdr_ext *ext = (struct pdr_ext *) ext_ptr; 385 PDR intern[1]; 386 387 /* Make it reasonable to do in-place. */ 388 *intern = *intern_copy; 389 390 ECOFF_PUT_OFF (abfd, intern->adr, ext->p_adr); 391 H_PUT_32 (abfd, intern->isym, ext->p_isym); 392 H_PUT_32 (abfd, intern->iline, ext->p_iline); 393 H_PUT_32 (abfd, intern->regmask, ext->p_regmask); 394 H_PUT_32 (abfd, intern->regoffset, ext->p_regoffset); 395 H_PUT_32 (abfd, intern->iopt, ext->p_iopt); 396 H_PUT_32 (abfd, intern->fregmask, ext->p_fregmask); 397 H_PUT_32 (abfd, intern->fregoffset, ext->p_fregoffset); 398 H_PUT_32 (abfd, intern->frameoffset, ext->p_frameoffset); 399 H_PUT_16 (abfd, intern->framereg, ext->p_framereg); 400 H_PUT_16 (abfd, intern->pcreg, ext->p_pcreg); 401 H_PUT_32 (abfd, intern->lnLow, ext->p_lnLow); 402 H_PUT_32 (abfd, intern->lnHigh, ext->p_lnHigh); 403 ECOFF_PUT_OFF (abfd, intern->cbLineOffset, ext->p_cbLineOffset); 404 405 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 406 H_PUT_8 (abfd, intern->gp_prologue, ext->p_gp_prologue); 407 408 if (bfd_header_big_endian (abfd)) 409 { 410 ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_BIG : 0) 411 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_BIG : 0) 412 | (intern->prof ? PDR_BITS1_PROF_BIG : 0) 413 | ((intern->reserved 414 >> PDR_BITS1_RESERVED_SH_LEFT_BIG) 415 & PDR_BITS1_RESERVED_BIG)); 416 ext->p_bits2[0] = ((intern->reserved << PDR_BITS2_RESERVED_SH_BIG) 417 & PDR_BITS2_RESERVED_BIG); 418 } 419 else 420 { 421 ext->p_bits1[0] = ((intern->gp_used ? PDR_BITS1_GP_USED_LITTLE : 0) 422 | (intern->reg_frame ? PDR_BITS1_REG_FRAME_LITTLE : 0) 423 | (intern->prof ? PDR_BITS1_PROF_LITTLE : 0) 424 | ((intern->reserved << PDR_BITS1_RESERVED_SH_LITTLE) 425 & PDR_BITS1_RESERVED_LITTLE)); 426 ext->p_bits2[0] = ((intern->reserved >> 427 PDR_BITS2_RESERVED_SH_LEFT_LITTLE) 428 & PDR_BITS2_RESERVED_LITTLE); 429 } 430 H_PUT_8 (abfd, intern->localoff, ext->p_localoff); 431 #endif 432 433 #ifdef TEST 434 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 435 abort (); 436 #endif 437 } 438 439 /* Swap in a symbol record. */ 440 441 static void 442 ecoff_swap_sym_in (bfd *abfd, void * ext_copy, SYMR *intern) 443 { 444 struct sym_ext ext[1]; 445 446 *ext = *(struct sym_ext *) ext_copy; 447 448 intern->iss = H_GET_32 (abfd, ext->s_iss); 449 intern->value = ECOFF_GET_OFF (abfd, ext->s_value); 450 451 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 452 if (intern->iss == (signed long) 0xffffffff) 453 intern->iss = -1; 454 #endif 455 456 /* Now the fun stuff... */ 457 if (bfd_header_big_endian (abfd)) 458 { 459 intern->st = (ext->s_bits1[0] & SYM_BITS1_ST_BIG) 460 >> SYM_BITS1_ST_SH_BIG; 461 intern->sc = ((ext->s_bits1[0] & SYM_BITS1_SC_BIG) 462 << SYM_BITS1_SC_SH_LEFT_BIG) 463 | ((ext->s_bits2[0] & SYM_BITS2_SC_BIG) 464 >> SYM_BITS2_SC_SH_BIG); 465 intern->reserved = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_BIG); 466 intern->index = ((ext->s_bits2[0] & SYM_BITS2_INDEX_BIG) 467 << SYM_BITS2_INDEX_SH_LEFT_BIG) 468 | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_BIG) 469 | (ext->s_bits4[0] << SYM_BITS4_INDEX_SH_LEFT_BIG); 470 } 471 else 472 { 473 intern->st = (ext->s_bits1[0] & SYM_BITS1_ST_LITTLE) 474 >> SYM_BITS1_ST_SH_LITTLE; 475 intern->sc = ((ext->s_bits1[0] & SYM_BITS1_SC_LITTLE) 476 >> SYM_BITS1_SC_SH_LITTLE) 477 | ((ext->s_bits2[0] & SYM_BITS2_SC_LITTLE) 478 << SYM_BITS2_SC_SH_LEFT_LITTLE); 479 intern->reserved = 0 != (ext->s_bits2[0] & SYM_BITS2_RESERVED_LITTLE); 480 intern->index = ((ext->s_bits2[0] & SYM_BITS2_INDEX_LITTLE) 481 >> SYM_BITS2_INDEX_SH_LITTLE) 482 | (ext->s_bits3[0] << SYM_BITS3_INDEX_SH_LEFT_LITTLE) 483 | ((unsigned int) ext->s_bits4[0] 484 << SYM_BITS4_INDEX_SH_LEFT_LITTLE); 485 } 486 487 #ifdef TEST 488 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 489 abort (); 490 #endif 491 } 492 493 /* Swap out a symbol record. */ 494 495 static void 496 ecoff_swap_sym_out (bfd *abfd, const SYMR *intern_copy, void * ext_ptr) 497 { 498 struct sym_ext *ext = (struct sym_ext *) ext_ptr; 499 SYMR intern[1]; 500 501 /* Make it reasonable to do in-place. */ 502 *intern = *intern_copy; 503 504 H_PUT_32 (abfd, intern->iss, ext->s_iss); 505 ECOFF_PUT_OFF (abfd, intern->value, ext->s_value); 506 507 /* Now the fun stuff... */ 508 if (bfd_header_big_endian (abfd)) 509 { 510 ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_BIG) 511 & SYM_BITS1_ST_BIG) 512 | ((intern->sc >> SYM_BITS1_SC_SH_LEFT_BIG) 513 & SYM_BITS1_SC_BIG)); 514 ext->s_bits2[0] = (((intern->sc << SYM_BITS2_SC_SH_BIG) 515 & SYM_BITS2_SC_BIG) 516 | (intern->reserved ? SYM_BITS2_RESERVED_BIG : 0) 517 | ((intern->index >> SYM_BITS2_INDEX_SH_LEFT_BIG) 518 & SYM_BITS2_INDEX_BIG)); 519 ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_BIG) & 0xff; 520 ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_BIG) & 0xff; 521 } 522 else 523 { 524 ext->s_bits1[0] = (((intern->st << SYM_BITS1_ST_SH_LITTLE) 525 & SYM_BITS1_ST_LITTLE) 526 | ((intern->sc << SYM_BITS1_SC_SH_LITTLE) 527 & SYM_BITS1_SC_LITTLE)); 528 ext->s_bits2[0] = (((intern->sc >> SYM_BITS2_SC_SH_LEFT_LITTLE) 529 & SYM_BITS2_SC_LITTLE) 530 | (intern->reserved ? SYM_BITS2_RESERVED_LITTLE : 0) 531 | ((intern->index << SYM_BITS2_INDEX_SH_LITTLE) 532 & SYM_BITS2_INDEX_LITTLE)); 533 ext->s_bits3[0] = (intern->index >> SYM_BITS3_INDEX_SH_LEFT_LITTLE) & 0xff; 534 ext->s_bits4[0] = (intern->index >> SYM_BITS4_INDEX_SH_LEFT_LITTLE) & 0xff; 535 } 536 537 #ifdef TEST 538 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 539 abort (); 540 #endif 541 } 542 543 /* Swap in an external symbol record. */ 544 545 static void 546 ecoff_swap_ext_in (bfd *abfd, void * ext_copy, EXTR *intern) 547 { 548 struct ext_ext ext[1]; 549 550 *ext = *(struct ext_ext *) ext_copy; 551 552 /* Now the fun stuff... */ 553 if (bfd_header_big_endian (abfd)) 554 { 555 intern->jmptbl = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_BIG); 556 intern->cobol_main = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_BIG); 557 intern->weakext = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_BIG); 558 } 559 else 560 { 561 intern->jmptbl = 0 != (ext->es_bits1[0] & EXT_BITS1_JMPTBL_LITTLE); 562 intern->cobol_main = 0 != (ext->es_bits1[0] & EXT_BITS1_COBOL_MAIN_LITTLE); 563 intern->weakext = 0 != (ext->es_bits1[0] & EXT_BITS1_WEAKEXT_LITTLE); 564 } 565 intern->reserved = 0; 566 567 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32) 568 intern->ifd = H_GET_S16 (abfd, ext->es_ifd); 569 #endif 570 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 571 intern->ifd = H_GET_S32 (abfd, ext->es_ifd); 572 #endif 573 574 ecoff_swap_sym_in (abfd, &ext->es_asym, &intern->asym); 575 576 #ifdef TEST 577 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 578 abort (); 579 #endif 580 } 581 582 /* Swap out an external symbol record. */ 583 584 static void 585 ecoff_swap_ext_out (bfd *abfd, const EXTR *intern_copy, void * ext_ptr) 586 { 587 struct ext_ext *ext = (struct ext_ext *) ext_ptr; 588 EXTR intern[1]; 589 590 /* Make it reasonable to do in-place. */ 591 *intern = *intern_copy; 592 593 /* Now the fun stuff... */ 594 if (bfd_header_big_endian (abfd)) 595 { 596 ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_BIG : 0) 597 | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_BIG : 0) 598 | (intern->weakext ? EXT_BITS1_WEAKEXT_BIG : 0)); 599 ext->es_bits2[0] = 0; 600 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 601 ext->es_bits2[1] = 0; 602 ext->es_bits2[2] = 0; 603 #endif 604 } 605 else 606 { 607 ext->es_bits1[0] = ((intern->jmptbl ? EXT_BITS1_JMPTBL_LITTLE : 0) 608 | (intern->cobol_main ? EXT_BITS1_COBOL_MAIN_LITTLE : 0) 609 | (intern->weakext ? EXT_BITS1_WEAKEXT_LITTLE : 0)); 610 ext->es_bits2[0] = 0; 611 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 612 ext->es_bits2[1] = 0; 613 ext->es_bits2[2] = 0; 614 #endif 615 } 616 617 #if defined (ECOFF_32) || defined (ECOFF_SIGNED_32) 618 H_PUT_S16 (abfd, intern->ifd, ext->es_ifd); 619 #endif 620 #if defined (ECOFF_64) || defined (ECOFF_SIGNED_64) 621 H_PUT_S32 (abfd, intern->ifd, ext->es_ifd); 622 #endif 623 624 ecoff_swap_sym_out (abfd, &intern->asym, &ext->es_asym); 625 626 #ifdef TEST 627 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 628 abort (); 629 #endif 630 } 631 632 /* Swap in a relative file descriptor. */ 633 634 static void 635 ecoff_swap_rfd_in (bfd *abfd, void * ext_ptr, RFDT *intern) 636 { 637 struct rfd_ext *ext = (struct rfd_ext *) ext_ptr; 638 639 *intern = H_GET_32 (abfd, ext->rfd); 640 641 #ifdef TEST 642 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 643 abort (); 644 #endif 645 } 646 647 /* Swap out a relative file descriptor. */ 648 649 static void 650 ecoff_swap_rfd_out (bfd *abfd, const RFDT *intern, void * ext_ptr) 651 { 652 struct rfd_ext *ext = (struct rfd_ext *) ext_ptr; 653 654 H_PUT_32 (abfd, *intern, ext->rfd); 655 656 #ifdef TEST 657 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 658 abort (); 659 #endif 660 } 661 662 /* Swap in an optimization symbol. */ 663 664 static void 665 ecoff_swap_opt_in (bfd *abfd, void * ext_copy, OPTR * intern) 666 { 667 struct opt_ext ext[1]; 668 669 *ext = *(struct opt_ext *) ext_copy; 670 671 if (bfd_header_big_endian (abfd)) 672 { 673 intern->ot = ext->o_bits1[0]; 674 intern->value = (((unsigned int) ext->o_bits2[0] 675 << OPT_BITS2_VALUE_SH_LEFT_BIG) 676 | ((unsigned int) ext->o_bits3[0] 677 << OPT_BITS2_VALUE_SH_LEFT_BIG) 678 | ((unsigned int) ext->o_bits4[0] 679 << OPT_BITS2_VALUE_SH_LEFT_BIG)); 680 } 681 else 682 { 683 intern->ot = ext->o_bits1[0]; 684 intern->value = ((ext->o_bits2[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE) 685 | (ext->o_bits3[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE) 686 | (ext->o_bits4[0] << OPT_BITS2_VALUE_SH_LEFT_LITTLE)); 687 } 688 689 _bfd_ecoff_swap_rndx_in (bfd_header_big_endian (abfd), 690 &ext->o_rndx, &intern->rndx); 691 692 intern->offset = H_GET_32 (abfd, ext->o_offset); 693 694 #ifdef TEST 695 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 696 abort (); 697 #endif 698 } 699 700 /* Swap out an optimization symbol. */ 701 702 static void 703 ecoff_swap_opt_out (bfd *abfd, const OPTR *intern_copy, void * ext_ptr) 704 { 705 struct opt_ext *ext = (struct opt_ext *) ext_ptr; 706 OPTR intern[1]; 707 708 /* Make it reasonable to do in-place. */ 709 *intern = *intern_copy; 710 711 if (bfd_header_big_endian (abfd)) 712 { 713 ext->o_bits1[0] = intern->ot; 714 ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_BIG; 715 ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_BIG; 716 ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_BIG; 717 } 718 else 719 { 720 ext->o_bits1[0] = intern->ot; 721 ext->o_bits2[0] = intern->value >> OPT_BITS2_VALUE_SH_LEFT_LITTLE; 722 ext->o_bits3[0] = intern->value >> OPT_BITS3_VALUE_SH_LEFT_LITTLE; 723 ext->o_bits4[0] = intern->value >> OPT_BITS4_VALUE_SH_LEFT_LITTLE; 724 } 725 726 _bfd_ecoff_swap_rndx_out (bfd_header_big_endian (abfd), 727 &intern->rndx, &ext->o_rndx); 728 729 H_PUT_32 (abfd, intern->value, ext->o_offset); 730 731 #ifdef TEST 732 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 733 abort (); 734 #endif 735 } 736 737 /* Swap in a dense number. */ 738 739 static void 740 ecoff_swap_dnr_in (bfd *abfd, void * ext_copy, DNR *intern) 741 { 742 struct dnr_ext ext[1]; 743 744 *ext = *(struct dnr_ext *) ext_copy; 745 746 intern->rfd = H_GET_32 (abfd, ext->d_rfd); 747 intern->index = H_GET_32 (abfd, ext->d_index); 748 749 #ifdef TEST 750 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 751 abort (); 752 #endif 753 } 754 755 /* Swap out a dense number. */ 756 757 static void 758 ecoff_swap_dnr_out (bfd *abfd, const DNR *intern_copy, void * ext_ptr) 759 { 760 struct dnr_ext *ext = (struct dnr_ext *) ext_ptr; 761 DNR intern[1]; 762 763 /* Make it reasonable to do in-place. */ 764 *intern = *intern_copy; 765 766 H_PUT_32 (abfd, intern->rfd, ext->d_rfd); 767 H_PUT_32 (abfd, intern->index, ext->d_index); 768 769 #ifdef TEST 770 if (memcmp ((char *) ext, (char *) intern, sizeof (*intern)) != 0) 771 abort (); 772 #endif 773 } 774