GDB (xrefs)
/tmp/gdb-7.10/gdb/ax-gdb.h
Go to the documentation of this file.
1 /* GDB-specific functions for operating on agent expressions
2  Copyright (C) 1998-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
18 
19 #ifndef AX_GDB_H
20 #define AX_GDB_H
21 
22 struct expression;
23 union exp_element;
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. */
53  {
54  /* We generated code to compute the subexpression's value.
55  Constants and arithmetic operators yield this. */
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. */
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. */
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  /* If nonzero, this is a variable which does not actually exist in
85  the program. */
87 
88  union
89  {
90  /* if kind == axs_lvalue_register, this is the register number */
91  int reg;
92  }
93  u;
94  };
95 
96 
97 /* Translating GDB expressions into agent expressions. */
98 
99 /* Given a GDB expression EXPR, return bytecode to trace its value.
100  The result will use the `trace' and `trace_quick' bytecodes to
101  record the value of all memory touched by the expression, and leave
102  no values on the stack. The caller can then use the ax_reqs
103  function to discover which registers the expression uses. */
104 extern struct agent_expr *gen_trace_for_expr (CORE_ADDR, struct expression *,
105  int);
106 
107 extern struct agent_expr *gen_trace_for_var (CORE_ADDR, struct gdbarch *,
108  struct symbol *, int);
109 
111  struct gdbarch *,
112  int);
113 
114 extern struct agent_expr *gen_eval_for_expr (CORE_ADDR, struct expression *);
115 
116 extern void gen_expr (struct expression *exp, union exp_element **pc,
117  struct agent_expr *ax, struct axs_value *value);
118 
119 extern void require_rvalue (struct agent_expr *ax, struct axs_value *value);
120 
121 struct format_piece;
122 extern struct agent_expr *gen_printf (CORE_ADDR, struct gdbarch *,
123  CORE_ADDR, LONGEST, const char *, int,
124  struct format_piece *,
125  int, struct expression **);
126 
127 #endif /* AX_GDB_H */
bfd_vma CORE_ADDR
Definition: common-types.h:41
void gen_expr(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1776
Definition: ax.h:95
axs_lvalue_kind
Definition: ax-gdb.h:52
union axs_value::@27 u
struct type * type
Definition: ax-gdb.h:82
struct agent_expr * gen_printf(CORE_ADDR, struct gdbarch *, CORE_ADDR, LONGEST, const char *, int, struct format_piece *, int, struct expression **)
Definition: ax-gdb.c:2533
char optimized_out
Definition: ax-gdb.h:86
int reg
Definition: ax-gdb.h:91
Definition: gdbtypes.h:749
struct agent_expr * gen_trace_for_var(CORE_ADDR, struct gdbarch *, struct symbol *, int)
Definition: ax-gdb.c:2395
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:764
Definition: value.c:172
struct agent_expr * gen_trace_for_expr(CORE_ADDR, struct expression *, int)
Definition: ax-gdb.c:2437
Definition: symtab.h:703
struct agent_expr * gen_eval_for_expr(CORE_ADDR, struct expression *)
Definition: ax-gdb.c:2474
enum axs_lvalue_kind kind
Definition: ax-gdb.h:77
struct agent_expr * gen_trace_for_return_address(CORE_ADDR, struct gdbarch *, int)
Definition: ax-gdb.c:2501
long long LONGEST
Definition: common-types.h:52