]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/ax-gdb.h
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / ax-gdb.h
CommitLineData
c906108c 1/* GDB-specific functions for operating on agent expressions
6aba47ca 2 Copyright (C) 1998, 1999, 2000, 2007 Free Software Foundation, Inc.
c906108c 3
c5aa993b 4 This file is part of GDB.
c906108c 5
c5aa993b
JM
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.
c906108c 10
c5aa993b
JM
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.
c906108c 15
c5aa993b
JM
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
197e01b6
EZ
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
c906108c 20
c906108c
SS
21#ifndef AX_GDB_H
22#define AX_GDB_H
da3331ec
AC
23
24struct expression;
c5aa993b 25
c906108c
SS
26/* Types and enums */
27
28/* GDB stores expressions in the form of a flattened tree (struct
29 expression), so we just walk that tree and generate agent bytecodes
30 as we go along.
31
32 GDB's normal evaluation uses struct value, which contains the
33 expression's value as well as its address or the register it came
34 from. The `+' operator uses the value, whereas the unary `&'
35 operator will use the address portion. The `=' operator will use
36 the address or register number of its left hand side.
37
38 The issues are different when generating agent bytecode. Given a
39 variable reference expression, we should not necessarily generate
40 code to fetch its value, because the next operator may be `=' or
41 unary `&'. Instead, when we recurse on a subexpression, we
42 indicate whether we want that expression to produce an lvalue or an
43 rvalue. If we requested an lvalue, then the recursive call tells
44 us whether it generated code to compute an address on the stack, or
45 whether the lvalue lives in a register.
46
47 The `axs' prefix here means `agent expression, static', because
48 this is all static analysis of the expression, i.e. analysis which
49 doesn't depend on the contents of memory and registers. */
50
51
52/* Different kinds of agent expression static values. */
c5aa993b
JM
53enum axs_lvalue_kind
54 {
55 /* We generated code to compute the subexpression's value.
56 Constants and arithmetic operators yield this. */
57 axs_rvalue,
58
59 /* We generated code to yield the subexpression's value's address on
60 the top of the stack. If the caller needs an rvalue, it should
61 call require_rvalue to produce the rvalue from this address. */
62 axs_lvalue_memory,
63
64 /* We didn't generate any code, and the stack is undisturbed,
65 because the subexpression's value lives in a register; u.reg is
66 the register number. If the caller needs an rvalue, it should
67 call require_rvalue to produce the rvalue from this register
68 number. */
69 axs_lvalue_register
70 };
c906108c
SS
71
72/* Structure describing what we got from a subexpression. Think of
73 this as parallel to value.h's enum lval_type, except that we're
74 describing a value which will exist when the expression is
75 evaluated in the future, not a value we have in our hand. */
c5aa993b
JM
76struct axs_value
77 {
78 enum axs_lvalue_kind kind; /* see above */
79
80 /* The type of the subexpression. Even if lvalue == axs_lvalue_memory,
81 this is the type of the value itself; the value on the stack is a
82 "pointer to" an object of this type. */
83 struct type *type;
84
85 union
86 {
87 /* if kind == axs_lvalue_register, this is the register number */
88 int reg;
89 }
90 u;
91 };
c906108c 92\f
c5aa993b 93
c906108c
SS
94/* Translating GDB expressions into agent expressions. */
95
96/* Given a GDB expression EXPR, translate it into the agent bytecode,
97 and return it. FLAGS are from enum expr_to_agent_flags. */
a14ed312
KB
98extern struct agent_expr *expr_to_agent (struct expression *EXPR,
99 struct axs_value *VALUE);
c906108c
SS
100
101/* Given a GDB expression EXPR denoting an lvalue in memory, produce a
102 string of agent bytecode which will leave its address and size on
103 the top of stack. Return the agent expression. */
a14ed312 104extern struct agent_expr *expr_to_address_and_size (struct expression *EXPR);
c906108c
SS
105
106/* Given a GDB expression EXPR, return bytecode to trace its value.
107 The result will use the `trace' and `trace_quick' bytecodes to
108 record the value of all memory touched by the expression, and leave
109 no values on the stack. The caller can then use the ax_reqs
110 function to discover which registers the expression uses. */
a14ed312 111extern struct agent_expr *gen_trace_for_expr (CORE_ADDR, struct expression *);
c906108c
SS
112
113#endif /* AX_GDB_H */