srconv.c revision 1.10
1 /* srconv.c -- Sysroff conversion program 2 Copyright (C) 1994-2025 Free Software Foundation, Inc. 3 4 This file is part of GNU Binutils. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 /* Written by Steve Chamberlain (sac (at) cygnus.com) 22 23 This program can be used to convert a coff object file 24 into a Hitachi OM/LM (Sysroff) format. 25 26 All debugging information is preserved */ 27 28 #include "sysdep.h" 29 #include "bfd.h" 30 #include "bucomm.h" 31 #include "sysroff.h" 32 #include "coffgrok.h" 33 #include "libiberty.h" 34 #include "filenames.h" 35 #include "getopt.h" 36 37 #include "coff/internal.h" 38 #include "../bfd/libcoff.h" 39 40 /*#define FOOP1 1 */ 41 42 static int addrsize; 43 static char *toolname; 44 static char **rnames; 45 46 static void walk_tree_symbol 47 (struct coff_sfile *, struct coff_section *, struct coff_symbol *, int); 48 static void walk_tree_scope 49 (struct coff_section *, struct coff_sfile *, struct coff_scope *, int, int); 50 static int find_base (struct coff_sfile *, struct coff_section *); 51 static void wr_globals (struct coff_ofile *, struct coff_sfile *, int); 52 53 static FILE *file; 54 static bfd *abfd; 55 static int debug = 0; 56 static int quick = 0; 57 static int noprescan = 0; 58 static struct coff_ofile *tree; 59 /* Obsolete ?? 60 static int absolute_p; 61 */ 62 63 static int segmented_p; 64 static int code; 65 66 static int ids1[20000]; 67 static int ids2[20000]; 68 69 static int base1 = 0x18; 70 static int base2 = 0x2018; 71 72 static int 73 get_member_id (int x) 74 { 75 if (ids2[x]) 76 return ids2[x]; 77 78 ids2[x] = base2++; 79 return ids2[x]; 80 } 81 82 static int 83 get_ordinary_id (int x) 84 { 85 if (ids1[x]) 86 return ids1[x]; 87 88 ids1[x] = base1++; 89 return ids1[x]; 90 } 91 static char * 92 section_translate (char *n) 93 { 94 if (strcmp (n, ".text") == 0) 95 return "P"; 96 if (strcmp (n, ".data") == 0) 97 return "D"; 98 if (strcmp (n, ".bss") == 0) 99 return "B"; 100 return n; 101 } 102 103 #define DATE "940201073000"; /* Just a time on my birthday */ 104 105 static char * 106 strip_suffix (const char *name) 107 { 108 int i; 109 char *res; 110 111 for (i = 0; name[i] != 0 && name[i] != '.'; i++) 112 ; 113 res = (char *) xmalloc (i + 1); 114 memcpy (res, name, i); 115 res[i] = 0; 116 return res; 117 } 118 119 /* IT LEN stuff CS */ 120 static void 121 checksum (FILE *ffile, unsigned char *ptr, int size, int ccode) 122 { 123 int j; 124 int last; 125 int sum = 0; 126 int bytes = size / 8; 127 128 last = !(ccode & 0xff00); 129 if (size & 0x7) 130 fatal (_("Checksum failure")); 131 132 ptr[0] = ccode | (last ? 0x80 : 0); 133 ptr[1] = bytes + 1; 134 135 for (j = 0; j < bytes; j++) 136 sum += ptr[j]; 137 138 /* Glue on a checksum too. */ 139 ptr[bytes] = ~sum; 140 if (fwrite (ptr, bytes + 1, 1, ffile) != 1) 141 /* FIXME: Return error status. */ 142 fatal (_("Failed to write checksum")); 143 } 144 145 146 static void 147 writeINT (int n, unsigned char *ptr, int *idx, int size, FILE *ffile) 148 { 149 int byte = *idx / 8; 150 151 if (size == -2) 152 size = addrsize; 153 else if (size == -1) 154 size = 0; 155 156 if (byte > 240) 157 { 158 /* Lets write out that record and do another one. */ 159 checksum (ffile, ptr, *idx, code | 0x1000); 160 *idx = 16; 161 byte = *idx / 8; 162 } 163 164 switch (size) 165 { 166 case 0: 167 break; 168 case 1: 169 ptr[byte] = n; 170 break; 171 case 2: 172 ptr[byte + 0] = n >> 8; 173 ptr[byte + 1] = n; 174 break; 175 case 4: 176 ptr[byte + 0] = n >> 24; 177 ptr[byte + 1] = n >> 16; 178 ptr[byte + 2] = n >> 8; 179 ptr[byte + 3] = n >> 0; 180 break; 181 default: 182 fatal (_("Unsupported integer write size: %d"), size); 183 } 184 *idx += size * 8; 185 } 186 187 static void 188 writeBITS (int val, unsigned char *ptr, int *idx, int size) 189 { 190 int byte = *idx / 8; 191 int bit = *idx % 8; 192 int old; 193 194 *idx += size; 195 196 old = ptr[byte]; 197 /* Turn off all about to change bits. */ 198 old &= ~((~0 >> (8 - bit - size)) & ((1 << size) - 1)); 199 /* Turn on the bits we want. */ 200 old |= (val & ((1 << size) - 1)) << (8 - bit - size); 201 ptr[byte] = old; 202 } 203 204 static void 205 writeBARRAY (barray data, unsigned char *ptr, int *idx, 206 int size ATTRIBUTE_UNUSED, FILE *ffile) 207 { 208 int i; 209 210 writeINT (data.len, ptr, idx, 1, ffile); 211 for (i = 0; i < data.len; i++) 212 writeINT (data.data[i], ptr, idx, 1, ffile); 213 } 214 215 static void 216 writeCHARS (char *string, unsigned char *ptr, int *idx, int size, FILE *ffile) 217 { 218 int i = *idx / 8; 219 220 if (i > 240) 221 { 222 /* Lets write out that record and do another one. */ 223 checksum (ffile, ptr, *idx, code | 0x1000); 224 *idx = 16; 225 i = *idx / 8; 226 } 227 228 if (size == 0) 229 { 230 /* Variable length string. */ 231 size = strlen (string); 232 ptr[i++] = size; 233 } 234 235 /* BUG WAITING TO HAPPEN. */ 236 memcpy (ptr + i, string, size); 237 i += size; 238 *idx = i * 8; 239 } 240 241 #define SYSROFF_SWAP_OUT 242 #include "sysroff.c" 243 244 static char *rname_sh[] = 245 { 246 "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15" 247 }; 248 249 static char *rname_h8300[] = 250 { 251 "ER0", "ER1", "ER2", "ER3", "ER4", "ER5", "ER6", "ER7", "PC", "CCR" 252 }; 253 254 static void 255 wr_tr (void) 256 { 257 /* The TR block is not normal - it doesn't have any contents. */ 258 259 static char b[] = 260 { 261 0xff, /* IT */ 262 0x03, /* RL */ 263 0xfd, /* CS */ 264 }; 265 266 if (fwrite (b, sizeof (b), 1, file) != 1) 267 /* FIXME: Return error status. */ 268 fatal (_("Failed to write TR block")); 269 } 270 271 static void 272 wr_un (struct coff_ofile *ptr, struct coff_sfile *sfile, int first, 273 int nsecs ATTRIBUTE_UNUSED) 274 { 275 struct IT_un un; 276 struct coff_symbol *s; 277 278 un.spare1 = 0; 279 280 if (bfd_get_file_flags (abfd) & EXEC_P) 281 un.format = FORMAT_LM; 282 else 283 un.format = FORMAT_OM; 284 un.spare1 = 0; 285 286 /* Don't count the abs section. */ 287 un.nsections = ptr->nsections - 1; 288 289 un.nextdefs = 0; 290 un.nextrefs = 0; 291 /* Count all the undefined and defined variables with global scope. */ 292 293 if (first) 294 { 295 for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list) 296 { 297 if (s->visible->type == coff_vis_ext_def 298 || s->visible->type == coff_vis_common) 299 un.nextdefs++; 300 301 if (s->visible->type == coff_vis_ext_ref) 302 un.nextrefs++; 303 } 304 } 305 un.tool = toolname; 306 un.tcd = DATE; 307 un.linker = "L_GX00"; 308 un.lcd = DATE; 309 un.name = sfile->name; 310 sysroff_swap_un_out (file, &un); 311 } 312 313 static void 314 wr_hd (struct coff_ofile *p) 315 { 316 struct IT_hd hd; 317 318 hd.spare1 = 0; 319 hd.spare2 = 0; 320 if (bfd_get_file_flags (abfd) & EXEC_P) 321 hd.mt = MTYPE_ABS_LM; 322 else 323 hd.mt = MTYPE_OMS_OR_LMS; 324 325 hd.cd = DATE; 326 327 hd.nu = p->nsources; /* Always one unit */ 328 hd.code = 0; /* Always ASCII */ 329 hd.ver = "0200"; /* Version 2.00 */ 330 331 switch (bfd_get_arch (abfd)) 332 { 333 case bfd_arch_h8300: 334 hd.au = 8; 335 hd.si = 0; 336 hd.spcsz = 32; 337 hd.segsz = 0; 338 hd.segsh = 0; 339 switch (bfd_get_mach (abfd)) 340 { 341 case bfd_mach_h8300: 342 hd.cpu = "H8300"; 343 hd.afl = 2; 344 addrsize = 2; 345 toolname = "C_H8/300"; 346 break; 347 case bfd_mach_h8300h: 348 hd.cpu = "H8300H"; 349 hd.afl = 4; 350 addrsize = 4; 351 toolname = "C_H8/300H"; 352 break; 353 case bfd_mach_h8300s: 354 hd.cpu = "H8300S"; 355 hd.afl = 4; 356 addrsize = 4; 357 toolname = "C_H8/300S"; 358 break; 359 default: 360 fatal (_("Unrecognized H8300 sub-architecture: %ld"), 361 bfd_get_mach (abfd)); 362 } 363 rnames = rname_h8300; 364 break; 365 case bfd_arch_sh: 366 hd.au = 8; 367 hd.si = 0; 368 hd.afl = 4; 369 hd.spcsz = 32; 370 hd.segsz = 0; 371 hd.segsh = 0; 372 hd.cpu = "SH"; 373 addrsize = 4; 374 toolname = "C_SH"; 375 rnames = rname_sh; 376 break; 377 default: 378 fatal (_("Unsupported architecture: %d"), bfd_get_arch (abfd)); 379 } 380 381 if (! (bfd_get_file_flags(abfd) & EXEC_P)) 382 { 383 hd.ep = 0; 384 } 385 else 386 { 387 hd.ep = 1; 388 hd.uan = 0; 389 hd.sa = 0; 390 hd.sad = 0; 391 hd.address = bfd_get_start_address (abfd); 392 } 393 394 hd.os = ""; 395 hd.sys = ""; 396 hd.mn = strip_suffix (bfd_get_filename (abfd)); 397 398 sysroff_swap_hd_out (file, &hd); 399 } 400 401 402 static void 403 wr_sh (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *sec) 404 { 405 struct IT_sh sh; 406 sh.unit = 0; 407 sh.section = sec->number; 408 #ifdef FOOP1 409 sh.section = 0; 410 #endif 411 sysroff_swap_sh_out (file, &sh); 412 } 413 414 415 static void 416 wr_ob (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_section *section) 417 { 418 bfd_size_type i; 419 int first = 1; 420 unsigned char stuff[200]; 421 422 i = 0; 423 while (i < bfd_section_size (section->bfd_section)) 424 { 425 struct IT_ob ob; 426 int todo = 200; /* Copy in 200 byte lumps. */ 427 428 ob.spare = 0; 429 if (i + todo > bfd_section_size (section->bfd_section)) 430 todo = bfd_section_size (section->bfd_section) - i; 431 432 if (first) 433 { 434 ob.saf = 1; 435 if (bfd_get_file_flags (abfd) & EXEC_P) 436 ob.address = section->address; 437 else 438 ob.address = 0; 439 440 first = 0; 441 } 442 else 443 { 444 ob.saf = 0; 445 } 446 447 ob.cpf = 0; /* Never compress. */ 448 ob.data.len = todo; 449 bfd_get_section_contents (abfd, section->bfd_section, stuff, i, todo); 450 ob.data.data = stuff; 451 sysroff_swap_ob_out (file, &ob /*, i + todo < section->size */ ); 452 i += todo; 453 } 454 455 /* Now fill the rest with blanks. */ 456 while (i < (bfd_size_type) section->size) 457 { 458 struct IT_ob ob; 459 int todo = 200; /* Copy in 200 byte lumps. */ 460 461 ob.spare = 0; 462 if (i + todo > (bfd_size_type) section->size) 463 todo = section->size - i; 464 ob.saf = 0; 465 466 ob.cpf = 0; /* Never compress. */ 467 ob.data.len = todo; 468 memset (stuff, 0, todo); 469 ob.data.data = stuff; 470 sysroff_swap_ob_out (file, &ob); 471 i += todo; 472 } 473 /* Now fill the rest with blanks. */ 474 } 475 476 static void 477 wr_rl (struct coff_ofile *ptr ATTRIBUTE_UNUSED, struct coff_section *sec) 478 { 479 int nr = sec->nrelocs; 480 int i; 481 482 for (i = 0; i < nr; i++) 483 { 484 struct coff_reloc *r = sec->relocs + i; 485 struct coff_symbol *ref; 486 struct IT_rl rl; 487 488 rl.apol = 0; 489 rl.boundary = 0; 490 rl.segment = 1; 491 rl.sign = 0; 492 rl.check = 0; 493 rl.addr = r->offset; 494 rl.bitloc = 0; 495 rl.flen = 32; /* SH Specific. */ 496 497 /* What sort of reloc ? Look in the section to find out. */ 498 ref = r->symbol; 499 if (ref->visible->type == coff_vis_ext_ref) 500 { 501 rl.bcount = 4; /* Always 4 for us. */ 502 rl.op = OP_EXT_REF; 503 rl.symn = ref->er_number; 504 } 505 else if (ref->visible->type == coff_vis_common) 506 { 507 rl.bcount = 11; /* Always 11 for us. */ 508 rl.op = OP_SEC_REF; 509 rl.secn = ref->where->section->number; 510 rl.copcode_is_3 = 3; 511 rl.alength_is_4 = 4; 512 rl.addend = ref->where->offset - ref->where->section->address; 513 rl.aopcode_is_0x20 = 0x20; 514 } 515 else 516 { 517 rl.bcount = 11; /* Always 11 for us. */ 518 rl.op = OP_SEC_REF; 519 rl.secn = ref->where->section->number; 520 rl.copcode_is_3 = 3; 521 rl.alength_is_4 = 4; 522 rl.addend = -ref->where->section->address; 523 rl.aopcode_is_0x20 = 0x20; 524 } 525 526 rl.end = 0xff; 527 528 if ( rl.op == OP_SEC_REF 529 || rl.op == OP_EXT_REF) 530 sysroff_swap_rl_out (file, &rl); 531 } 532 } 533 534 static void 535 wr_object_body (struct coff_ofile *p) 536 { 537 int i; 538 539 for (i = 1; i < p->nsections; i++) 540 { 541 wr_sh (p, p->sections + i); 542 wr_ob (p, p->sections + i); 543 wr_rl (p, p->sections + i); 544 } 545 } 546 547 static void 548 wr_dps_start (struct coff_sfile *sfile, 549 struct coff_section *section ATTRIBUTE_UNUSED, 550 struct coff_scope *scope, int type, int nest) 551 { 552 struct IT_dps dps; 553 554 dps.end = 0; 555 dps.opt = 0; 556 dps.type = type; 557 558 if (scope->sec) 559 { 560 dps.san = scope->sec->number; 561 dps.address = scope->offset - find_base (sfile, scope->sec); 562 dps.block_size = scope->size; 563 564 if (debug) 565 { 566 printf ("DPS %s %d %x\n", 567 sfile->name, 568 nest, 569 dps.address); 570 } 571 } 572 else 573 { 574 dps.san = 0; 575 dps.address = 0; 576 dps.block_size = 0; 577 } 578 579 dps.nesting = nest; 580 dps.neg = 0x1001; 581 sysroff_swap_dps_out (file, &dps); 582 } 583 584 static void 585 wr_dps_end (struct coff_section *section ATTRIBUTE_UNUSED, 586 struct coff_scope *scope ATTRIBUTE_UNUSED, int type) 587 { 588 struct IT_dps dps; 589 590 dps.end = 1; 591 dps.type = type; 592 sysroff_swap_dps_out (file, &dps); 593 } 594 595 static int * 596 nints (int x) 597 { 598 return (int *) (xcalloc (x, sizeof (int))); 599 } 600 601 static void 602 walk_tree_type_1 (struct coff_sfile *sfile, struct coff_symbol *symbol, 603 struct coff_type *type, int nest) 604 { 605 switch (type->type) 606 { 607 case coff_secdef_type: 608 case coff_basic_type: 609 { 610 struct IT_dbt dbt; 611 612 switch (type->u.basic) 613 { 614 case T_NULL: 615 case T_VOID: 616 dbt.btype = BTYPE_VOID; 617 dbt.sign = BTYPE_UNSPEC; 618 dbt.fptype = FPTYPE_NOTSPEC; 619 break; 620 621 case T_CHAR: 622 dbt.btype = BTYPE_CHAR; 623 dbt.sign = BTYPE_UNSPEC; 624 dbt.fptype = FPTYPE_NOTSPEC; 625 break; 626 627 case T_SHORT: 628 case T_INT: 629 case T_LONG: 630 dbt.btype = BTYPE_INT; 631 dbt.sign = SIGN_SIGNED; 632 dbt.fptype = FPTYPE_NOTSPEC; 633 break; 634 635 case T_FLOAT: 636 dbt.btype = BTYPE_FLOAT; 637 dbt.fptype = FPTYPE_SINGLE; 638 break; 639 640 case T_DOUBLE: 641 dbt.btype = BTYPE_FLOAT; 642 dbt.fptype = FPTYPE_DOUBLE; 643 break; 644 645 case T_LNGDBL: 646 dbt.btype = BTYPE_FLOAT; 647 dbt.fptype = FPTYPE_EXTENDED; 648 break; 649 650 case T_UCHAR: 651 dbt.btype = BTYPE_CHAR; 652 dbt.sign = SIGN_UNSIGNED; 653 dbt.fptype = FPTYPE_NOTSPEC; 654 break; 655 656 case T_USHORT: 657 case T_UINT: 658 case T_ULONG: 659 dbt.btype = BTYPE_INT; 660 dbt.sign = SIGN_UNSIGNED; 661 dbt.fptype = FPTYPE_NOTSPEC; 662 break; 663 } 664 665 dbt.bitsize = type->size; 666 dbt.neg = 0x1001; 667 sysroff_swap_dbt_out (file, &dbt); 668 break; 669 } 670 671 case coff_pointer_type: 672 { 673 struct IT_dpt dpt; 674 675 dpt.dunno = 0; 676 walk_tree_type_1 (sfile, symbol, type->u.pointer.points_to, nest + 1); 677 dpt.neg = 0x1001; 678 sysroff_swap_dpt_out (file, &dpt); 679 break; 680 } 681 682 case coff_function_type: 683 { 684 struct IT_dfp dfp; 685 struct coff_symbol *param; 686 687 dfp.end = 0; 688 dfp.spare = 0; 689 dfp.nparams = type->u.function.parameters->nvars; 690 dfp.neg = 0x1001; 691 692 walk_tree_type_1 (sfile, symbol, type->u.function.function_returns, nest + 1); 693 694 sysroff_swap_dfp_out (file, &dfp); 695 696 for (param = type->u.function.parameters->vars_head; 697 param; 698 param = param->next) 699 walk_tree_symbol (sfile, 0, param, nest); 700 701 dfp.end = 1; 702 sysroff_swap_dfp_out (file, &dfp); 703 break; 704 } 705 706 case coff_structdef_type: 707 { 708 struct IT_dbt dbt; 709 struct IT_dds dds; 710 struct coff_symbol *member; 711 712 dds.spare = 0; 713 dbt.btype = BTYPE_STRUCT; 714 dbt.bitsize = type->size; 715 dbt.sign = SIGN_UNSPEC; 716 dbt.fptype = FPTYPE_NOTSPEC; 717 dbt.sid = get_member_id (type->u.astructdef.idx); 718 dbt.neg = 0x1001; 719 sysroff_swap_dbt_out (file, &dbt); 720 dds.end = 0; 721 dds.neg = 0x1001; 722 sysroff_swap_dds_out (file, &dds); 723 724 for (member = type->u.astructdef.elements->vars_head; 725 member; 726 member = member->next) 727 walk_tree_symbol (sfile, 0, member, nest + 1); 728 729 dds.end = 1; 730 sysroff_swap_dds_out (file, &dds); 731 732 } 733 break; 734 735 case coff_structref_type: 736 { 737 struct IT_dbt dbt; 738 739 dbt.btype = BTYPE_TAG; 740 dbt.bitsize = type->size; 741 dbt.sign = SIGN_UNSPEC; 742 dbt.fptype = FPTYPE_NOTSPEC; 743 744 if (type->u.astructref.ref) 745 dbt.sid = get_member_id (type->u.astructref.ref->number); 746 else 747 dbt.sid = 0; 748 749 dbt.neg = 0x1001; 750 sysroff_swap_dbt_out (file, &dbt); 751 } 752 break; 753 754 case coff_array_type: 755 { 756 struct IT_dar dar; 757 int j; 758 int dims = 1; /* Only output one dimension at a time. */ 759 760 dar.dims = dims; 761 dar.variable = nints (dims); 762 dar.subtype = nints (dims); 763 dar.spare = nints (dims); 764 dar.max_variable = nints (dims); 765 dar.maxspare = nints (dims); 766 dar.max = nints (dims); 767 dar.min_variable = nints (dims); 768 dar.min = nints (dims); 769 dar.minspare = nints (dims); 770 dar.neg = 0x1001; 771 dar.length = type->size / type->u.array.dim; 772 773 for (j = 0; j < dims; j++) 774 { 775 dar.variable[j] = VARIABLE_FIXED; 776 dar.subtype[j] = SUB_INTEGER; 777 dar.spare[j] = 0; 778 dar.max_variable[j] = 0; 779 dar.max[j] = type->u.array.dim; 780 dar.min_variable[j] = 0; 781 dar.min[j] = 1; /* Why isn't this 0 ? */ 782 } 783 walk_tree_type_1 (sfile, symbol, type->u.array.array_of, nest + 1); 784 sysroff_swap_dar_out (file, &dar); 785 } 786 break; 787 788 case coff_enumdef_type: 789 { 790 struct IT_dbt dbt; 791 struct IT_den den; 792 struct coff_symbol *member; 793 794 dbt.btype = BTYPE_ENUM; 795 dbt.bitsize = type->size; 796 dbt.sign = SIGN_UNSPEC; 797 dbt.fptype = FPTYPE_NOTSPEC; 798 dbt.sid = get_member_id (type->u.aenumdef.idx); 799 dbt.neg = 0x1001; 800 sysroff_swap_dbt_out (file, &dbt); 801 802 den.end = 0; 803 den.neg = 0x1001; 804 den.spare = 0; 805 sysroff_swap_den_out (file, &den); 806 807 for (member = type->u.aenumdef.elements->vars_head; 808 member; 809 member = member->next) 810 walk_tree_symbol (sfile, 0, member, nest + 1); 811 812 den.end = 1; 813 sysroff_swap_den_out (file, &den); 814 } 815 break; 816 817 case coff_enumref_type: 818 { 819 struct IT_dbt dbt; 820 821 dbt.btype = BTYPE_TAG; 822 dbt.bitsize = type->size; 823 dbt.sign = SIGN_UNSPEC; 824 dbt.fptype = FPTYPE_NOTSPEC; 825 dbt.sid = get_member_id (type->u.aenumref.ref->number); 826 dbt.neg = 0x1001; 827 sysroff_swap_dbt_out (file, &dbt); 828 } 829 break; 830 831 default: 832 fatal (_("Unrecognised type: %d"), type->type); 833 } 834 } 835 836 /* Obsolete ? 837 static void 838 dty_start () 839 { 840 struct IT_dty dty; 841 dty.end = 0; 842 dty.neg = 0x1001; 843 dty.spare = 0; 844 sysroff_swap_dty_out (file, &dty); 845 } 846 847 static void 848 dty_stop () 849 { 850 struct IT_dty dty; 851 dty.end = 0; 852 dty.neg = 0x1001; 853 dty.end = 1; 854 sysroff_swap_dty_out (file, &dty); 855 } 856 857 858 static void 859 dump_tree_structure (sfile, symbol, type, nest) 860 struct coff_sfile *sfile; 861 struct coff_symbol *symbol; 862 struct coff_type *type; 863 int nest; 864 { 865 if (symbol->type->type == coff_function_type) 866 { 867 868 869 } 870 871 } 872 */ 873 874 static void 875 walk_tree_type (struct coff_sfile *sfile, struct coff_symbol *symbol, 876 struct coff_type *type, int nest) 877 { 878 struct IT_dty dty; 879 880 dty.spare = 0; 881 dty.end = 0; 882 dty.neg = 0x1001; 883 884 if (symbol->type->type == coff_function_type) 885 { 886 sysroff_swap_dty_out (file, &dty); 887 walk_tree_type_1 (sfile, symbol, type, nest); 888 dty.end = 1; 889 sysroff_swap_dty_out (file, &dty); 890 891 wr_dps_start (sfile, 892 symbol->where->section, 893 symbol->type->u.function.code, 894 BLOCK_TYPE_FUNCTION, nest); 895 wr_dps_start (sfile, symbol->where->section, 896 symbol->type->u.function.code, 897 BLOCK_TYPE_BLOCK, nest); 898 walk_tree_scope (symbol->where->section, 899 sfile, 900 symbol->type->u.function.code, 901 nest + 1, BLOCK_TYPE_BLOCK); 902 903 wr_dps_end (symbol->where->section, 904 symbol->type->u.function.code, 905 BLOCK_TYPE_BLOCK); 906 wr_dps_end (symbol->where->section, 907 symbol->type->u.function.code, BLOCK_TYPE_FUNCTION); 908 } 909 else 910 { 911 sysroff_swap_dty_out (file, &dty); 912 walk_tree_type_1 (sfile, symbol, type, nest); 913 dty.end = 1; 914 sysroff_swap_dty_out (file, &dty); 915 } 916 } 917 918 static void 919 walk_tree_symbol (struct coff_sfile *sfile, struct coff_section *section ATTRIBUTE_UNUSED, struct coff_symbol *symbol, int nest) 920 { 921 struct IT_dsy dsy; 922 923 memset (&dsy, 0, sizeof(dsy)); 924 dsy.nesting = nest; 925 926 switch (symbol->type->type) 927 { 928 case coff_function_type: 929 dsy.type = STYPE_FUNC; 930 dsy.assign = 1; 931 break; 932 933 case coff_structref_type: 934 case coff_pointer_type: 935 case coff_array_type: 936 case coff_basic_type: 937 case coff_enumref_type: 938 dsy.type = STYPE_VAR; 939 dsy.assign = 1; 940 break; 941 942 case coff_enumdef_type: 943 dsy.type = STYPE_TAG; 944 dsy.assign = 0; 945 dsy.magic = 2; 946 break; 947 948 case coff_structdef_type: 949 dsy.type = STYPE_TAG; 950 dsy.assign = 0; 951 dsy.magic = symbol->type->u.astructdef.isstruct ? 0 : 1; 952 break; 953 954 case coff_secdef_type: 955 return; 956 957 default: 958 fatal (_("Unrecognised coff symbol type: %d"), symbol->type->type); 959 } 960 961 if (symbol->where->where == coff_where_member_of_struct) 962 { 963 dsy.assign = 0; 964 dsy.type = STYPE_MEMBER; 965 } 966 967 if (symbol->where->where == coff_where_member_of_enum) 968 { 969 dsy.type = STYPE_ENUM; 970 dsy.assign = 0; 971 dsy.evallen = 4; 972 dsy.evalue = symbol->where->offset; 973 } 974 975 if (symbol->type->type == coff_structdef_type 976 || symbol->where->where == coff_where_entag 977 || symbol->where->where == coff_where_strtag) 978 { 979 dsy.snumber = get_member_id (symbol->number); 980 } 981 else 982 { 983 dsy.snumber = get_ordinary_id (symbol->number); 984 } 985 986 dsy.sname = symbol->name[0] == '_' ? symbol->name + 1 : symbol->name; 987 988 switch (symbol->visible->type) 989 { 990 case coff_vis_common: 991 case coff_vis_ext_def: 992 dsy.ainfo = AINFO_STATIC_EXT_DEF; 993 break; 994 995 case coff_vis_ext_ref: 996 dsy.ainfo = AINFO_STATIC_EXT_REF; 997 break; 998 999 case coff_vis_int_def: 1000 dsy.ainfo = AINFO_STATIC_INT; 1001 break; 1002 1003 case coff_vis_auto: 1004 case coff_vis_autoparam: 1005 dsy.ainfo = AINFO_AUTO; 1006 break; 1007 1008 case coff_vis_register: 1009 case coff_vis_regparam: 1010 dsy.ainfo = AINFO_REG; 1011 break; 1012 break; 1013 1014 case coff_vis_tag: 1015 case coff_vis_member_of_struct: 1016 case coff_vis_member_of_enum: 1017 break; 1018 1019 default: 1020 fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type); 1021 } 1022 1023 dsy.dlength = symbol->type->size; 1024 1025 switch (symbol->where->where) 1026 { 1027 case coff_where_memory: 1028 1029 dsy.section = symbol->where->section->number; 1030 #ifdef FOOP 1031 dsy.section = 0; 1032 #endif 1033 break; 1034 1035 case coff_where_member_of_struct: 1036 case coff_where_member_of_enum: 1037 case coff_where_stack: 1038 case coff_where_register: 1039 case coff_where_unknown: 1040 case coff_where_strtag: 1041 case coff_where_entag: 1042 case coff_where_typedef: 1043 break; 1044 1045 default: 1046 fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); 1047 } 1048 1049 switch (symbol->where->where) 1050 { 1051 case coff_where_memory: 1052 dsy.address = symbol->where->offset - find_base (sfile, symbol->where->section); 1053 break; 1054 1055 case coff_where_stack: 1056 dsy.address = symbol->where->offset; 1057 break; 1058 1059 case coff_where_member_of_struct: 1060 if (symbol->where->bitsize) 1061 { 1062 int bits = (symbol->where->offset * 8 + symbol->where->bitoffset); 1063 dsy.bitunit = 1; 1064 dsy.field_len = symbol->where->bitsize; 1065 dsy.field_off = (bits / 32) * 4; 1066 dsy.field_bitoff = bits % 32; 1067 } 1068 else 1069 { 1070 dsy.bitunit = 0; 1071 1072 dsy.field_len = symbol->type->size; 1073 dsy.field_off = symbol->where->offset; 1074 } 1075 break; 1076 1077 case coff_where_member_of_enum: 1078 /* dsy.bitunit = 0; 1079 dsy.field_len = symbol->type->size; 1080 dsy.field_off = symbol->where->offset; */ 1081 break; 1082 1083 case coff_where_register: 1084 case coff_where_unknown: 1085 case coff_where_strtag: 1086 case coff_where_entag: 1087 case coff_where_typedef: 1088 break; 1089 1090 default: 1091 fatal (_("Unrecognised coff symbol location: %d"), symbol->where->where); 1092 } 1093 1094 if (symbol->where->where == coff_where_register) 1095 dsy.reg = rnames[symbol->where->offset]; 1096 1097 switch (symbol->visible->type) 1098 { 1099 case coff_vis_common: 1100 /* We do this 'cause common C symbols are treated as extdefs. */ 1101 case coff_vis_ext_def: 1102 case coff_vis_ext_ref: 1103 dsy.ename = symbol->name; 1104 break; 1105 1106 case coff_vis_regparam: 1107 case coff_vis_autoparam: 1108 dsy.type = STYPE_PARAMETER; 1109 break; 1110 1111 case coff_vis_int_def: 1112 case coff_vis_auto: 1113 case coff_vis_register: 1114 case coff_vis_tag: 1115 case coff_vis_member_of_struct: 1116 case coff_vis_member_of_enum: 1117 break; 1118 1119 default: 1120 fatal (_("Unrecognised coff symbol visibility: %d"), symbol->visible->type); 1121 } 1122 1123 dsy.sfn = 0; 1124 dsy.sln = 2; 1125 dsy.neg = 0x1001; 1126 1127 sysroff_swap_dsy_out (file, &dsy); 1128 1129 walk_tree_type (sfile, symbol, symbol->type, nest); 1130 } 1131 1132 static void 1133 walk_tree_scope (struct coff_section *section, struct coff_sfile *sfile, struct coff_scope *scope, int nest, int type) 1134 { 1135 struct coff_symbol *vars; 1136 struct coff_scope *child; 1137 1138 if (scope->vars_head 1139 || (scope->list_head && scope->list_head->vars_head)) 1140 { 1141 wr_dps_start (sfile, section, scope, type, nest); 1142 1143 if (nest == 0) 1144 wr_globals (tree, sfile, nest + 1); 1145 1146 for (vars = scope->vars_head; vars; vars = vars->next) 1147 walk_tree_symbol (sfile, section, vars, nest); 1148 1149 for (child = scope->list_head; child; child = child->next) 1150 walk_tree_scope (section, sfile, child, nest + 1, BLOCK_TYPE_BLOCK); 1151 1152 wr_dps_end (section, scope, type); 1153 } 1154 } 1155 1156 static void 1157 walk_tree_sfile (struct coff_section *section, struct coff_sfile *sfile) 1158 { 1159 walk_tree_scope (section, sfile, sfile->scope, 0, BLOCK_TYPE_COMPUNIT); 1160 } 1161 1162 static void 1163 wr_program_structure (struct coff_ofile *p, struct coff_sfile *sfile) 1164 { 1165 if (p->nsections < 4) 1166 return; 1167 walk_tree_sfile (p->sections + 4, sfile); 1168 } 1169 1170 static void 1171 wr_du (struct coff_ofile *p, struct coff_sfile *sfile, int n) 1172 { 1173 struct IT_du du; 1174 int lim; 1175 int i; 1176 int j; 1177 unsigned int *lowest = (unsigned *) nints (p->nsections); 1178 unsigned int *highest = (unsigned *) nints (p->nsections); 1179 1180 du.format = bfd_get_file_flags (abfd) & EXEC_P ? 0 : 1; 1181 du.optimized = 0; 1182 du.stackfrmt = 0; 1183 du.spare = 0; 1184 du.unit = n; 1185 du.sections = p->nsections - 1; 1186 du.san = (int *) xcalloc (du.sections, sizeof (int)); 1187 du.address = nints (du.sections); 1188 du.length = nints (du.sections); 1189 1190 for (i = 0; i < du.sections; i++) 1191 { 1192 lowest[i] = ~0; 1193 highest[i] = 0; 1194 } 1195 1196 lim = du.sections; 1197 for (j = 0; j < lim; j++) 1198 { 1199 int src = j; 1200 int dst = j; 1201 1202 du.san[dst] = dst; 1203 1204 if (sfile->section[src].init) 1205 { 1206 du.length[dst] 1207 = sfile->section[src].high - sfile->section[src].low + 1; 1208 du.address[dst] 1209 = sfile->section[src].low; 1210 } 1211 else 1212 { 1213 du.length[dst] = 0; 1214 du.address[dst] = 0; 1215 } 1216 1217 if (debug) 1218 { 1219 if (sfile->section[src].parent) 1220 { 1221 printf (" section %6s 0x%08x..0x%08x\n", 1222 sfile->section[src].parent->name, 1223 du.address[dst], 1224 du.address[dst] + du.length[dst] - 1); 1225 } 1226 } 1227 1228 du.sections = dst + 1; 1229 } 1230 1231 du.tool = "c_gcc"; 1232 du.date = DATE; 1233 1234 sysroff_swap_du_out (file, &du); 1235 } 1236 1237 static void 1238 wr_dus (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile) 1239 { 1240 struct IT_dus dus; 1241 1242 dus.efn = 0x1001; 1243 dus.ns = 1; /* p->nsources; sac 14 jul 94 */ 1244 dus.drb = nints (dus.ns); 1245 dus.fname = (char **) xcalloc (dus.ns, sizeof (char *)); 1246 dus.spare = nints (dus.ns); 1247 dus.ndir = 0; 1248 /* Find the filenames. */ 1249 dus.drb[0] = 0; 1250 dus.fname[0] = sfile->name; 1251 1252 sysroff_swap_dus_out (file, &dus); 1253 1254 } 1255 1256 /* Find the offset of the .text section for this sfile in the 1257 .text section for the output file. */ 1258 1259 static int 1260 find_base (struct coff_sfile *sfile, struct coff_section *section) 1261 { 1262 return sfile->section[section->number].low; 1263 } 1264 1265 static void 1266 wr_dln (struct coff_ofile *p ATTRIBUTE_UNUSED, struct coff_sfile *sfile, 1267 int n ATTRIBUTE_UNUSED) 1268 { 1269 /* Count up all the linenumbers */ 1270 1271 struct coff_symbol *sy; 1272 int lc = 0; 1273 struct IT_dln dln; 1274 1275 int idx; 1276 1277 for (sy = sfile->scope->vars_head; 1278 sy; 1279 sy = sy->next) 1280 { 1281 struct coff_type *t = sy->type; 1282 if (t->type == coff_function_type) 1283 { 1284 struct coff_line *l = t->u.function.lines; 1285 if (l) 1286 lc += l->nlines; 1287 } 1288 } 1289 1290 dln.sfn = nints (lc); 1291 dln.sln = nints (lc); 1292 dln.cc = nints (lc); 1293 dln.section = nints (lc); 1294 1295 dln.from_address = nints (lc); 1296 dln.to_address = nints (lc); 1297 1298 1299 dln.neg = 0x1001; 1300 1301 dln.nln = lc; 1302 1303 /* Run through once more and fill up the structure */ 1304 idx = 0; 1305 for (sy = sfile->scope->vars_head; 1306 sy; 1307 sy = sy->next) 1308 { 1309 if (sy->type->type == coff_function_type) 1310 { 1311 int i; 1312 struct coff_line *l = sy->type->u.function.lines; 1313 if (l) 1314 { 1315 int base = find_base (sfile, sy->where->section); 1316 for (i = 0; i < l->nlines; i++) 1317 { 1318 dln.section[idx] = sy->where->section->number; 1319 dln.sfn[idx] = 0; 1320 dln.sln[idx] = l->lines[i]; 1321 dln.from_address[idx] = 1322 l->addresses[i] + sy->where->section->address - base; 1323 dln.cc[idx] = 0; 1324 if (idx) 1325 dln.to_address[idx - 1] = dln.from_address[idx]; 1326 idx++; 1327 1328 } 1329 dln.to_address[idx - 1] = dln.from_address[idx - 1] + 2; 1330 } 1331 } 1332 } 1333 if (lc) 1334 sysroff_swap_dln_out (file, &dln); 1335 } 1336 1337 /* Write the global symbols out to the debug info. */ 1338 1339 static void 1340 wr_globals (struct coff_ofile *p, struct coff_sfile *sfile, 1341 int n ATTRIBUTE_UNUSED) 1342 { 1343 struct coff_symbol *sy; 1344 1345 for (sy = p->symbol_list_head; 1346 sy; 1347 sy = sy->next_in_ofile_list) 1348 { 1349 if (sy->visible->type == coff_vis_ext_def 1350 || sy->visible->type == coff_vis_ext_ref) 1351 { 1352 /* Only write out symbols if they belong to 1353 the current source file. */ 1354 if (sy->sfile == sfile) 1355 walk_tree_symbol (sfile, 0, sy, 0); 1356 } 1357 } 1358 } 1359 1360 static void 1361 wr_debug (struct coff_ofile *p) 1362 { 1363 struct coff_sfile *sfile; 1364 int n = 0; 1365 1366 for (sfile = p->source_head; 1367 sfile; 1368 sfile = sfile->next) 1369 { 1370 if (debug) 1371 printf ("%s\n", sfile->name); 1372 1373 wr_du (p, sfile, n); 1374 wr_dus (p, sfile); 1375 wr_program_structure (p, sfile); 1376 wr_dln (p, sfile, n); 1377 n++; 1378 } 1379 } 1380 1381 static void 1382 wr_cs (void) 1383 { 1384 /* It seems that the CS struct is not normal - the size is wrong 1385 heres one I prepared earlier. */ 1386 static char b[] = 1387 { 1388 0x80, /* IT */ 1389 0x21, /* RL */ 1390 0x00, /* number of chars in variable length part */ 1391 0x80, /* hd */ 1392 0x00, /* hs */ 1393 0x80, /* un */ 1394 0x00, /* us */ 1395 0x80, /* sc */ 1396 0x00, /* ss */ 1397 0x80, /* er */ 1398 0x80, /* ed */ 1399 0x80, /* sh */ 1400 0x80, /* ob */ 1401 0x80, /* rl */ 1402 0x80, /* du */ 1403 0x80, /* dps */ 1404 0x80, /* dsy */ 1405 0x80, /* dty */ 1406 0x80, /* dln */ 1407 0x80, /* dso */ 1408 0x80, /* dus */ 1409 0x00, /* dss */ 1410 0x80, /* dbt */ 1411 0x00, /* dpp */ 1412 0x80, /* dfp */ 1413 0x80, /* den */ 1414 0x80, /* dds */ 1415 0x80, /* dar */ 1416 0x80, /* dpt */ 1417 0x00, /* dul */ 1418 0x00, /* dse */ 1419 0x00, /* dot */ 1420 0xDE /* CS */ 1421 }; 1422 1423 if (fwrite (b, sizeof (b), 1, file) != 1) 1424 /* FIXME: Return error status. */ 1425 fatal (_("Failed to write CS struct")); 1426 } 1427 1428 /* Write out the SC records for a unit. Create an SC 1429 for all the sections which appear in the output file, even 1430 if there isn't an equivalent one on the input. */ 1431 1432 static int 1433 wr_sc (struct coff_ofile *ptr, struct coff_sfile *sfile) 1434 { 1435 int i; 1436 int scount = 0; 1437 /* First work out the total number of sections. */ 1438 int total_sec = ptr->nsections; 1439 struct myinfo 1440 { 1441 struct coff_section *sec; 1442 struct coff_symbol *symbol; 1443 }; 1444 struct coff_symbol *symbol; 1445 struct myinfo *info 1446 = (struct myinfo *) calloc (total_sec, sizeof (struct myinfo)); 1447 1448 1449 for (i = 0; i < total_sec; i++) 1450 { 1451 info[i].sec = ptr->sections + i; 1452 info[i].symbol = 0; 1453 } 1454 1455 for (symbol = sfile->scope->vars_head; 1456 symbol; 1457 symbol = symbol->next) 1458 { 1459 1460 if (symbol->type->type == coff_secdef_type) 1461 { 1462 for (i = 0; i < total_sec; i++) 1463 { 1464 if (symbol->where->section == info[i].sec) 1465 { 1466 info[i].symbol = symbol; 1467 break; 1468 } 1469 } 1470 } 1471 } 1472 1473 /* Now output all the section info, and fake up some stuff for sections 1474 we don't have. */ 1475 for (i = 1; i < total_sec; i++) 1476 { 1477 struct IT_sc sc; 1478 char *name; 1479 1480 symbol = info[i].symbol; 1481 sc.spare = 0; 1482 sc.spare1 = 0; 1483 1484 if (!symbol) 1485 { 1486 /* Don't have a symbol set aside for this section, which means 1487 that nothing in this file does anything for the section. */ 1488 sc.format = !(bfd_get_file_flags (abfd) & EXEC_P); 1489 sc.addr = 0; 1490 sc.length = 0; 1491 name = info[i].sec->name; 1492 } 1493 else 1494 { 1495 if (bfd_get_file_flags (abfd) & EXEC_P) 1496 { 1497 sc.format = 0; 1498 sc.addr = symbol->where->offset; 1499 } 1500 else 1501 { 1502 sc.format = 1; 1503 sc.addr = 0; 1504 } 1505 sc.length = symbol->type->size; 1506 name = symbol->name; 1507 } 1508 1509 sc.align = 4; 1510 sc.concat = CONCAT_SIMPLE; 1511 sc.read = 3; 1512 sc.write = 3; 1513 sc.exec = 3; 1514 sc.init = 3; 1515 sc.mode = 3; 1516 sc.spare = 0; 1517 sc.segadd = 0; 1518 sc.spare1 = 0; /* If not zero, then it doesn't work. */ 1519 sc.name = section_translate (name); 1520 1521 if (strlen (sc.name) == 1) 1522 { 1523 switch (sc.name[0]) 1524 { 1525 case 'D': 1526 case 'B': 1527 sc.contents = CONTENTS_DATA; 1528 break; 1529 1530 default: 1531 sc.contents = CONTENTS_CODE; 1532 } 1533 } 1534 else 1535 { 1536 sc.contents = CONTENTS_CODE; 1537 } 1538 1539 sysroff_swap_sc_out (file, &sc); 1540 scount++; 1541 } 1542 free (info); 1543 return scount; 1544 } 1545 1546 /* Write out the ER records for a unit. */ 1547 1548 static void 1549 wr_er (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED, 1550 int first) 1551 { 1552 int idx = 0; 1553 struct coff_symbol *sym; 1554 1555 if (first) 1556 { 1557 for (sym = ptr->symbol_list_head; sym; sym = sym->next_in_ofile_list) 1558 { 1559 if (sym->visible->type == coff_vis_ext_ref) 1560 { 1561 struct IT_er er; 1562 1563 er.spare = 0; 1564 er.type = ER_NOTSPEC; 1565 er.name = sym->name; 1566 sysroff_swap_er_out (file, &er); 1567 sym->er_number = idx++; 1568 } 1569 } 1570 } 1571 } 1572 1573 /* Write out the ED records for a unit. */ 1574 1575 static void 1576 wr_ed (struct coff_ofile *ptr, struct coff_sfile *sfile ATTRIBUTE_UNUSED, 1577 int first) 1578 { 1579 struct coff_symbol *s; 1580 1581 if (first) 1582 { 1583 for (s = ptr->symbol_list_head; s; s = s->next_in_ofile_list) 1584 { 1585 if (s->visible->type == coff_vis_ext_def 1586 || s->visible->type == coff_vis_common) 1587 { 1588 struct IT_ed ed; 1589 1590 ed.section = s->where->section->number; 1591 ed.spare = 0; 1592 1593 if (s->where->section->data) 1594 { 1595 ed.type = ED_TYPE_DATA; 1596 } 1597 else if (s->where->section->code & SEC_CODE) 1598 { 1599 ed.type = ED_TYPE_ENTRY; 1600 } 1601 else 1602 { 1603 ed.type = ED_TYPE_NOTSPEC; 1604 ed.type = ED_TYPE_DATA; 1605 } 1606 1607 ed.address = s->where->offset - s->where->section->address; 1608 ed.name = s->name; 1609 sysroff_swap_ed_out (file, &ed); 1610 } 1611 } 1612 } 1613 } 1614 1615 static void 1616 wr_unit_info (struct coff_ofile *ptr) 1617 { 1618 struct coff_sfile *sfile; 1619 int first = 1; 1620 1621 for (sfile = ptr->source_head; 1622 sfile; 1623 sfile = sfile->next) 1624 { 1625 long p1; 1626 long p2; 1627 int nsecs; 1628 1629 p1 = ftell (file); 1630 wr_un (ptr, sfile, first, 0); 1631 nsecs = wr_sc (ptr, sfile); 1632 p2 = ftell (file); 1633 fseek (file, p1, SEEK_SET); 1634 wr_un (ptr, sfile, first, nsecs); 1635 fseek (file, p2, SEEK_SET); 1636 wr_er (ptr, sfile, first); 1637 wr_ed (ptr, sfile, first); 1638 first = 0; 1639 } 1640 } 1641 1642 static void 1643 wr_module (struct coff_ofile *p) 1644 { 1645 wr_cs (); 1646 wr_hd (p); 1647 wr_unit_info (p); 1648 wr_object_body (p); 1649 wr_debug (p); 1650 wr_tr (); 1651 } 1652 1653 static int 1654 align (int x) 1655 { 1656 return (x + 3) & ~3; 1657 } 1658 1659 /* Find all the common variables and turn them into 1660 ordinary defs - dunno why, but thats what hitachi does with 'em. */ 1661 1662 static void 1663 prescan (struct coff_ofile *otree) 1664 { 1665 struct coff_symbol *s; 1666 struct coff_section *common_section; 1667 1668 if (otree->nsections < 3) 1669 return; 1670 1671 /* Find the common section - always section 3. */ 1672 common_section = otree->sections + 3; 1673 1674 for (s = otree->symbol_list_head; 1675 s; 1676 s = s->next_in_ofile_list) 1677 { 1678 if (s->visible->type == coff_vis_common) 1679 { 1680 struct coff_where *w = s->where; 1681 /* s->visible->type = coff_vis_ext_def; leave it as common */ 1682 common_section->size = align (common_section->size); 1683 w->offset = common_section->size + common_section->address; 1684 w->section = common_section; 1685 common_section->size += s->type->size; 1686 common_section->size = align (common_section->size); 1687 } 1688 } 1689 } 1690 1691 ATTRIBUTE_NORETURN static void 1692 show_usage (FILE *ffile, int status) 1693 { 1694 fprintf (ffile, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name); 1695 fprintf (ffile, _("Convert a COFF object file into a SYSROFF object file\n")); 1696 fprintf (ffile, _(" The options are:\n\ 1697 -q --quick (Obsolete - ignored)\n\ 1698 -n --noprescan Do not perform a scan to convert commons into defs\n\ 1699 -d --debug Display information about what is being done\n\ 1700 @<file> Read options from <file>\n\ 1701 -h --help Display this information\n\ 1702 -v --version Print the program's version number\n")); 1703 1704 if (REPORT_BUGS_TO[0] && status == 0) 1705 fprintf (ffile, _("Report bugs to %s\n"), REPORT_BUGS_TO); 1706 exit (status); 1707 } 1708 1709 int 1710 main (int ac, char **av) 1711 { 1712 int opt; 1713 static struct option long_options[] = 1714 { 1715 {"debug", no_argument, 0, 'd'}, 1716 {"quick", no_argument, 0, 'q'}, 1717 {"noprescan", no_argument, 0, 'n'}, 1718 {"help", no_argument, 0, 'h'}, 1719 {"version", no_argument, 0, 'V'}, 1720 {NULL, no_argument, 0, 0} 1721 }; 1722 char **matching; 1723 char *input_file; 1724 char *output_file; 1725 1726 #ifdef HAVE_LC_MESSAGES 1727 setlocale (LC_MESSAGES, ""); 1728 #endif 1729 setlocale (LC_CTYPE, ""); 1730 bindtextdomain (PACKAGE, LOCALEDIR); 1731 textdomain (PACKAGE); 1732 1733 program_name = av[0]; 1734 xmalloc_set_program_name (program_name); 1735 bfd_set_error_program_name (program_name); 1736 1737 expandargv (&ac, &av); 1738 1739 while ((opt = getopt_long (ac, av, "dHhVvqn", long_options, 1740 (int *) NULL)) 1741 != EOF) 1742 { 1743 switch (opt) 1744 { 1745 case 'q': 1746 quick = 1; 1747 break; 1748 case 'n': 1749 noprescan = 1; 1750 break; 1751 case 'd': 1752 debug = 1; 1753 break; 1754 case 'H': 1755 case 'h': 1756 show_usage (stdout, 0); 1757 /*NOTREACHED */ 1758 case 'v': 1759 case 'V': 1760 print_version ("srconv"); 1761 exit (0); 1762 /*NOTREACHED */ 1763 case 0: 1764 break; 1765 default: 1766 show_usage (stderr, 1); 1767 /*NOTREACHED */ 1768 } 1769 } 1770 1771 /* The input and output files may be named on the command line. */ 1772 output_file = NULL; 1773 if (optind < ac) 1774 { 1775 input_file = av[optind]; 1776 ++optind; 1777 if (optind < ac) 1778 { 1779 output_file = av[optind]; 1780 ++optind; 1781 if (optind < ac) 1782 show_usage (stderr, 1); 1783 if (filename_cmp (input_file, output_file) == 0) 1784 { 1785 fatal (_("input and output files must be different")); 1786 } 1787 } 1788 } 1789 else 1790 input_file = 0; 1791 1792 if (!input_file) 1793 { 1794 fatal (_("no input file specified")); 1795 } 1796 1797 if (!output_file) 1798 { 1799 /* Take a .o off the input file and stick on a .obj. If 1800 it doesn't end in .o, then stick a .obj on anyway */ 1801 1802 int len = strlen (input_file); 1803 1804 output_file = xmalloc (len + 5); 1805 strcpy (output_file, input_file); 1806 1807 if (len > 3 1808 && output_file[len - 2] == '.' 1809 && output_file[len - 1] == 'o') 1810 { 1811 output_file[len] = 'b'; 1812 output_file[len + 1] = 'j'; 1813 output_file[len + 2] = 0; 1814 } 1815 else 1816 { 1817 strcat (output_file, ".obj"); 1818 } 1819 } 1820 1821 abfd = bfd_openr (input_file, 0); 1822 1823 if (!abfd) 1824 bfd_fatal (input_file); 1825 1826 if (!bfd_check_format_matches (abfd, bfd_object, &matching)) 1827 { 1828 bfd_nonfatal (input_file); 1829 1830 if (bfd_get_error () == bfd_error_file_ambiguously_recognized) 1831 list_matching_formats (matching); 1832 exit (1); 1833 } 1834 1835 file = fopen (output_file, FOPEN_WB); 1836 1837 if (!file) 1838 fatal (_("unable to open output file %s"), output_file); 1839 1840 if (debug) 1841 printf ("ids %d %d\n", base1, base2); 1842 1843 tree = coff_grok (abfd); 1844 if (tree) 1845 { 1846 if (!noprescan) 1847 prescan (tree); 1848 1849 wr_module (tree); 1850 } 1851 return 0; 1852 } 1853
Indexes created Mon Mar 02 05:31:46 UTC 2026