OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [ada-lang.h] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Ada language support definitions for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4
   2007, 2008 Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program 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 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#if !defined (ADA_LANG_H)
22
#define ADA_LANG_H 1
23
 
24
struct partial_symbol;
25
struct frame_info;
26
 
27
#include "value.h"
28
#include "gdbtypes.h"
29
#include "breakpoint.h"
30
 
31
/* Names of specific files known to be part of the runtime
32
   system and that might consider (confusing) debugging information.
33
   Each name (a basic regular expression string) is followed by a
34
   comma.  FIXME: Should be part of a configuration file. */
35
#if defined(__alpha__) && defined(__osf__)
36
#define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \
37
   "^[agis]-.*\\.ad[bs]$", \
38
   "/usr/shlib/libpthread\\.so",
39
#elif defined (__linux__)
40
#define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \
41
   "^[agis]-.*\\.ad[bs]$", \
42
   "/lib.*/libpthread\\.so[.0-9]*$", "/lib.*/libpthread\\.a$", \
43
   "/lib.*/libc\\.so[.0-9]*$", "/lib.*/libc\\.a$",
44
#endif
45
 
46
#if !defined (ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS)
47
#define ADA_KNOWN_RUNTIME_FILE_NAME_PATTERNS \
48
   "^[agis]-.*\\.ad[bs]$",
49
#endif
50
 
51
/* Names of compiler-generated auxiliary functions probably of no
52
   interest to users. Each name (a basic regular expression string)
53
   is followed by a comma. */
54
#define ADA_KNOWN_AUXILIARY_FUNCTION_NAME_PATTERNS \
55
   "___clean[.$a-zA-Z0-9_]*$",
56
 
57
/* The maximum number of frame levels searched for non-local,
58
 * non-global symbols.  This limit exists as a precaution to prevent
59
 * infinite search loops when the stack is screwed up. */
60
#define MAX_ENCLOSING_FRAME_LEVELS 7
61
 
62
/* Maximum number of steps followed in looking for the ultimate
63
   referent of a renaming.  This prevents certain infinite loops that
64
   can otherwise result. */
65
#define MAX_RENAMING_CHAIN_LENGTH 10
66
 
67
struct block;
68
 
69
/* Corresponding encoded/decoded names and opcodes for Ada user-definable
70
   operators. */
71
struct ada_opname_map
72
{
73
  const char *encoded;
74
  const char *decoded;
75
  enum exp_opcode op;
76
};
77
 
78
/* Table of Ada operators in encoded and decoded forms. */
79
/* Defined in ada-lang.c */
80
extern const struct ada_opname_map ada_opname_table[];
81
 
82
enum ada_operator
83
  {
84
    /* X IN A'RANGE(N).  N is an immediate operand, surrounded by
85
       BINOP_IN_BOUNDS before and after.  A is an array, X an index
86
       value.  Evaluates to true iff X is within range of the Nth
87
       dimension (1-based) of A.  (A multi-dimensional array
88
       type is represented as array of array of ...) */
89
    BINOP_IN_BOUNDS = OP_EXTENDED0,
90
 
91
    /* X IN L .. U.  True iff L <= X <= U.  */
92
    TERNOP_IN_RANGE,
93
 
94
    /* Ada attributes ('Foo). */
95
    OP_ATR_FIRST,
96
    OP_ATR_LAST,
97
    OP_ATR_LENGTH,
98
    OP_ATR_IMAGE,
99
    OP_ATR_MAX,
100
    OP_ATR_MIN,
101
    OP_ATR_MODULUS,
102
    OP_ATR_POS,
103
    OP_ATR_SIZE,
104
    OP_ATR_TAG,
105
    OP_ATR_VAL,
106
 
107
    /* Ada type qualification.  It is encoded as for UNOP_CAST, above,
108
       and denotes the TYPE'(EXPR) construct. */
109
    UNOP_QUAL,
110
 
111
    /* X IN TYPE.  The `TYPE' argument is immediate, with
112
       UNOP_IN_RANGE before and after it. True iff X is a member of
113
       type TYPE (typically a subrange). */
114
    UNOP_IN_RANGE,
115
 
116
    /* An aggregate.   A single immediate operand, N>0, gives
117
       the number of component specifications that follow.  The
118
       immediate operand is followed by a second OP_AGGREGATE.
119
       Next come N component specifications.  A component
120
       specification is either an OP_OTHERS (others=>...), an
121
       OP_CHOICES (for named associations), or other expression (for
122
       positional aggregates only).  Aggregates currently
123
       occur only as the right sides of assignments. */
124
    OP_AGGREGATE,
125
 
126
    /* An others clause.  Followed by a single expression. */
127
    OP_OTHERS,
128
 
129
    /* An aggregate component association.  A single immediate operand, N,
130
       gives the number of choices that follow.  This is followed by a second
131
       OP_CHOICES operator.  Next come N operands, each of which is an
132
       expression, an OP_DISCRETE_RANGE, or an OP_NAME---the latter
133
       for a simple name that must be a record component name and does
134
       not correspond to a single existing symbol.  After the N choice
135
       indicators comes an expression giving the value.
136
 
137
       In an aggregate such as (X => E1, ...), where X is a simple
138
       name, X could syntactically be either a component_selector_name
139
       or an expression used as a discrete_choice, depending on the
140
       aggregate's type context.  Since this is not known at parsing
141
       time, we don't attempt to disambiguate X if it has multiple
142
       definitions, but instead supply an OP_NAME.  If X has a single
143
       definition, we represent it with an OP_VAR_VALUE, even though
144
       it may turn out to be within a record aggregate.  Aggregate
145
       evaluation can use either OP_NAMEs or OP_VAR_VALUEs to get a
146
       record field name, and can evaluate OP_VAR_VALUE normally to
147
       get its value as an expression.  Unfortunately, we lose out in
148
       cases where X has multiple meanings and is part of an array
149
       aggregate.  I hope these are not common enough to annoy users,
150
       who can work around the problem in any case by putting
151
       parentheses around X. */
152
    OP_CHOICES,
153
 
154
    /* A positional aggregate component association.  The operator is
155
       followed by a single integer indicating the position in the
156
       aggregate (0-based), followed by a second OP_POSITIONAL.  Next
157
       follows a single expression giving the component value.  */
158
    OP_POSITIONAL,
159
 
160
    /* A range of values.  Followed by two expressions giving the
161
       upper and lower bounds of the range. */
162
    OP_DISCRETE_RANGE,
163
 
164
    /* End marker */
165
    OP_ADA_LAST
166
  };
