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