OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [f-lang.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.