167
 
168
/* A triple, (symbol, block, symtab), representing one instance of a
169
 * symbol-lookup operation. */
170
struct ada_symbol_info {
171
  struct symbol* sym;
172
  struct block* block;
173
  struct symtab* symtab;
174
};
175
 
176
/* Denotes a type of renaming symbol (see ada_parse_renaming).  */
177
enum ada_renaming_category
178
  {
179
    /* Indicates a symbol that does not encode a renaming.  */
180
    ADA_NOT_RENAMING,
181
 
182
    /* For symbols declared
183
         Foo : TYPE renamed OBJECT;  */
184
    ADA_OBJECT_RENAMING,
185
 
186
    /* For symbols declared
187
         Foo : exception renames EXCEPTION;  */
188
    ADA_EXCEPTION_RENAMING,
189
    /* For packages declared
190
          package Foo renames PACKAGE; */
191
    ADA_PACKAGE_RENAMING,
192
    /* For subprograms declared
193
          SUBPROGRAM_SPEC renames SUBPROGRAM;
194
       (Currently not used).  */
195
    ADA_SUBPROGRAM_RENAMING
196
  };
197
 
198
/* Ada task structures.  */
199
 
200
/* Ada task control block, as defined in the GNAT runt-time library.  */
201
 
202
struct task_control_block
203
{
204
  char state;
205
  CORE_ADDR parent;
206
  int priority;
207
  char image [32];
208
  int image_len;    /* This field is not always present in the ATCB.  */
209
  CORE_ADDR call;
210
  CORE_ADDR thread;
211
  CORE_ADDR lwp;    /* This field is not always present in the ATCB.  */
212
 
213
  /* If the task is waiting on a task entry, this field contains the
214
   task_id of the other task.  */
215
  CORE_ADDR called_task;
216
};
217
 
218
struct task_ptid
219
{
220
  int pid;                      /* The Process id */
221
  long lwp;                     /* The Light Weight Process id */
222
  long tid;                     /* The Thread id */
223
};
224
typedef struct task_ptid task_ptid_t;
225
 
226
struct task_entry
227
{
228
  CORE_ADDR task_id;
229
  struct task_control_block atcb;
230
  int task_num;
231
  int known_tasks_index;
232
  struct task_entry *next_task;
233
  task_ptid_t task_ptid;
234
  int stack_per;
235
};
236
 
237
/* task entry list.  */
238
extern struct task_entry *task_list;
239
 
240
 
241
/* Assuming V points to an array of S objects,  make sure that it contains at
242
   least M objects, updating V and S as necessary. */
243
 
244
#define GROW_VECT(v, s, m)                                              \
245
   if ((s) < (m)) (v) = grow_vect (v, &(s), m, sizeof *(v));
246
 
247
extern void *grow_vect (void *, size_t *, size_t, int);
248
 
249
extern int ada_get_field_index (const struct type *type,
250
                                const char *field_name,
251
                                int maybe_missing);
252
 
