1 /* Fortran language support routines for GDB, the GNU debugger. 2 3 Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 4 2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. 5 6 Contributed by Motorola. Adapted from the C parser by Farooq Butt 7 (fmbutt@engage.sps.mot.com). 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 23 24 #include "defs.h" 25 #include "gdb_string.h" 26 #include "symtab.h" 27 #include "gdbtypes.h" 28 #include "expression.h" 29 #include "parser-defs.h" 30 #include "language.h" 31 #include "f-lang.h" 32 #include "valprint.h" 33 #include "value.h" 34 #include "cp-support.h" 35 36 37 /* Following is dubious stuff that had been in the xcoff reader. */ 38 39 struct saved_fcn 40 { 41 long line_offset; /* Line offset for function. */ 42 struct saved_fcn *next; 43 }; 44 45 46 struct saved_bf_symnum 47 { 48 long symnum_fcn; /* Symnum of function (i.e. .function 49 directive). */ 50 long symnum_bf; /* Symnum of .bf for this function. */ 51 struct saved_bf_symnum *next; 52 }; 53 54 typedef struct saved_fcn SAVED_FUNCTION, *SAVED_FUNCTION_PTR; 55 typedef struct saved_bf_symnum SAVED_BF, *SAVED_BF_PTR; 56 57 /* Local functions */ 58 59 extern void _initialize_f_language (void); 60 #if 0 61 static void clear_function_list (void); 62 static long get_bf_for_fcn (long); 63 static void clear_bf_list (void); 64 static void patch_all_commons_by_name (char *, CORE_ADDR, int); 65 static SAVED_F77_COMMON_PTR find_first_common_named (char *); 66 static void add_common_entry (struct symbol *); 67 static void add_common_block (char *, CORE_ADDR, int, char *); 68 static SAVED_FUNCTION *allocate_saved_function_node (void); 69 static SAVED_BF_PTR allocate_saved_bf_node (void); 70 static COMMON_ENTRY_PTR allocate_common_entry_node (void); 71 static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node (void); 72 static void patch_common_entries (SAVED_F77_COMMON_PTR, CORE_ADDR, int); 73 #endif 74 75 static void f_printchar (int c, struct type *type, struct ui_file * stream); 76 static void f_emit_char (int c, struct type *type, 77 struct ui_file * stream, int quoter); 78 79 /* Print the character C on STREAM as part of the contents of a literal 80 string whose delimiter is QUOTER. Note that that format for printing 81 characters and strings is language specific. 82 FIXME: This is a copy of the same function from c-exp.y. It should 83 be replaced with a true F77 version. */ 84 85 static void 86 f_emit_char (int c, struct type *type, struct ui_file *stream, int quoter) 87 { 88 c &= 0xFF; /* Avoid sign bit follies. */ 89 90 if (PRINT_LITERAL_FORM (c)) 91 { 92 if (c == '\\' || c == quoter) 93 fputs_filtered ("\\", stream); 94 fprintf_filtered (stream, "%c", c); 95 } 96 else 97 { 98 switch (c) 99 { 100 case '\n': 101 fputs_filtered ("\\n", stream); 102 break; 103 case '\b': 104 fputs_filtered ("\\b", stream); 105 break; 106 case '\t': 107 fputs_filtered ("\\t", stream); 108 break; 109 case '\f': 110 fputs_filtered ("\\f", stream); 111 break; 112 case '\r': 113 fputs_filtered ("\\r", stream); 114 break; 115 case '\033': 116 fputs_filtered ("\\e", stream); 117 break; 118 case '\007': 119 fputs_filtered ("\\a", stream); 120 break; 121 default: 122 fprintf_filtered (stream, "\\%.3o", (unsigned int) c); 123 break; 124 } 125 } 126 } 127 128 /* FIXME: This is a copy of the same function from c-exp.y. It should 129 be replaced with a true F77version. */ 130 131 static void 132 f_printchar (int c, struct type *type, struct ui_file *stream) 133 { 134 fputs_filtered ("'", stream); 135 LA_EMIT_CHAR (c, type, stream, '\''); 136 fputs_filtered ("'", stream); 137 } 138 139 /* Print the character string STRING, printing at most LENGTH characters. 140 Printing stops early if the number hits print_max; repeat counts 141 are printed as appropriate. Print ellipses at the end if we 142 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. 143 FIXME: This is a copy of the same function from c-exp.y. It should 144 be replaced with a true F77 version. */ 145 146 static void 147 f_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string, 148 unsigned int length, const char *encoding, int force_ellipses, 149 const struct value_print_options *options) 150 { 151 unsigned int i; 152 unsigned int things_printed = 0; 153 int in_quotes = 0; 154 int need_comma = 0; 155 156 if (length == 0) 157 { 158 fputs_filtered ("''", gdb_stdout); 159 return; 160 } 161 162 for (i = 0; i < length && things_printed < options->print_max; ++i) 163 { 164 /* Position of the character we are examining 165 to see whether it is repeated. */ 166 unsigned int rep1; 167 /* Number of repetitions we have detected so far. */ 168 unsigned int reps; 169 170 QUIT; 171 172 if (need_comma) 173 { 174 fputs_filtered (", ", stream); 175 need_comma = 0; 176 } 177 178 rep1 = i + 1; 179 reps = 1; 180 while (rep1 < length && string[rep1] == string[i]) 181 { 182 ++rep1; 183 ++reps; 184 } 185 186 if (reps > options->repeat_count_threshold) 187 { 188 if (in_quotes) 189 { 190 if (options->inspect_it) 191 fputs_filtered ("\\', ", stream); 192 else 193 fputs_filtered ("', ", stream); 194 in_quotes = 0; 195 } 196 f_printchar (string[i], type, stream); 197 fprintf_filtered (stream, " <repeats %u times>", reps); 198 i = rep1 - 1; 199 things_printed += options->repeat_count_threshold; 200 need_comma = 1; 201 } 202 else 203 { 204 if (!in_quotes) 205 { 206 if (options->inspect_it) 207 fputs_filtered ("\\'", stream); 208 else 209 fputs_filtered ("'", stream); 210 in_quotes = 1; 211 } 212 LA_EMIT_CHAR (string[i], type, stream, '"'); 213 ++things_printed; 214 } 215 } 216 217 /* Terminate the quotes if necessary. */ 218 if (in_quotes) 219 { 220 if (options->inspect_it) 221 fputs_filtered ("\\'", stream); 222 else 223 fputs_filtered ("'", stream); 224 } 225 226 if (force_ellipses || i < length) 227 fputs_filtered ("...", stream); 228 } 229 230 231 /* Table of operators and their precedences for printing expressions. */ 232 233 static const struct op_print f_op_print_tab[] = 234 { 235 {"+", BINOP_ADD, PREC_ADD, 0}, 236 {"+", UNOP_PLUS, PREC_PREFIX, 0}, 237 {"-", BINOP_SUB, PREC_ADD, 0}, 238 {"-", UNOP_NEG, PREC_PREFIX, 0}, 239 {"*", BINOP_MUL, PREC_MUL, 0}, 240 {"/", BINOP_DIV, PREC_MUL, 0}, 241 {"DIV", BINOP_INTDIV, PREC_MUL, 0}, 242 {"MOD", BINOP_REM, PREC_MUL, 0}, 243 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 244 {".OR.", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 245 {".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 246 {".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 247 {".EQ.", BINOP_EQUAL, PREC_EQUAL, 0}, 248 {".NE.", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 249 {".LE.", BINOP_LEQ, PREC_ORDER, 0}, 250 {".GE.", BINOP_GEQ, PREC_ORDER, 0}, 251 {".GT.", BINOP_GTR, PREC_ORDER, 0}, 252 {".LT.", BINOP_LESS, PREC_ORDER, 0}, 253 {"**", UNOP_IND, PREC_PREFIX, 0}, 254 {"@", BINOP_REPEAT, PREC_REPEAT, 0}, 255 {NULL, 0, 0, 0} 256 }; 257 258 enum f_primitive_types { 259 f_primitive_type_character, 260 f_primitive_type_logical, 261 f_primitive_type_logical_s1, 262 f_primitive_type_logical_s2, 263 f_primitive_type_logical_s8, 264 f_primitive_type_integer, 265 f_primitive_type_integer_s2, 266 f_primitive_type_real, 267 f_primitive_type_real_s8, 268 f_primitive_type_real_s16, 269 f_primitive_type_complex_s8, 270 f_primitive_type_complex_s16, 271 f_primitive_type_void, 272 nr_f_primitive_types 273 }; 274 275 static void 276 f_language_arch_info (struct gdbarch *gdbarch, 277 struct language_arch_info *lai) 278 { 279 const struct builtin_f_type *builtin = builtin_f_type (gdbarch); 280 281 lai->string_char_type = builtin->builtin_character; 282 lai->primitive_type_vector 283 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_f_primitive_types + 1, 284 struct type *); 285 286 lai->primitive_type_vector [f_primitive_type_character] 287 = builtin->builtin_character; 288 lai->primitive_type_vector [f_primitive_type_logical] 289 = builtin->builtin_logical; 290 lai->primitive_type_vector [f_primitive_type_logical_s1] 291 = builtin->builtin_logical_s1; 292 lai->primitive_type_vector [f_primitive_type_logical_s2] 293 = builtin->builtin_logical_s2; 294 lai->primitive_type_vector [f_primitive_type_logical_s8] 295 = builtin->builtin_logical_s8; 296 lai->primitive_type_vector [f_primitive_type_real] 297 = builtin->builtin_real; 298 lai->primitive_type_vector [f_primitive_type_real_s8] 299 = builtin->builtin_real_s8; 300 lai->primitive_type_vector [f_primitive_type_real_s16] 301 = builtin->builtin_real_s16; 302 lai->primitive_type_vector [f_primitive_type_complex_s8] 303 = builtin->builtin_complex_s8; 304 lai->primitive_type_vector [f_primitive_type_complex_s16] 305 = builtin->builtin_complex_s16; 306 lai->primitive_type_vector [f_primitive_type_void] 307 = builtin->builtin_void; 308 309 lai->bool_type_symbol = "logical"; 310 lai->bool_type_default = builtin->builtin_logical_s2; 311 } 312 313 /* Remove the modules separator :: from the default break list. */ 314 315 static char * 316 f_word_break_characters (void) 317 { 318 static char *retval; 319 320 if (!retval) 321 { 322 char *s; 323 324 retval = xstrdup (default_word_break_characters ()); 325 s = strchr (retval, ':'); 326 if (s) 327 { 328 char *last_char = &s[strlen (s) - 1]; 329 330 *s = *last_char; 331 *last_char = 0; 332 } 333 } 334 return retval; 335 } 336 337 /* Consider the modules separator :: as a valid symbol name character 338 class. */ 339 340 static char ** 341 f_make_symbol_completion_list (char *text, char *word) 342 { 343 return default_make_symbol_completion_list_break_on (text, word, ":"); 344 } 345 346 /* This is declared in c-lang.h but it is silly to import that file for what 347 is already just a hack. */ 348 extern int c_value_print (struct value *, struct ui_file *, 349 const struct value_print_options *); 350 351 const struct language_defn f_language_defn = 352 { 353 "fortran", 354 language_fortran, 355 range_check_on, 356 type_check_on, 357 case_sensitive_off, 358 array_column_major, 359 macro_expansion_no, 360 &exp_descriptor_standard, 361 f_parse, /* parser */ 362 f_error, /* parser error function */ 363 null_post_parser, 364 f_printchar, /* Print character constant */ 365 f_printstr, /* function to print string constant */ 366 f_emit_char, /* Function to print a single character */ 367 f_print_type, /* Print a type using appropriate syntax */ 368 default_print_typedef, /* Print a typedef using appropriate syntax */ 369 f_val_print, /* Print a value using appropriate syntax */ 370 c_value_print, /* FIXME */ 371 NULL, /* Language specific skip_trampoline */ 372 NULL, /* name_of_this */ 373 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 374 basic_lookup_transparent_type,/* lookup_transparent_type */ 375 NULL, /* Language specific symbol demangler */ 376 NULL, /* Language specific 377 class_name_from_physname */ 378 f_op_print_tab, /* expression operators for printing */ 379 0, /* arrays are first-class (not c-style) */ 380 1, /* String lower bound */ 381 f_word_break_characters, 382 f_make_symbol_completion_list, 383 f_language_arch_info, 384 default_print_array_index, 385 default_pass_by_reference, 386 default_get_string, 387 LANG_MAGIC 388 }; 389 390 static void * 391 build_fortran_types (struct gdbarch *gdbarch) 392 { 393 struct builtin_f_type *builtin_f_type 394 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type); 395 396 builtin_f_type->builtin_void 397 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "VOID"); 398 399 builtin_f_type->builtin_character 400 = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "character"); 401 402 builtin_f_type->builtin_logical_s1 403 = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1"); 404 405 builtin_f_type->builtin_integer_s2 406 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 0, 407 "integer*2"); 408 409 builtin_f_type->builtin_logical_s2 410 = arch_boolean_type (gdbarch, gdbarch_short_bit (gdbarch), 1, 411 "logical*2"); 412 413 builtin_f_type->builtin_logical_s8 414 = arch_boolean_type (gdbarch, gdbarch_long_long_bit (gdbarch), 1, 415 "logical*8"); 416 417 builtin_f_type->builtin_integer 418 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, 419 "integer"); 420 421 builtin_f_type->builtin_logical 422 = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, 423 "logical*4"); 424 425 builtin_f_type->builtin_real 426 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), 427 "real", NULL); 428 builtin_f_type->builtin_real_s8 429 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), 430 "real*8", NULL); 431 builtin_f_type->builtin_real_s16 432 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), 433 "real*16", NULL); 434 435 builtin_f_type->builtin_complex_s8 436 = arch_complex_type (gdbarch, "complex*8", 437 builtin_f_type->builtin_real); 438 builtin_f_type->builtin_complex_s16 439 = arch_complex_type (gdbarch, "complex*16", 440 builtin_f_type->builtin_real_s8); 441 builtin_f_type->builtin_complex_s32 442 = arch_complex_type (gdbarch, "complex*32", 443 builtin_f_type->builtin_real_s16); 444 445 return builtin_f_type; 446 } 447 448 static struct gdbarch_data *f_type_data; 449 450 const struct builtin_f_type * 451 builtin_f_type (struct gdbarch *gdbarch) 452 { 453 return gdbarch_data (gdbarch, f_type_data); 454 } 455 456 void 457 _initialize_f_language (void) 458 { 459 f_type_data = gdbarch_data_register_post_init (build_fortran_types); 460 461 add_language (&f_language_defn); 462 } 463 464 #if 0 465 static SAVED_BF_PTR 466 allocate_saved_bf_node (void) 467 { 468 SAVED_BF_PTR new; 469 470 new = (SAVED_BF_PTR) xmalloc (sizeof (SAVED_BF)); 471 return (new); 472 } 473 474 static SAVED_FUNCTION * 475 allocate_saved_function_node (void) 476 { 477 SAVED_FUNCTION *new; 478 479 new = (SAVED_FUNCTION *) xmalloc (sizeof (SAVED_FUNCTION)); 480 return (new); 481 } 482 483 static SAVED_F77_COMMON_PTR 484 allocate_saved_f77_common_node (void) 485 { 486 SAVED_F77_COMMON_PTR new; 487 488 new = (SAVED_F77_COMMON_PTR) xmalloc (sizeof (SAVED_F77_COMMON)); 489 return (new); 490 } 491 492 static COMMON_ENTRY_PTR 493 allocate_common_entry_node (void) 494 { 495 COMMON_ENTRY_PTR new; 496 497 new = (COMMON_ENTRY_PTR) xmalloc (sizeof (COMMON_ENTRY)); 498 return (new); 499 } 500 #endif 501 502 SAVED_F77_COMMON_PTR head_common_list = NULL; /* Ptr to 1st saved COMMON */ 503 SAVED_F77_COMMON_PTR tail_common_list = NULL; /* Ptr to last saved COMMON */ 504 SAVED_F77_COMMON_PTR current_common = NULL; /* Ptr to current COMMON */ 505 506 #if 0 507 static SAVED_BF_PTR saved_bf_list = NULL; /* Ptr to (.bf,function) 508 list */ 509 static SAVED_BF_PTR saved_bf_list_end = NULL; /* Ptr to above list's end */ 510 static SAVED_BF_PTR current_head_bf_list = NULL; /* Current head of 511 above list. */ 512 513 static SAVED_BF_PTR tmp_bf_ptr; /* Generic temporary for use 514 in macros. */ 515 516 /* The following function simply enters a given common block onto 517 the global common block chain. */ 518 519 static void 520 add_common_block (char *name, CORE_ADDR offset, int secnum, char *func_stab) 521 { 522 SAVED_F77_COMMON_PTR tmp; 523 char *c, *local_copy_func_stab; 524 525 /* If the COMMON block we are trying to add has a blank 526 name (i.e. "#BLNK_COM") then we set it to __BLANK 527 because the darn "#" character makes GDB's input 528 parser have fits. */ 529 530 531 if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0 532 || strcmp (name, BLANK_COMMON_NAME_MF77) == 0) 533 { 534 535 xfree (name); 536 name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1); 537 strcpy (name, BLANK_COMMON_NAME_LOCAL); 538 } 539 540 tmp = allocate_saved_f77_common_node (); 541 542 local_copy_func_stab = xmalloc (strlen (func_stab) + 1); 543 strcpy (local_copy_func_stab, func_stab); 544 545 tmp->name = xmalloc (strlen (name) + 1); 546 547 /* local_copy_func_stab is a stabstring, let us first extract the 548 function name from the stab by NULLing out the ':' character. */ 549 550 551 c = NULL; 552 c = strchr (local_copy_func_stab, ':'); 553 554 if (c) 555 *c = '\0'; 556 else 557 error (_("Malformed function STAB found in add_common_block()")); 558 559 560 tmp->owning_function = xmalloc (strlen (local_copy_func_stab) + 1); 561 562 strcpy (tmp->owning_function, local_copy_func_stab); 563 564 strcpy (tmp->name, name); 565 tmp->offset = offset; 566 tmp->next = NULL; 567 tmp->entries = NULL; 568 tmp->secnum = secnum; 569 570 current_common = tmp; 571 572 if (head_common_list == NULL) 573 { 574 head_common_list = tail_common_list = tmp; 575 } 576 else 577 { 578 tail_common_list->next = tmp; 579 tail_common_list = tmp; 580 } 581 } 582 #endif 583 584 /* The following function simply enters a given common entry onto 585 the "current_common" block that has been saved away. */ 586 587 #if 0 588 static void 589 add_common_entry (struct symbol *entry_sym_ptr) 590 { 591 COMMON_ENTRY_PTR tmp; 592 593 594 595 /* The order of this list is important, since 596 we expect the entries to appear in decl. 597 order when we later issue "info common" calls. */ 598 599 tmp = allocate_common_entry_node (); 600 601 tmp->next = NULL; 602 tmp->symbol = entry_sym_ptr; 603 604 if (current_common == NULL) 605 error (_("Attempt to add COMMON entry with no block open!")); 606 else 607 { 608 if (current_common->entries == NULL) 609 { 610 current_common->entries = tmp; 611 current_common->end_of_entries = tmp; 612 } 613 else 614 { 615 current_common->end_of_entries->next = tmp; 616 current_common->end_of_entries = tmp; 617 } 618 } 619 } 620 #endif 621 622 /* This routine finds the first encountred COMMON block named "name". */ 623 624 #if 0 625 static SAVED_F77_COMMON_PTR 626 find_first_common_named (char *name) 627 { 628 629 SAVED_F77_COMMON_PTR tmp; 630 631 tmp = head_common_list; 632 633 while (tmp != NULL) 634 { 635 if (strcmp (tmp->name, name) == 0) 636 return (tmp); 637 else 638 tmp = tmp->next; 639 } 640 return (NULL); 641 } 642 #endif 643 644 /* This routine finds the first encountred COMMON block named "name" 645 that belongs to function funcname. */ 646 647 SAVED_F77_COMMON_PTR 648 find_common_for_function (char *name, char *funcname) 649 { 650 651 SAVED_F77_COMMON_PTR tmp; 652 653 tmp = head_common_list; 654 655 while (tmp != NULL) 656 { 657 if (strcmp (tmp->name, name) == 0 658 && strcmp (tmp->owning_function, funcname) == 0) 659 return (tmp); 660 else 661 tmp = tmp->next; 662 } 663 return (NULL); 664 } 665 666 667 #if 0 668 669 /* The following function is called to patch up the offsets 670 for the statics contained in the COMMON block named 671 "name." */ 672 673 static void 674 patch_common_entries (SAVED_F77_COMMON_PTR blk, CORE_ADDR offset, int secnum) 675 { 676 COMMON_ENTRY_PTR entry; 677 678 blk->offset = offset; /* Keep this around for future use. */ 679 680 entry = blk->entries; 681 682 while (entry != NULL) 683 { 684 SYMBOL_VALUE (entry->symbol) += offset; 685 SYMBOL_SECTION (entry->symbol) = secnum; 686 687 entry = entry->next; 688 } 689 blk->secnum = secnum; 690 } 691 692 /* Patch all commons named "name" that need patching.Since COMMON 693 blocks occur with relative infrequency, we simply do a linear scan on 694 the name. Eventually, the best way to do this will be a 695 hashed-lookup. Secnum is the section number for the .bss section 696 (which is where common data lives). */ 697 698 static void 699 patch_all_commons_by_name (char *name, CORE_ADDR offset, int secnum) 700 { 701 702 SAVED_F77_COMMON_PTR tmp; 703 704 /* For blank common blocks, change the canonical reprsentation 705 of a blank name */ 706 707 if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0 708 || strcmp (name, BLANK_COMMON_NAME_MF77) == 0) 709 { 710 xfree (name); 711 name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1); 712 strcpy (name, BLANK_COMMON_NAME_LOCAL); 713 } 714 715 tmp = head_common_list; 716 717 while (tmp != NULL) 718 { 719 if (COMMON_NEEDS_PATCHING (tmp)) 720 if (strcmp (tmp->name, name) == 0) 721 patch_common_entries (tmp, offset, secnum); 722 723 tmp = tmp->next; 724 } 725 } 726 #endif 727 728 /* This macro adds the symbol-number for the start of the function 729 (the symbol number of the .bf) referenced by symnum_fcn to a 730 list. This list, in reality should be a FIFO queue but since 731 #line pragmas sometimes cause line ranges to get messed up 732 we simply create a linear list. This list can then be searched 733 first by a queueing algorithm and upon failure fall back to 734 a linear scan. */ 735 736 #if 0 737 #define ADD_BF_SYMNUM(bf_sym,fcn_sym) \ 738 \ 739 if (saved_bf_list == NULL) \ 740 { \ 741 tmp_bf_ptr = allocate_saved_bf_node(); \ 742 \ 743 tmp_bf_ptr->symnum_bf = (bf_sym); \ 744 tmp_bf_ptr->symnum_fcn = (fcn_sym); \ 745 tmp_bf_ptr->next = NULL; \ 746 \ 747 current_head_bf_list = saved_bf_list = tmp_bf_ptr; \ 748 saved_bf_list_end = tmp_bf_ptr; \ 749 } \ 750 else \ 751 { \ 752 tmp_bf_ptr = allocate_saved_bf_node(); \ 753 \ 754 tmp_bf_ptr->symnum_bf = (bf_sym); \ 755 tmp_bf_ptr->symnum_fcn = (fcn_sym); \ 756 tmp_bf_ptr->next = NULL; \ 757 \ 758 saved_bf_list_end->next = tmp_bf_ptr; \ 759 saved_bf_list_end = tmp_bf_ptr; \ 760 } 761 #endif 762 763 /* This function frees the entire (.bf,function) list. */ 764 765 #if 0 766 static void 767 clear_bf_list (void) 768 { 769 770 SAVED_BF_PTR tmp = saved_bf_list; 771 SAVED_BF_PTR next = NULL; 772 773 while (tmp != NULL) 774 { 775 next = tmp->next; 776 xfree (tmp); 777 tmp = next; 778 } 779 saved_bf_list = NULL; 780 } 781 #endif 782 783 int global_remote_debug; 784 785 #if 0 786 787 static long 788 get_bf_for_fcn (long the_function) 789 { 790 SAVED_BF_PTR tmp; 791 int nprobes = 0; 792 793 /* First use a simple queuing algorithm (i.e. look and see if the 794 item at the head of the queue is the one you want). */ 795 796 if (saved_bf_list == NULL) 797 internal_error (__FILE__, __LINE__, 798 _("cannot get .bf node off empty list")); 799 800 if (current_head_bf_list != NULL) 801 if (current_head_bf_list->symnum_fcn == the_function) 802 { 803 if (global_remote_debug) 804 fprintf_unfiltered (gdb_stderr, "*"); 805 806 tmp = current_head_bf_list; 807 current_head_bf_list = current_head_bf_list->next; 808 return (tmp->symnum_bf); 809 } 810 811 /* If the above did not work (probably because #line directives were 812 used in the sourcefile and they messed up our internal tables) we now do 813 the ugly linear scan. */ 814 815 if (global_remote_debug) 816 fprintf_unfiltered (gdb_stderr, "\ndefaulting to linear scan\n"); 817 818 nprobes = 0; 819 tmp = saved_bf_list; 820 while (tmp != NULL) 821 { 822 nprobes++; 823 if (tmp->symnum_fcn == the_function) 824 { 825 if (global_remote_debug) 826 fprintf_unfiltered (gdb_stderr, "Found in %d probes\n", nprobes); 827 current_head_bf_list = tmp->next; 828 return (tmp->symnum_bf); 829 } 830 tmp = tmp->next; 831 } 832 833 return (-1); 834 } 835 836 static SAVED_FUNCTION_PTR saved_function_list = NULL; 837 static SAVED_FUNCTION_PTR saved_function_list_end = NULL; 838 839 static void 840 clear_function_list (void) 841 { 842 SAVED_FUNCTION_PTR tmp = saved_function_list; 843 SAVED_FUNCTION_PTR next = NULL; 844 845 while (tmp != NULL) 846 { 847 next = tmp->next; 848 xfree (tmp); 849 tmp = next; 850 } 851 852 saved_function_list = NULL; 853 } 854 #endif 855