1 /* Sysroff object format dumper. 2 Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007, 3 2009, 2011 Free Software Foundation, Inc. 4 5 This file is part of GNU Binutils. 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, MA 20 02110-1301, USA. */ 21 22 23 /* Written by Steve Chamberlain <sac@cygnus.com>. 24 25 This program reads a SYSROFF object file and prints it in an 26 almost human readable form to stdout. */ 27 28 #include "sysdep.h" 29 #include "bfd.h" 30 #include "safe-ctype.h" 31 #include "libiberty.h" 32 #include "getopt.h" 33 #include "bucomm.h" 34 #include "sysroff.h" 35 36 static int dump = 1; 37 static int segmented_p; 38 static int code; 39 static int addrsize = 4; 40 static FILE *file; 41 42 static void dh (unsigned char *, int); 43 static void itheader (char *, int); 44 static void p (void); 45 static void tabout (void); 46 static void pbarray (barray *); 47 static int getone (int); 48 static int opt (int); 49 static void must (int); 50 static void tab (int, char *); 51 static void dump_symbol_info (void); 52 static void derived_type (void); 53 static void module (void); 54 static void show_usage (FILE *, int); 55 56 extern int main (int, char **); 57 58 static char * 59 getCHARS (unsigned char *ptr, int *idx, int size, int max) 60 { 61 int oc = *idx / 8; 62 char *r; 63 int b = size; 64 65 if (b >= max) 66 return _("*undefined*"); 67 68 if (b == 0) 69 { 70 /* Got to work out the length of the string from self. */ 71 b = ptr[oc++]; 72 (*idx) += 8; 73 } 74 75 *idx += b * 8; 76 r = xcalloc (b + 1, 1); 77 memcpy (r, ptr + oc, b); 78 r[b] = 0; 79 80 return r; 81 } 82 83 static void 84 dh (unsigned char *ptr, int size) 85 { 86 int i; 87 int j; 88 int span = 16; 89 90 printf ("\n************************************************************\n"); 91 92 for (i = 0; i < size; i += span) 93 { 94 for (j = 0; j < span; j++) 95 { 96 if (j + i < size) 97 printf ("%02x ", ptr[i + j]); 98 else 99 printf (" "); 100 } 101 102 for (j = 0; j < span && j + i < size; j++) 103 { 104 int c = ptr[i + j]; 105 106 if (c < 32 || c > 127) 107 c = '.'; 108 printf ("%c", c); 109 } 110 111 printf ("\n"); 112 } 113 } 114 115 static int 116 fillup (unsigned char *ptr) 117 { 118 int size; 119 int sum; 120 int i; 121 122 size = getc (file); 123 if (size == EOF 124 || size <= 2) 125 return 0; 126 127 size -= 2; 128 if (fread (ptr, size, 1, file) != 1) 129 return 0; 130 131 sum = code + size + 2; 132 133 for (i = 0; i < size; i++) 134 sum += ptr[i]; 135 136 if ((sum & 0xff) != 0xff) 137 printf (_("SUM IS %x\n"), sum); 138 139 if (dump) 140 dh (ptr, size); 141 142 return size; 143 } 144 145 static barray 146 getBARRAY (unsigned char *ptr, int *idx, int dsize ATTRIBUTE_UNUSED, 147 int max ATTRIBUTE_UNUSED) 148 { 149 barray res; 150 int i; 151 int byte = *idx / 8; 152 int size = ptr[byte++]; 153 154 res.len = size; 155 res.data = (unsigned char *) xmalloc (size); 156 157 for (i = 0; i < size; i++) 158 res.data[i] = ptr[byte++]; 159 160 return res; 161 } 162 163 static int 164 getINT (unsigned char *ptr, int *idx, int size, int max) 165 { 166 int n = 0; 167 int byte = *idx / 8; 168 169 if (byte >= max) 170 return 0; 171 172 if (size == -2) 173 size = addrsize; 174 175 if (size == -1) 176 size = 0; 177 178 switch (size) 179 { 180 case 0: 181 return 0; 182 case 1: 183 n = (ptr[byte]); 184 break; 185 case 2: 186 n = (ptr[byte + 0] << 8) + ptr[byte + 1]; 187 break; 188 case 4: 189 n = (ptr[byte + 0] << 24) + (ptr[byte + 1] << 16) + (ptr[byte + 2] << 8) + (ptr[byte + 3]); 190 break; 191 default: 192 abort (); 193 } 194 195 *idx += size * 8; 196 return n; 197 } 198 199 static int 200 getBITS (unsigned char *ptr, int *idx, int size, int max) 201 { 202 int byte = *idx / 8; 203 int bit = *idx % 8; 204 205 if (byte >= max) 206 return 0; 207 208 *idx += size; 209 210 return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1); 211 } 212 213 static void 214 itheader (char *name, int icode) 215 { 216 printf ("\n%s 0x%02x\n", name, icode); 217 } 218 219 static int indent; 220 221 static void 222 p (void) 223 { 224 int i; 225 226 for (i = 0; i < indent; i++) 227 printf ("| "); 228 229 printf ("> "); 230 } 231 232 static void 233 tabout (void) 234 { 235 p (); 236 } 237 238 static void 239 pbarray (barray *y) 240 { 241 int x; 242 243 printf ("%d (", y->len); 244 245 for (x = 0; x < y->len; x++) 246 printf ("(%02x %c)", y->data[x], 247 ISPRINT (y->data[x]) ? y->data[x] : '.'); 248 249 printf (")\n"); 250 } 251 252 #define SYSROFF_PRINT 253 #define SYSROFF_SWAP_IN 254 255 #include "sysroff.c" 256 257 /* FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't 258 hack the special case of the tr block, which has no contents. So we 259 implement our own functions for reading in and printing out the tr 260 block. */ 261 262 #define IT_tr_CODE 0x7f 263 264 static void 265 sysroff_swap_tr_in (void) 266 { 267 unsigned char raw[255]; 268 269 memset (raw, 0, 255); 270 fillup (raw); 271 } 272 273 static void 274 sysroff_print_tr_out (void) 275 { 276 itheader ("tr", IT_tr_CODE); 277 } 278 279 static int 280 getone (int type) 281 { 282 int c = getc (file); 283 284 code = c; 285 286 if ((c & 0x7f) != type) 287 { 288 ungetc (c, file); 289 return 0; 290 } 291 292 switch (c & 0x7f) 293 { 294 case IT_cs_CODE: 295 { 296 struct IT_cs dummy; 297 sysroff_swap_cs_in (&dummy); 298 sysroff_print_cs_out (&dummy); 299 } 300 break; 301 302 case IT_dln_CODE: 303 { 304 struct IT_dln dummy; 305 sysroff_swap_dln_in (&dummy); 306 sysroff_print_dln_out (&dummy); 307 } 308 break; 309 310 case IT_hd_CODE: 311 { 312 struct IT_hd dummy; 313 sysroff_swap_hd_in (&dummy); 314 addrsize = dummy.afl; 315 sysroff_print_hd_out (&dummy); 316 } 317 break; 318 319 case IT_dar_CODE: 320 { 321 struct IT_dar dummy; 322 sysroff_swap_dar_in (&dummy); 323 sysroff_print_dar_out (&dummy); 324 } 325 break; 326 327 case IT_dsy_CODE: 328 { 329 struct IT_dsy dummy; 330 sysroff_swap_dsy_in (&dummy); 331 sysroff_print_dsy_out (&dummy); 332 } 333 break; 334 335 case IT_dfp_CODE: 336 { 337 struct IT_dfp dummy; 338 sysroff_swap_dfp_in (&dummy); 339 sysroff_print_dfp_out (&dummy); 340 } 341 break; 342 343 case IT_dso_CODE: 344 { 345 struct IT_dso dummy; 346 sysroff_swap_dso_in (&dummy); 347 sysroff_print_dso_out (&dummy); 348 } 349 break; 350 351 case IT_dpt_CODE: 352 { 353 struct IT_dpt dummy; 354 sysroff_swap_dpt_in (&dummy); 355 sysroff_print_dpt_out (&dummy); 356 } 357 break; 358 359 case IT_den_CODE: 360 { 361 struct IT_den dummy; 362 sysroff_swap_den_in (&dummy); 363 sysroff_print_den_out (&dummy); 364 } 365 break; 366 367 case IT_dbt_CODE: 368 { 369 struct IT_dbt dummy; 370 sysroff_swap_dbt_in (&dummy); 371 sysroff_print_dbt_out (&dummy); 372 } 373 break; 374 375 case IT_dty_CODE: 376 { 377 struct IT_dty dummy; 378 sysroff_swap_dty_in (&dummy); 379 sysroff_print_dty_out (&dummy); 380 } 381 break; 382 383 case IT_un_CODE: 384 { 385 struct IT_un dummy; 386 sysroff_swap_un_in (&dummy); 387 sysroff_print_un_out (&dummy); 388 } 389 break; 390 391 case IT_sc_CODE: 392 { 393 struct IT_sc dummy; 394 sysroff_swap_sc_in (&dummy); 395 sysroff_print_sc_out (&dummy); 396 } 397 break; 398 399 case IT_er_CODE: 400 { 401 struct IT_er dummy; 402 sysroff_swap_er_in (&dummy); 403 sysroff_print_er_out (&dummy); 404 } 405 break; 406 407 case IT_ed_CODE: 408 { 409 struct IT_ed dummy; 410 sysroff_swap_ed_in (&dummy); 411 sysroff_print_ed_out (&dummy); 412 } 413 break; 414 415 case IT_sh_CODE: 416 { 417 struct IT_sh dummy; 418 sysroff_swap_sh_in (&dummy); 419 sysroff_print_sh_out (&dummy); 420 } 421 break; 422 423 case IT_ob_CODE: 424 { 425 struct IT_ob dummy; 426 sysroff_swap_ob_in (&dummy); 427 sysroff_print_ob_out (&dummy); 428 } 429 break; 430 431 case IT_rl_CODE: 432 { 433 struct IT_rl dummy; 434 sysroff_swap_rl_in (&dummy); 435 sysroff_print_rl_out (&dummy); 436 } 437 break; 438 439 case IT_du_CODE: 440 { 441 struct IT_du dummy; 442 sysroff_swap_du_in (&dummy); 443 444 sysroff_print_du_out (&dummy); 445 } 446 break; 447 448 case IT_dus_CODE: 449 { 450 struct IT_dus dummy; 451 sysroff_swap_dus_in (&dummy); 452 sysroff_print_dus_out (&dummy); 453 } 454 break; 455 456 case IT_dul_CODE: 457 { 458 struct IT_dul dummy; 459 sysroff_swap_dul_in (&dummy); 460 sysroff_print_dul_out (&dummy); 461 } 462 break; 463 464 case IT_dss_CODE: 465 { 466 struct IT_dss dummy; 467 sysroff_swap_dss_in (&dummy); 468 sysroff_print_dss_out (&dummy); 469 } 470 break; 471 472 case IT_hs_CODE: 473 { 474 struct IT_hs dummy; 475 sysroff_swap_hs_in (&dummy); 476 sysroff_print_hs_out (&dummy); 477 } 478 break; 479 480 case IT_dps_CODE: 481 { 482 struct IT_dps dummy; 483 sysroff_swap_dps_in (&dummy); 484 sysroff_print_dps_out (&dummy); 485 } 486 break; 487 488 case IT_tr_CODE: 489 sysroff_swap_tr_in (); 490 sysroff_print_tr_out (); 491 break; 492 493 case IT_dds_CODE: 494 { 495 struct IT_dds dummy; 496 497 sysroff_swap_dds_in (&dummy); 498 sysroff_print_dds_out (&dummy); 499 } 500 break; 501 502 default: 503 printf (_("GOT A %x\n"), c); 504 return 0; 505 break; 506 } 507 508 return 1; 509 } 510 511 static int 512 opt (int x) 513 { 514 return getone (x); 515 } 516 517 static void 518 must (int x) 519 { 520 if (!getone (x)) 521 printf (_("WANTED %x!!\n"), x); 522 } 523 524 static void 525 tab (int i, char *s) 526 { 527 indent += i; 528 529 if (s) 530 { 531 p (); 532 puts (s); 533 } 534 } 535 536 static void 537 dump_symbol_info (void) 538 { 539 tab (1, _("SYMBOL INFO")); 540 541 while (opt (IT_dsy_CODE)) 542 { 543 if (opt (IT_dty_CODE)) 544 { 545 must (IT_dbt_CODE); 546 derived_type (); 547 must (IT_dty_CODE); 548 } 549 } 550 551 tab (-1, ""); 552 } 553 554 static void 555 derived_type (void) 556 { 557 tab (1, _("DERIVED TYPE")); 558 559 while (1) 560 { 561 if (opt (IT_dpp_CODE)) 562 { 563 dump_symbol_info (); 564 must (IT_dpp_CODE); 565 } 566 else if (opt (IT_dfp_CODE)) 567 { 568 dump_symbol_info (); 569 must (IT_dfp_CODE); 570 } 571 else if (opt (IT_den_CODE)) 572 { 573 dump_symbol_info (); 574 must (IT_den_CODE); 575 } 576 else if (opt (IT_den_CODE)) 577 { 578 dump_symbol_info (); 579 must (IT_den_CODE); 580 } 581 else if (opt (IT_dds_CODE)) 582 { 583 dump_symbol_info (); 584 must (IT_dds_CODE); 585 } 586 else if (opt (IT_dar_CODE)) 587 { 588 } 589 else if (opt (IT_dpt_CODE)) 590 { 591 } 592 else if (opt (IT_dul_CODE)) 593 { 594 } 595 else if (opt (IT_dse_CODE)) 596 { 597 } 598 else if (opt (IT_dot_CODE)) 599 { 600 } 601 else 602 break; 603 } 604 605 tab (-1, ""); 606 } 607 608 static void 609 module (void) 610 { 611 int c = 0; 612 int l = 0; 613 614 tab (1, _("MODULE***\n")); 615 616 do 617 { 618 c = getc (file); 619 ungetc (c, file); 620 621 c &= 0x7f; 622 } 623 while (getone (c) && c != IT_tr_CODE); 624 625 tab (-1, ""); 626 627 c = getc (file); 628 while (c != EOF) 629 { 630 printf ("%02x ", c); 631 l++; 632 if (l == 32) 633 { 634 printf ("\n"); 635 l = 0; 636 } 637 c = getc (file); 638 } 639 } 640 641 char *program_name; 642 643 static void 644 show_usage (FILE *ffile, int status) 645 { 646 fprintf (ffile, _("Usage: %s [option(s)] in-file\n"), program_name); 647 fprintf (ffile, _("Print a human readable interpretation of a SYSROFF object file\n")); 648 fprintf (ffile, _(" The options are:\n\ 649 -h --help Display this information\n\ 650 -v --version Print the program's version number\n")); 651 652 if (REPORT_BUGS_TO[0] && status == 0) 653 fprintf (ffile, _("Report bugs to %s\n"), REPORT_BUGS_TO); 654 exit (status); 655 } 656 657 int 658 main (int ac, char **av) 659 { 660 char *input_file = NULL; 661 int option; 662 static struct option long_options[] = 663 { 664 {"help", no_argument, 0, 'h'}, 665 {"version", no_argument, 0, 'V'}, 666 {NULL, no_argument, 0, 0} 667 }; 668 669 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 670 setlocale (LC_MESSAGES, ""); 671 #endif 672 #if defined (HAVE_SETLOCALE) 673 setlocale (LC_CTYPE, ""); 674 #endif 675 bindtextdomain (PACKAGE, LOCALEDIR); 676 textdomain (PACKAGE); 677 678 program_name = av[0]; 679 xmalloc_set_program_name (program_name); 680 681 expandargv (&ac, &av); 682 683 while ((option = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF) 684 { 685 switch (option) 686 { 687 case 'H': 688 case 'h': 689 show_usage (stdout, 0); 690 /*NOTREACHED*/ 691 case 'v': 692 case 'V': 693 print_version ("sysdump"); 694 exit (0); 695 /*NOTREACHED*/ 696 case 0: 697 break; 698 default: 699 show_usage (stderr, 1); 700 /*NOTREACHED*/ 701 } 702 } 703 704 /* The input and output files may be named on the command line. */ 705 706 if (optind < ac) 707 input_file = av[optind]; 708 709 if (!input_file) 710 fatal (_("no input file specified")); 711 712 file = fopen (input_file, FOPEN_RB); 713 714 if (!file) 715 fatal (_("cannot open input file %s"), input_file); 716 717 module (); 718 return 0; 719 } 720