253
extern int ada_parse (void);    /* Defined in ada-exp.y */
254
 
255
extern void ada_error (char *); /* Defined in ada-exp.y */
256
 
257
                        /* Defined in ada-typeprint.c */
258
extern void ada_print_type (struct type *, char *, struct ui_file *, int,
259
                            int);
260
 
261
extern int ada_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
262
                          struct ui_file *, int, int, int,
263
                          enum val_prettyprint);
264
 
265
extern int ada_value_print (struct value *, struct ui_file *, int,
266
                            enum val_prettyprint);
267
 
268
                                /* Defined in ada-lang.c */
269
 
270
extern struct value *value_from_contents_and_address (struct type *,
271
                                                      const gdb_byte *,
272
                                                      CORE_ADDR);
273
 
274
extern void ada_emit_char (int, struct ui_file *, int, int);
275
 
276
extern void ada_printchar (int, struct ui_file *);
277
 
278
extern void ada_printstr (struct ui_file *, const gdb_byte *,
279
                          unsigned int, int, int);
280
 
281
struct value *ada_convert_actual (struct value *actual,
282
                                  struct type *formal_type0,
283
                                  CORE_ADDR *sp);
284
 
285
extern struct value *ada_value_subscript (struct value *, int,
286
                                          struct value **);
287
 
288
extern struct type *ada_array_element_type (struct type *, int);
289
 
290
extern int ada_array_arity (struct type *);
291
 
292
struct type *ada_type_of_array (struct value *, int);
293
 
294
extern struct value *ada_coerce_to_simple_array_ptr (struct value *);
295
 
296
extern int ada_is_simple_array_type (struct type *);
297
 
298
extern int ada_is_array_descriptor_type (struct type *);
299
 
300
extern int ada_is_bogus_array_descriptor (struct type *);
301
 
302
extern struct type *ada_index_type (struct type *, int);
303
 
304
extern struct value *ada_array_bound (struct value *, int, int);
305
 
306
extern char *ada_decode_symbol (const struct general_symbol_info*);
307
 
308
extern const char *ada_decode (const char*);
309
 
310
extern enum language ada_update_initial_language (enum language,
311
                                                  struct partial_symtab*);
312
 
313
extern void clear_ada_sym_cache (void);
314
 
315
extern int ada_lookup_symbol_list (const char *, const struct block *,
316
                                   domain_enum, struct ada_symbol_info**);
317
 
318
extern char *ada_fold_name (const char *);
319
 
320
extern struct symbol *ada_lookup_symbol (const char *, const struct block *,
321
                                         domain_enum, int *,
322
                                         struct symtab **);
323
 
324
extern struct symbol *
325
ada_lookup_encoded_symbol (const char *, const struct block *,
326
                           domain_enum namespace,
327
                           struct block **, struct symtab **);
328
 
329
extern struct minimal_symbol *ada_lookup_simple_minsym (const char *);
330
 
331
extern void ada_fill_in_ada_prototype (struct symbol *);
332
 
333
extern int user_select_syms (struct ada_symbol_info *, int, int);
334
 
335
extern int get_selections (int *, int, int, int, char *);
336
 
337
extern char *ada_start_decode_line_1 (char *);
338
 
339
extern struct symtabs_and_lines ada_finish_decode_line_1 (char **,
340
                                                          struct symtab *,
341
                                                          int, char ***);
342
 
343
extern struct symtabs_and_lines ada_sals_for_line (const char*, int,
344
                                                   int, char***, int);
345
 
346
extern int ada_scan_number (const char *, int, LONGEST *, int *);
347
 
348
extern struct type *ada_parent_type (struct type *);
349
 
350
extern int ada_is_ignored_field (struct type *, int);
351
 
352
extern int ada_is_packed_array_type (struct type *);
353
 
354
extern struct value *ada_value_primitive_packed_val (struct value *,
355
                                                     const gdb_byte *,
356
                                                     long, int, int,
357
                                                     struct type *);
358
 
359
extern struct type *ada_coerce_to_simple_array_type (struct type *);
360
 
361
extern int ada_is_character_type (struct type *);
362
 
363
extern int ada_is_string_type (struct type *);
364
 
365
extern int ada_is_tagged_type (struct type *, int);
366
 
367
extern int ada_is_tag_type (struct type *);
368
 
369
extern struct type *ada_tag_type (struct value *);
370
 
371
extern struct value *ada_value_tag (struct value *);
372
 
373
extern const char *ada_tag_name (struct value *);
374
 
375
extern int ada_is_parent_field (struct type *, int);
376
 
377
extern int ada_is_wrapper_field (struct type *, int);
378
 
379
extern int ada_is_variant_part (struct type *, int);
380
 
381
extern struct type *ada_variant_discrim_type (struct type *, struct type *);
382
 
