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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [ax-gdb.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* GDB-specific functions for operating on agent expressions
2
   Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#ifndef AX_GDB_H
22
#define AX_GDB_H
23
 
24
 
25
/* Types and enums */
26
 
27
/* GDB stores expressions in the form of a flattened tree (struct
28
   expression), so we just walk that tree and generate agent bytecodes
29
   as we go along.
30
 
31
   GDB's normal evaluation uses struct value, which contains the
32
   expression's value as well as its address or the register it came
33
   from.  The `+' operator uses the value, whereas the unary `&'
34
   operator will use the address portion.  The `=' operator will use
35
   the address or register number of its left hand side.
36
 
37
   The issues are different when generating agent bytecode.  Given a
38
   variable reference expression, we should not necessarily generate
39
   code to fetch its value, because the next operator may be `=' or
40
   unary `&'.  Instead, when we recurse on a subexpression, we
41
   indicate whether we want that expression to produce an lvalue or an
42
   rvalue.  If we requested an lvalue, then the recursive call tells
43
   us whether it generated code to compute an address on the stack, or
44
   whether the lvalue lives in a register.
45
 
46
   The `axs' prefix here means `agent expression, static', because
47
   this is all static analysis of the expression, i.e. analysis which
48
   doesn't depend on the contents of memory and registers.  */
49
 
50
 
51
/* Different kinds of agent expression static values.  */
52
enum axs_lvalue_kind
53
  {
54
    /* We generated code to compute the subexpression's value.
55
       Constants and arithmetic operators yield this.  */
56
    axs_rvalue,
57
 
58
    /* We generated code to yield the subexpression's value's address on
59
       the top of the stack.  If the caller needs an rvalue, it should
60
       call require_rvalue to produce the rvalue from this address.  */
61
    axs_lvalue_memory,
62
 
63
    /* We didn't generate any code, and the stack is undisturbed,
64
       because the subexpression's value lives in a register; u.reg is
65
       the register number.  If the caller needs an rvalue, it should
66
       call require_rvalue to produce the rvalue from this register
67
       number.  */
68
    axs_lvalue_register
69
  };
70
 
71
/* Structure describing what we got from a subexpression.  Think of
72
   this as parallel to value.h's enum lval_type, except that we're
73
   describing a value which will exist when the expression is
74
   evaluated in the future, not a value we have in our hand.  */
75
struct axs_value
76
  {
77
    enum axs_lvalue_kind kind;  /* see above */
78
 
79
    /* The type of the subexpression.  Even if lvalue == axs_lvalue_memory,
80
       this is the type of the value itself; the value on the stack is a
81
       "pointer to" an object of this type. */
82
    struct type *type;
83
 
84
    union
85
      {
86
        /* if kind == axs_lvalue_register, this is the register number */
87
        int reg;
88
      }
89
    u;
90
  };
91
 
92
 
93
/* Translating GDB expressions into agent expressions.  */
94
 
95
/* Given a GDB expression EXPR, translate it into the agent bytecode,
96
   and return it.  FLAGS are from enum expr_to_agent_flags.  */
97
extern struct agent_expr *expr_to_agent (struct expression *EXPR,
98
                                         struct axs_value *VALUE);
99
 
100
/* Given a GDB expression EXPR denoting an lvalue in memory, produce a
101
   string of agent bytecode which will leave its address and size on
102
   the top of stack.  Return the agent expression.  */
103
extern struct agent_expr *expr_to_address_and_size (struct expression *EXPR);
104
 
105
/* Given a GDB expression EXPR, return bytecode to trace its value.
106
   The result will use the `trace' and `trace_quick' bytecodes to
107
   record the value of all memory touched by the expression, and leave
108
   no values on the stack.  The caller can then use the ax_reqs
109
   function to discover which registers the expression uses.  */
110
extern struct agent_expr *gen_trace_for_expr (CORE_ADDR, struct expression *);
111
 
112
#endif /* AX_GDB_H */

powered by: WebSVN 2.1.0

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