1 /* listing.c - maintain assembly listings 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003 4 Free Software Foundation, Inc. 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 GAS is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 21 02111-1307, USA. */ 22 23 /* Contributed by Steve Chamberlain <sac@cygnus.com> 24 25 A listing page looks like: 26 27 LISTING_HEADER sourcefilename pagenumber 28 TITLE LINE 29 SUBTITLE LINE 30 linenumber address data source 31 linenumber address data source 32 linenumber address data source 33 linenumber address data source 34 35 If not overridden, the listing commands are: 36 37 .title "stuff" 38 Put "stuff" onto the title line 39 .sbttl "stuff" 40 Put stuff onto the subtitle line 41 42 If these commands come within 10 lines of the top of the page, they 43 will affect the page they are on, as well as any subsequent page 44 45 .eject 46 Thow a page 47 .list 48 Increment the enable listing counter 49 .nolist 50 Decrement the enable listing counter 51 52 .psize Y[,X] 53 Set the paper size to X wide and Y high. Setting a psize Y of 54 zero will suppress form feeds except where demanded by .eject 55 56 If the counter goes below zero, listing is suppressed. 57 58 Listings are a maintained by read calling various listing_<foo> 59 functions. What happens most is that the macro NO_LISTING is not 60 defined (from the Makefile), then the macro LISTING_NEWLINE expands 61 into a call to listing_newline. The call is done from read.c, every 62 time it sees a newline, and -l is on the command line. 63 64 The function listing_newline remembers the frag associated with the 65 newline, and creates a new frag - note that this is wasteful, but not 66 a big deal, since listing slows things down a lot anyway. The 67 function also remembers when the filename changes. 68 69 When all the input has finished, and gas has had a chance to settle 70 down, the listing is output. This is done by running down the list of 71 frag/source file records, and opening the files as needed and printing 72 out the bytes and chars associated with them. 73 74 The only things which the architecture can change about the listing 75 are defined in these macros: 76 77 LISTING_HEADER The name of the architecture 78 LISTING_WORD_SIZE The make of the number of bytes in a word, this determines 79 the clumping of the output data. eg a value of 80 2 makes words look like 1234 5678, whilst 1 81 would make the same value look like 12 34 56 82 78 83 LISTING_LHS_WIDTH Number of words of above size for the lhs 84 85 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs 86 for the second line 87 88 LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation 89 LISTING_RHS_WIDTH Number of chars from the input file to print 90 on a line. */ 91 92 #include "as.h" 93 #include "obstack.h" 94 #include "safe-ctype.h" 95 #include "input-file.h" 96 #include "subsegs.h" 97 98 #ifndef NO_LISTING 99 100 #ifndef LISTING_HEADER 101 #define LISTING_HEADER "GAS LISTING" 102 #endif 103 #ifndef LISTING_WORD_SIZE 104 #define LISTING_WORD_SIZE 4 105 #endif 106 #ifndef LISTING_LHS_WIDTH 107 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE)) 108 #endif 109 #ifndef LISTING_LHS_WIDTH_SECOND 110 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH 111 #endif 112 #ifndef LISTING_RHS_WIDTH 113 #define LISTING_RHS_WIDTH 100 114 #endif 115 #ifndef LISTING_LHS_CONT_LINES 116 #define LISTING_LHS_CONT_LINES 4 117 #endif 118 119 /* This structure remembers which .s were used. */ 120 typedef struct file_info_struct 121 { 122 struct file_info_struct * next; 123 char * filename; 124 long pos; 125 unsigned int linenum; 126 int at_end; 127 } file_info_type; 128 129 /* This structure remembers which line from which file goes into which 130 frag. */ 131 struct list_info_struct 132 { 133 /* Frag which this line of source is nearest to. */ 134 fragS *frag; 135 136 /* The actual line in the source file. */ 137 unsigned int line; 138 139 /* Pointer to the file info struct for the file which this line 140 belongs to. */ 141 file_info_type *file; 142 143 /* The expanded text of any macro that may have been executing. */ 144 char *line_contents; 145 146 /* Next in list. */ 147 struct list_info_struct *next; 148 149 /* Pointer to the file info struct for the high level language 150 source line that belongs here. */ 151 file_info_type *hll_file; 152 153 /* High level language source line. */ 154 unsigned int hll_line; 155 156 /* Pointer to any error message associated with this line. */ 157 char *message; 158 159 enum 160 { 161 EDICT_NONE, 162 EDICT_SBTTL, 163 EDICT_TITLE, 164 EDICT_NOLIST, 165 EDICT_LIST, 166 EDICT_NOLIST_NEXT, 167 EDICT_EJECT 168 } edict; 169 char *edict_arg; 170 171 /* Nonzero if this line is to be omitted because it contains 172 debugging information. This can become a flags field if we come 173 up with more information to store here. */ 174 int debugging; 175 }; 176 177 typedef struct list_info_struct list_info_type; 178 179 int listing_lhs_width = LISTING_LHS_WIDTH; 180 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND; 181 int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES; 182 int listing_rhs_width = LISTING_RHS_WIDTH; 183 184 struct list_info_struct * listing_tail; 185 186 static file_info_type * file_info_head; 187 static file_info_type * last_open_file_info; 188 static FILE * last_open_file; 189 static struct list_info_struct * head; 190 static int paper_width = 200; 191 static int paper_height = 60; 192 193 extern int listing; 194 195 /* File to output listings to. */ 196 static FILE *list_file; 197 198 /* This static array is used to keep the text of data to be printed 199 before the start of the line. */ 200 201 #define MAX_BYTES \ 202 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \ 203 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \ 204 * listing_lhs_cont_lines) \ 205 + 20) 206 207 static char *data_buffer; 208 209 /* Prototypes. */ 210 static void listing_message (const char *, const char *); 211 static file_info_type *file_info (const char *); 212 static void new_frag (void); 213 static char *buffer_line (file_info_type *, char *, unsigned int); 214 static void listing_page (list_info_type *); 215 static unsigned int calc_hex (list_info_type *); 216 static void print_lines (list_info_type *, unsigned int, char *, unsigned int); 217 static void list_symbol_table (void); 218 static void print_source (file_info_type *, list_info_type *, char *, unsigned int); 219 static int debugging_pseudo (list_info_type *, const char *); 220 static void listing_listing (char *); 221 222 static void 223 listing_message (const char *name, const char *message) 224 { 225 if (listing_tail != (list_info_type *) NULL) 226 { 227 unsigned int l = strlen (name) + strlen (message) + 1; 228 char *n = (char *) xmalloc (l); 229 strcpy (n, name); 230 strcat (n, message); 231 listing_tail->message = n; 232 } 233 } 234 235 void 236 listing_warning (const char *message) 237 { 238 listing_message (_("Warning:"), message); 239 } 240 241 void 242 listing_error (const char *message) 243 { 244 listing_message (_("Error:"), message); 245 } 246 247 static file_info_type * 248 file_info (const char *file_name) 249 { 250 /* Find an entry with this file name. */ 251 file_info_type *p = file_info_head; 252 253 while (p != (file_info_type *) NULL) 254 { 255 if (strcmp (p->filename, file_name) == 0) 256 return p; 257 p = p->next; 258 } 259 260 /* Make new entry. */ 261 p = xmalloc (sizeof (file_info_type)); 262 p->next = file_info_head; 263 file_info_head = p; 264 p->filename = xstrdup (file_name); 265 p->pos = 0; 266 p->linenum = 0; 267 p->at_end = 0; 268 269 return p; 270 } 271 272 static void 273 new_frag (void) 274 { 275 frag_wane (frag_now); 276 frag_new (0); 277 } 278 279 void 280 listing_newline (char *ps) 281 { 282 char *file; 283 unsigned int line; 284 static unsigned int last_line = 0xffff; 285 static char *last_file = NULL; 286 list_info_type *new = NULL; 287 288 if (listing == 0) 289 return; 290 291 if (now_seg == absolute_section) 292 return; 293 294 #ifdef OBJ_ELF 295 /* In ELF, anything in a section beginning with .debug or .line is 296 considered to be debugging information. This includes the 297 statement which switches us into the debugging section, which we 298 can only set after we are already in the debugging section. */ 299 if ((listing & LISTING_NODEBUG) != 0 300 && listing_tail != NULL 301 && ! listing_tail->debugging) 302 { 303 const char *segname; 304 305 segname = segment_name (now_seg); 306 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0 307 || strncmp (segname, ".line", sizeof ".line" - 1) == 0) 308 listing_tail->debugging = 1; 309 } 310 #endif 311 312 as_where (&file, &line); 313 if (ps == NULL) 314 { 315 if (line == last_line 316 && !(last_file && file && strcmp (file, last_file))) 317 return; 318 319 new = (list_info_type *) xmalloc (sizeof (list_info_type)); 320 321 /* Detect if we are reading from stdin by examining the file 322 name returned by as_where(). 323 324 [FIXME: We rely upon the name in the strcmp below being the 325 same as the one used by input_scrub_new_file(), if that is 326 not true, then this code will fail]. 327 328 If we are reading from stdin, then we need to save each input 329 line here (assuming of course that we actually have a line of 330 input to read), so that it can be displayed in the listing 331 that is produced at the end of the assembly. */ 332 if (strcmp (file, _("{standard input}")) == 0 333 && input_line_pointer != NULL) 334 { 335 char *copy; 336 int len; 337 int seen_quote = 0; 338 339 for (copy = input_line_pointer - 1; 340 *copy && (seen_quote 341 || (! is_end_of_line [(unsigned char) *copy])); 342 copy++) 343 if (*copy == '"' && copy[-1] != '\\') 344 seen_quote = ! seen_quote; 345 346 len = (copy - input_line_pointer) + 2; 347 348 copy = xmalloc (len); 349 350 if (copy != NULL) 351 { 352 char *src = input_line_pointer - 1; 353 char *dest = copy; 354 355 while (--len) 356 { 357 unsigned char c = *src++; 358 359 /* Omit control characters in the listing. */ 360 if (!ISCNTRL (c)) 361 *dest++ = c; 362 } 363 364 *dest = 0; 365 } 366 367 new->line_contents = copy; 368 } 369 else 370 new->line_contents = NULL; 371 } 372 else 373 { 374 new = xmalloc (sizeof (list_info_type)); 375 new->line_contents = ps; 376 } 377 378 last_line = line; 379 last_file = file; 380 381 new_frag (); 382 383 if (listing_tail) 384 listing_tail->next = new; 385 else 386 head = new; 387 388 listing_tail = new; 389 390 new->frag = frag_now; 391 new->line = line; 392 new->file = file_info (file); 393 new->next = (list_info_type *) NULL; 394 new->message = (char *) NULL; 395 new->edict = EDICT_NONE; 396 new->hll_file = (file_info_type *) NULL; 397 new->hll_line = 0; 398 new->debugging = 0; 399 400 new_frag (); 401 402 #ifdef OBJ_ELF 403 /* In ELF, anything in a section beginning with .debug or .line is 404 considered to be debugging information. */ 405 if ((listing & LISTING_NODEBUG) != 0) 406 { 407 const char *segname; 408 409 segname = segment_name (now_seg); 410 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0 411 || strncmp (segname, ".line", sizeof ".line" - 1) == 0) 412 new->debugging = 1; 413 } 414 #endif 415 } 416 417 /* Attach all current frags to the previous line instead of the 418 current line. This is called by the MIPS backend when it discovers 419 that it needs to add some NOP instructions; the added NOP 420 instructions should go with the instruction that has the delay, not 421 with the new instruction. */ 422 423 void 424 listing_prev_line (void) 425 { 426 list_info_type *l; 427 fragS *f; 428 429 if (head == (list_info_type *) NULL 430 || head == listing_tail) 431 return; 432 433 new_frag (); 434 435 for (l = head; l->next != listing_tail; l = l->next) 436 ; 437 438 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next) 439 if (f->line == listing_tail) 440 f->line = l; 441 442 listing_tail->frag = frag_now; 443 new_frag (); 444 } 445 446 /* This function returns the next source line from the file supplied, 447 truncated to size. It appends a fake line to the end of each input 448 file to make. */ 449 450 static char * 451 buffer_line (file_info_type *file, char *line, unsigned int size) 452 { 453 unsigned int count = 0; 454 int c; 455 456 char *p = line; 457 458 /* If we couldn't open the file, return an empty line. */ 459 if (file->at_end) 460 return ""; 461 462 /* Check the cache and see if we last used this file. */ 463 if (!last_open_file_info || file != last_open_file_info) 464 { 465 if (last_open_file) 466 { 467 last_open_file_info->pos = ftell (last_open_file); 468 fclose (last_open_file); 469 } 470 471 last_open_file_info = file; 472 last_open_file = fopen (file->filename, FOPEN_RT); 473 if (last_open_file == NULL) 474 { 475 file->at_end = 1; 476 return ""; 477 } 478 479 /* Seek to where we were last time this file was open. */ 480 if (file->pos) 481 fseek (last_open_file, file->pos, SEEK_SET); 482 } 483 484 c = fgetc (last_open_file); 485 486 /* Leave room for null. */ 487 size -= 1; 488 489 while (c != EOF && c != '\n') 490 { 491 if (count < size) 492 *p++ = c; 493 count++; 494 495 c = fgetc (last_open_file); 496 497 } 498 if (c == EOF) 499 { 500 file->at_end = 1; 501 if (count + 2 < size) 502 { 503 *p++ = '.'; 504 *p++ = '.'; 505 *p++ = '.'; 506 } 507 } 508 file->linenum++; 509 *p++ = 0; 510 return line; 511 } 512 513 static const char *fn; 514 515 static unsigned int eject; /* Eject pending */ 516 static unsigned int page; /* Current page number */ 517 static char *title; /* Current title */ 518 static char *subtitle; /* Current subtitle */ 519 static unsigned int on_page; /* Number of lines printed on current page */ 520 521 static void 522 listing_page (list_info_type *list) 523 { 524 /* Grope around, see if we can see a title or subtitle edict coming up 525 soon. (we look down 10 lines of the page and see if it's there) */ 526 if ((eject || (on_page >= (unsigned int) paper_height)) 527 && paper_height != 0) 528 { 529 unsigned int c = 10; 530 int had_title = 0; 531 int had_subtitle = 0; 532 533 page++; 534 535 while (c != 0 && list) 536 { 537 if (list->edict == EDICT_SBTTL && !had_subtitle) 538 { 539 had_subtitle = 1; 540 subtitle = list->edict_arg; 541 } 542 if (list->edict == EDICT_TITLE && !had_title) 543 { 544 had_title = 1; 545 title = list->edict_arg; 546 } 547 list = list->next; 548 c--; 549 } 550 551 if (page > 1) 552 { 553 fprintf (list_file, "\f"); 554 } 555 556 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page); 557 fprintf (list_file, "%s\n", title); 558 fprintf (list_file, "%s\n", subtitle); 559 on_page = 3; 560 eject = 0; 561 } 562 } 563 564 static unsigned int 565 calc_hex (list_info_type *list) 566 { 567 int data_buffer_size; 568 list_info_type *first = list; 569 unsigned int address = ~(unsigned int) 0; 570 fragS *frag; 571 fragS *frag_ptr; 572 unsigned int octet_in_frag; 573 574 /* Find first frag which says it belongs to this line. */ 575 frag = list->frag; 576 while (frag && frag->line != list) 577 frag = frag->fr_next; 578 579 frag_ptr = frag; 580 581 data_buffer_size = 0; 582 583 /* Dump all the frags which belong to this line. */ 584 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first) 585 { 586 /* Print as many bytes from the fixed part as is sensible. */ 587 octet_in_frag = 0; 588 while ((offsetT) octet_in_frag < frag_ptr->fr_fix 589 && data_buffer_size < MAX_BYTES - 3) 590 { 591 if (address == ~(unsigned int) 0) 592 address = frag_ptr->fr_address / OCTETS_PER_BYTE; 593 594 sprintf (data_buffer + data_buffer_size, 595 "%02X", 596 (frag_ptr->fr_literal[octet_in_frag]) & 0xff); 597 data_buffer_size += 2; 598 octet_in_frag++; 599 } 600 if (frag_ptr->fr_type == rs_fill) 601 { 602 unsigned int var_rep_max = octet_in_frag; 603 unsigned int var_rep_idx = octet_in_frag; 604 605 /* Print as many bytes from the variable part as is sensible. */ 606 while (((offsetT) octet_in_frag 607 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset)) 608 && data_buffer_size < MAX_BYTES - 3) 609 { 610 if (address == ~(unsigned int) 0) 611 address = frag_ptr->fr_address / OCTETS_PER_BYTE; 612 613 sprintf (data_buffer + data_buffer_size, 614 "%02X", 615 (frag_ptr->fr_literal[var_rep_idx]) & 0xff); 616 #if 0 617 data_buffer[data_buffer_size++] = '*'; 618 data_buffer[data_buffer_size++] = '*'; 619 #endif 620 data_buffer_size += 2; 621 622 var_rep_idx++; 623 octet_in_frag++; 624 625 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var) 626 var_rep_idx = var_rep_max; 627 } 628 } 629 630 frag_ptr = frag_ptr->fr_next; 631 } 632 data_buffer[data_buffer_size] = '\0'; 633 return address; 634 } 635 636 static void 637 print_lines (list_info_type *list, unsigned int lineno, 638 char *string, unsigned int address) 639 { 640 unsigned int idx; 641 unsigned int nchars; 642 unsigned int lines; 643 unsigned int octet_in_word = 0; 644 char *src = data_buffer; 645 int cur; 646 647 /* Print the stuff on the first line. */ 648 listing_page (list); 649 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width; 650 651 /* Print the hex for the first line. */ 652 if (address == ~(unsigned int) 0) 653 { 654 fprintf (list_file, "% 4d ", lineno); 655 for (idx = 0; idx < nchars; idx++) 656 fprintf (list_file, " "); 657 658 fprintf (list_file, "\t%s\n", string ? string : ""); 659 660 on_page++; 661 662 listing_page (0); 663 664 return; 665 } 666 667 if (had_errors ()) 668 fprintf (list_file, "% 4d ???? ", lineno); 669 else 670 fprintf (list_file, "% 4d %04x ", lineno, address); 671 672 /* And the data to go along with it. */ 673 idx = 0; 674 cur = 0; 675 while (src[cur] && idx < nchars) 676 { 677 int offset; 678 offset = cur; 679 fprintf (list_file, "%c%c", src[offset], src[offset + 1]); 680 cur += 2; 681 octet_in_word++; 682 683 if (octet_in_word == LISTING_WORD_SIZE) 684 { 685 fprintf (list_file, " "); 686 idx++; 687 octet_in_word = 0; 688 } 689 690 idx += 2; 691 } 692 693 for (; idx < nchars; idx++) 694 fprintf (list_file, " "); 695 696 fprintf (list_file, "\t%s\n", string ? string : ""); 697 on_page++; 698 listing_page (list); 699 700 if (list->message) 701 { 702 fprintf (list_file, "**** %s\n", list->message); 703 listing_page (list); 704 on_page++; 705 } 706 707 for (lines = 0; 708 lines < (unsigned int) listing_lhs_cont_lines 709 && src[cur]; 710 lines++) 711 { 712 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1; 713 idx = 0; 714 715 /* Print any more lines of data, but more compactly. */ 716 fprintf (list_file, "% 4d ", lineno); 717 718 while (src[cur] && idx < nchars) 719 { 720 int offset; 721 offset = cur; 722 fprintf (list_file, "%c%c", src[offset], src[offset + 1]); 723 cur += 2; 724 idx += 2; 725 octet_in_word++; 726 727 if (octet_in_word == LISTING_WORD_SIZE) 728 { 729 fprintf (list_file, " "); 730 idx++; 731 octet_in_word = 0; 732 } 733 } 734 735 fprintf (list_file, "\n"); 736 on_page++; 737 listing_page (list); 738 } 739 } 740 741 static void 742 list_symbol_table (void) 743 { 744 extern symbolS *symbol_rootP; 745 int got_some = 0; 746 747 symbolS *ptr; 748 eject = 1; 749 listing_page (0); 750 751 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) 752 { 753 if (SEG_NORMAL (S_GET_SEGMENT (ptr)) 754 || S_GET_SEGMENT (ptr) == absolute_section) 755 { 756 #ifdef BFD_ASSEMBLER 757 /* Don't report section symbols. They are not interesting. */ 758 if (symbol_section_p (ptr)) 759 continue; 760 #endif 761 if (S_GET_NAME (ptr)) 762 { 763 char buf[30], fmt[8]; 764 valueT val = S_GET_VALUE (ptr); 765 766 /* @@ Note that this is dependent on the compilation options, 767 not solely on the target characteristics. */ 768 if (sizeof (val) == 4 && sizeof (int) == 4) 769 sprintf (buf, "%08lx", (unsigned long) val); 770 else if (sizeof (val) <= sizeof (unsigned long)) 771 { 772 sprintf (fmt, "%%0%lulx", 773 (unsigned long) (sizeof (val) * 2)); 774 sprintf (buf, fmt, (unsigned long) val); 775 } 776 #if defined (BFD64) 777 else if (sizeof (val) > 4) 778 sprintf_vma (buf, val); 779 #endif 780 else 781 abort (); 782 783 if (!got_some) 784 { 785 fprintf (list_file, "DEFINED SYMBOLS\n"); 786 on_page++; 787 got_some = 1; 788 } 789 790 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line) 791 { 792 fprintf (list_file, "%20s:%-5d %s:%s %s\n", 793 symbol_get_frag (ptr)->line->file->filename, 794 symbol_get_frag (ptr)->line->line, 795 segment_name (S_GET_SEGMENT (ptr)), 796 buf, S_GET_NAME (ptr)); 797 } 798 else 799 { 800 fprintf (list_file, "%33s:%s %s\n", 801 segment_name (S_GET_SEGMENT (ptr)), 802 buf, S_GET_NAME (ptr)); 803 } 804 805 on_page++; 806 listing_page (0); 807 } 808 } 809 810 } 811 if (!got_some) 812 { 813 fprintf (list_file, "NO DEFINED SYMBOLS\n"); 814 on_page++; 815 } 816 fprintf (list_file, "\n"); 817 on_page++; 818 listing_page (0); 819 820 got_some = 0; 821 822 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) 823 { 824 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0) 825 { 826 if (S_GET_SEGMENT (ptr) == undefined_section) 827 { 828 if (!got_some) 829 { 830 got_some = 1; 831 fprintf (list_file, "UNDEFINED SYMBOLS\n"); 832 on_page++; 833 listing_page (0); 834 } 835 fprintf (list_file, "%s\n", S_GET_NAME (ptr)); 836 on_page++; 837 listing_page (0); 838 } 839 } 840 } 841 if (!got_some) 842 { 843 fprintf (list_file, "NO UNDEFINED SYMBOLS\n"); 844 on_page++; 845 listing_page (0); 846 } 847 } 848 849 static void 850 print_source (file_info_type *current_file, list_info_type *list, 851 char *buffer, unsigned int width) 852 { 853 if (!current_file->at_end) 854 { 855 while (current_file->linenum < list->hll_line 856 && !current_file->at_end) 857 { 858 char *p = buffer_line (current_file, buffer, width); 859 860 fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum, 861 current_file->filename, p); 862 on_page++; 863 listing_page (list); 864 } 865 } 866 } 867 868 /* Sometimes the user doesn't want to be bothered by the debugging 869 records inserted by the compiler, see if the line is suspicious. */ 870 871 static int 872 debugging_pseudo (list_info_type *list, const char *line) 873 { 874 static int in_debug; 875 int was_debug; 876 877 if (list->debugging) 878 { 879 in_debug = 1; 880 return 1; 881 } 882 883 was_debug = in_debug; 884 in_debug = 0; 885 886 while (ISSPACE (*line)) 887 line++; 888 889 if (*line != '.') 890 { 891 #ifdef OBJ_ELF 892 /* The ELF compiler sometimes emits blank lines after switching 893 out of a debugging section. If the next line drops us back 894 into debugging information, then don't print the blank line. 895 This is a hack for a particular compiler behaviour, not a 896 general case. */ 897 if (was_debug 898 && *line == '\0' 899 && list->next != NULL 900 && list->next->debugging) 901 { 902 in_debug = 1; 903 return 1; 904 } 905 #endif 906 907 return 0; 908 } 909 910 line++; 911 912 if (strncmp (line, "def", 3) == 0) 913 return 1; 914 if (strncmp (line, "val", 3) == 0) 915 return 1; 916 if (strncmp (line, "scl", 3) == 0) 917 return 1; 918 if (strncmp (line, "line", 4) == 0) 919 return 1; 920 if (strncmp (line, "endef", 5) == 0) 921 return 1; 922 if (strncmp (line, "ln", 2) == 0) 923 return 1; 924 if (strncmp (line, "type", 4) == 0) 925 return 1; 926 if (strncmp (line, "size", 4) == 0) 927 return 1; 928 if (strncmp (line, "dim", 3) == 0) 929 return 1; 930 if (strncmp (line, "tag", 3) == 0) 931 return 1; 932 if (strncmp (line, "stabs", 5) == 0) 933 return 1; 934 if (strncmp (line, "stabn", 5) == 0) 935 return 1; 936 937 return 0; 938 } 939 940 static void 941 listing_listing (char *name ATTRIBUTE_UNUSED) 942 { 943 list_info_type *list = head; 944 file_info_type *current_hll_file = (file_info_type *) NULL; 945 char *message; 946 char *buffer; 947 char *p; 948 int show_listing = 1; 949 unsigned int width; 950 951 buffer = xmalloc (listing_rhs_width); 952 data_buffer = xmalloc (MAX_BYTES); 953 eject = 1; 954 list = head; 955 956 while (list != (list_info_type *) NULL && 0) 957 { 958 if (list->next) 959 list->frag = list->next->frag; 960 list = list->next; 961 } 962 963 list = head->next; 964 965 while (list) 966 { 967 unsigned int list_line; 968 969 width = listing_rhs_width > paper_width ? paper_width : 970 listing_rhs_width; 971 972 list_line = list->line; 973 switch (list->edict) 974 { 975 case EDICT_LIST: 976 /* Skip all lines up to the current. */ 977 list_line--; 978 break; 979 case EDICT_NOLIST: 980 show_listing--; 981 break; 982 case EDICT_NOLIST_NEXT: 983 if (show_listing == 0) 984 list_line--; 985 break; 986 case EDICT_EJECT: 987 break; 988 case EDICT_NONE: 989 break; 990 case EDICT_TITLE: 991 title = list->edict_arg; 992 break; 993 case EDICT_SBTTL: 994 subtitle = list->edict_arg; 995 break; 996 default: 997 abort (); 998 } 999 1000 if (show_listing <= 0) 1001 { 1002 while (list->file->linenum < list_line 1003 && !list->file->at_end) 1004 p = buffer_line (list->file, buffer, width); 1005 } 1006 1007 if (list->edict == EDICT_LIST 1008 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0)) 1009 { 1010 /* Enable listing for the single line that caused the enable. */ 1011 list_line++; 1012 show_listing++; 1013 } 1014 1015 if (show_listing > 0) 1016 { 1017 /* Scan down the list and print all the stuff which can be done 1018 with this line (or lines). */ 1019 message = 0; 1020 1021 if (list->hll_file) 1022 current_hll_file = list->hll_file; 1023 1024 if (current_hll_file && list->hll_line && (listing & LISTING_HLL)) 1025 print_source (current_hll_file, list, buffer, width); 1026 1027 if (list->line_contents) 1028 { 1029 if (!((listing & LISTING_NODEBUG) 1030 && debugging_pseudo (list, list->line_contents))) 1031 print_lines (list, 1032 list->file->linenum == 0 ? list->line : list->file->linenum, 1033 list->line_contents, calc_hex (list)); 1034 1035 free (list->line_contents); 1036 list->line_contents = NULL; 1037 } 1038 else 1039 { 1040 while (list->file->linenum < list_line 1041 && !list->file->at_end) 1042 { 1043 unsigned int address; 1044 1045 p = buffer_line (list->file, buffer, width); 1046 1047 if (list->file->linenum < list_line) 1048 address = ~(unsigned int) 0; 1049 else 1050 address = calc_hex (list); 1051 1052 if (!((listing & LISTING_NODEBUG) 1053 && debugging_pseudo (list, p))) 1054 print_lines (list, list->file->linenum, p, address); 1055 } 1056 } 1057 1058 if (list->edict == EDICT_EJECT) 1059 eject = 1; 1060 } 1061 1062 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1) 1063 --show_listing; 1064 1065 list = list->next; 1066 } 1067 1068 free (buffer); 1069 free (data_buffer); 1070 data_buffer = NULL; 1071 } 1072 1073 void 1074 listing_print (char *name) 1075 { 1076 int using_stdout; 1077 1078 title = ""; 1079 subtitle = ""; 1080 1081 if (name == NULL) 1082 { 1083 list_file = stdout; 1084 using_stdout = 1; 1085 } 1086 else 1087 { 1088 list_file = fopen (name, FOPEN_WT); 1089 if (list_file != NULL) 1090 using_stdout = 0; 1091 else 1092 { 1093 #ifdef BFD_ASSEMBLER 1094 bfd_set_error (bfd_error_system_call); 1095 #endif 1096 as_perror (_("can't open list file: %s"), name); 1097 list_file = stdout; 1098 using_stdout = 1; 1099 } 1100 } 1101 1102 if (listing & LISTING_NOFORM) 1103 paper_height = 0; 1104 1105 if (listing & LISTING_LISTING) 1106 listing_listing (name); 1107 1108 if (listing & LISTING_SYMBOLS) 1109 list_symbol_table (); 1110 1111 if (! using_stdout) 1112 { 1113 if (fclose (list_file) == EOF) 1114 { 1115 #ifdef BFD_ASSEMBLER 1116 bfd_set_error (bfd_error_system_call); 1117 #endif 1118 as_perror (_("error closing list file: %s"), name); 1119 } 1120 } 1121 1122 if (last_open_file) 1123 fclose (last_open_file); 1124 } 1125 1126 void 1127 listing_file (const char *name) 1128 { 1129 fn = name; 1130 } 1131 1132 void 1133 listing_eject (int ignore ATTRIBUTE_UNUSED) 1134 { 1135 if (listing) 1136 listing_tail->edict = EDICT_EJECT; 1137 } 1138 1139 void 1140 listing_flags (int ignore ATTRIBUTE_UNUSED) 1141 { 1142 while ((*input_line_pointer++) && (*input_line_pointer != '\n')) 1143 input_line_pointer++; 1144 1145 } 1146 1147 /* Turn listing on or off. An argument of 0 means to turn off 1148 listing. An argument of 1 means to turn on listing. An argument 1149 of 2 means to turn off listing, but as of the next line; that is, 1150 the current line should be listed, but the next line should not. */ 1151 1152 void 1153 listing_list (int on) 1154 { 1155 if (listing) 1156 { 1157 switch (on) 1158 { 1159 case 0: 1160 if (listing_tail->edict == EDICT_LIST) 1161 listing_tail->edict = EDICT_NONE; 1162 else 1163 listing_tail->edict = EDICT_NOLIST; 1164 break; 1165 case 1: 1166 if (listing_tail->edict == EDICT_NOLIST 1167 || listing_tail->edict == EDICT_NOLIST_NEXT) 1168 listing_tail->edict = EDICT_NONE; 1169 else 1170 listing_tail->edict = EDICT_LIST; 1171 break; 1172 case 2: 1173 listing_tail->edict = EDICT_NOLIST_NEXT; 1174 break; 1175 default: 1176 abort (); 1177 } 1178 } 1179 } 1180 1181 void 1182 listing_psize (int width_only) 1183 { 1184 if (! width_only) 1185 { 1186 paper_height = get_absolute_expression (); 1187 1188 if (paper_height < 0 || paper_height > 1000) 1189 { 1190 paper_height = 0; 1191 as_warn (_("strange paper height, set to no form")); 1192 } 1193 1194 if (*input_line_pointer != ',') 1195 { 1196 demand_empty_rest_of_line (); 1197 return; 1198 } 1199 1200 ++input_line_pointer; 1201 } 1202 1203 paper_width = get_absolute_expression (); 1204 1205 demand_empty_rest_of_line (); 1206 } 1207 1208 void 1209 listing_nopage (int ignore ATTRIBUTE_UNUSED) 1210 { 1211 paper_height = 0; 1212 } 1213 1214 void 1215 listing_title (int depth) 1216 { 1217 int quoted; 1218 char *start; 1219 char *ttl; 1220 unsigned int length; 1221 1222 SKIP_WHITESPACE (); 1223 if (*input_line_pointer != '\"') 1224 quoted = 0; 1225 else 1226 { 1227 quoted = 1; 1228 ++input_line_pointer; 1229 } 1230 1231 start = input_line_pointer; 1232 1233 while (*input_line_pointer) 1234 { 1235 if (quoted 1236 ? *input_line_pointer == '\"' 1237 : is_end_of_line[(unsigned char) *input_line_pointer]) 1238 { 1239 if (listing) 1240 { 1241 length = input_line_pointer - start; 1242 ttl = xmalloc (length + 1); 1243 memcpy (ttl, start, length); 1244 ttl[length] = 0; 1245 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE; 1246 listing_tail->edict_arg = ttl; 1247 } 1248 if (quoted) 1249 input_line_pointer++; 1250 demand_empty_rest_of_line (); 1251 return; 1252 } 1253 else if (*input_line_pointer == '\n') 1254 { 1255 as_bad (_("new line in title")); 1256 demand_empty_rest_of_line (); 1257 return; 1258 } 1259 else 1260 { 1261 input_line_pointer++; 1262 } 1263 } 1264 } 1265 1266 void 1267 listing_source_line (unsigned int line) 1268 { 1269 if (listing) 1270 { 1271 new_frag (); 1272 listing_tail->hll_line = line; 1273 new_frag (); 1274 } 1275 } 1276 1277 void 1278 listing_source_file (const char *file) 1279 { 1280 if (listing) 1281 listing_tail->hll_file = file_info (file); 1282 } 1283 1284 #else 1285 1286 /* Dummy functions for when compiled without listing enabled. */ 1287 1288 void 1289 listing_flags (int ignore) 1290 { 1291 s_ignore (0); 1292 } 1293 1294 void 1295 listing_list (int on) 1296 { 1297 s_ignore (0); 1298 } 1299 1300 void 1301 listing_eject (int ignore) 1302 { 1303 s_ignore (0); 1304 } 1305 1306 void 1307 listing_psize (int ignore) 1308 { 1309 s_ignore (0); 1310 } 1311 1312 void 1313 listing_nopage (int ignore) 1314 { 1315 s_ignore (0); 1316 } 1317 1318 void 1319 listing_title (int depth) 1320 { 1321 s_ignore (0); 1322 } 1323 1324 void 1325 listing_file (const char *name) 1326 { 1327 } 1328 1329 void 1330 listing_newline (char *name) 1331 { 1332 } 1333 1334 void 1335 listing_source_line (unsigned int n) 1336 { 1337 } 1338 1339 void 1340 listing_source_file (const char *n) 1341 { 1342 } 1343 1344 #endif 1345