383
extern int ada_is_others_clause (struct type *, int);
384
 
385
extern int ada_in_variant (LONGEST, struct type *, int);
386
 
387
extern char *ada_variant_discrim_name (struct type *);
388
 
389
extern struct value *ada_value_struct_elt (struct value *, char *, int);
390
 
391
extern int ada_is_aligner_type (struct type *);
392
 
393
extern struct type *ada_aligned_type (struct type *);
394
 
395
extern const gdb_byte *ada_aligned_value_addr (struct type *,
396
                                               const gdb_byte *);
397
 
398
extern const char *ada_attribute_name (enum exp_opcode);
399
 
400
extern int ada_is_fixed_point_type (struct type *);
401
 
402
extern int ada_is_system_address_type (struct type *);
403
 
404
extern DOUBLEST ada_delta (struct type *);
405
 
406
extern DOUBLEST ada_fixed_to_float (struct type *, LONGEST);
407
 
408
extern LONGEST ada_float_to_fixed (struct type *, DOUBLEST);
409
 
410
extern int ada_is_vax_floating_type (struct type *);
411
 
412
extern int ada_vax_float_type_suffix (struct type *);
413
 
414
extern struct value *ada_vax_float_print_function (struct type *);
415
 
416
extern struct type *ada_system_address_type (void);
417
 
418
extern int ada_which_variant_applies (struct type *, struct type *,
419
                                      const gdb_byte *);
420
 
421
extern struct type *ada_to_fixed_type (struct type *, const gdb_byte *,
422
                                       CORE_ADDR, struct value *,
423
                                       int check_tag);
424
 
425
extern struct type *ada_template_to_fixed_record_type_1 (struct type *type,
426
                                                         const gdb_byte *valaddr,
427
                                                         CORE_ADDR address,
428
                                                         struct value *dval0,
429
                                                         int keep_dynamic_fields);
430
 
431
extern int ada_name_prefix_len (const char *);
432
 
433
extern char *ada_type_name (struct type *);
434
 
435
extern struct type *ada_find_parallel_type (struct type *,
436
                                            const char *suffix);
437
 
438
extern LONGEST get_int_var_value (char *, int *);
439
 
440
extern struct symbol *ada_find_any_symbol (const char *name);
441
 
442
extern struct type *ada_find_any_type (const char *name);
443
 
444
extern struct symbol *ada_find_renaming_symbol (const char *name,
445
                                                struct block *block);
446
 
447
extern int ada_prefer_type (struct type *, struct type *);
448
 
449
extern struct type *ada_get_base_type (struct type *);
450
 
451
extern struct type *ada_check_typedef (struct type *);
452
 
453
extern char *ada_encode (const char *);
454
 
455
extern const char *ada_enum_name (const char *);
456
 
457
extern int ada_is_modular_type (struct type *);
458
 
459
extern ULONGEST ada_modulus (struct type *);
460
 
461
extern struct value *ada_value_ind (struct value *);
462
 
463
extern void ada_print_scalar (struct type *, LONGEST, struct ui_file *);
464
 
465
extern int ada_is_range_type_name (const char *);
466
 
467
extern enum ada_renaming_category ada_parse_renaming (struct symbol *,
468
                                                      const char **,
469
                                                      int *, const char **);
470
 
471
extern char *ada_breakpoint_rewrite (char *, int *);
472
 
473
extern char *ada_main_name (void);
474
 
475
/* Tasking-related: ada-tasks.c */
476
 
477
extern int valid_task_id (int);
478
 
479
extern void init_task_list (void);
480
 
481
extern int ada_is_exception_breakpoint (bpstat bs);
482
 
483
extern void ada_adjust_exception_stop (bpstat bs);
484
 
485
extern void ada_print_exception_stop (bpstat bs);
486
 
487
extern int ada_get_current_task (ptid_t);
488
 
489
extern int breakpoint_ada_task_match (CORE_ADDR, ptid_t);
490
 
491
extern int ada_print_exception_breakpoint_nontask (struct breakpoint *);
492
 
493
extern void ada_print_exception_breakpoint_task (struct breakpoint *);
494
 
495
extern void ada_reset_thread_registers (void);
496
 
497
extern int ada_build_task_list (void);
498
 
499
extern int ada_exception_catchpoint_p (struct breakpoint *b);
500
 
501
extern struct symtab_and_line
502
  ada_decode_exception_location (char *args, char **addr_string,
503
                                 char **exp_string, char **cond_string,
504
                                 struct expression **cond,
505
                                 struct breakpoint_ops **ops);
506
 
507
extern struct symtab_and_line
508
  ada_decode_assert_location (char *args, char **addr_string,
509
                              struct breakpoint_ops **ops);
510
 
511
 
512
#endif

powered by: WebSVN 2.1.0

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