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