FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2010-04-23 Stan Shebs <stan@codesourcery.com>

Browse source 
* ax.h (struct agent_expr): Merge in agent_reqs fields, add some
	comments.
	(struct agent_reqs): Remove.
	(ax_reg_mask): Declare.
	* ax-general.c (new_agent_expr): Add gdbarch argument, set new fields.
	(free_agent_expr): Free reg_mask.
	(ax_print): Add scope and register mask info.
	(ax_reqs): Remove agent_reqs argument, use agent expression
	fields, and move part of register mask computation to...
	(ax_reg_mask): New function.
	* ax-gdb.c (gen_trace_static_fields): Call it.
	(gen_traced_pop): Ditto.
	(is_nontrivial_conversion): Add dummy gdbarch to new_agent_expr.
	(gen_trace_for_var): Pass gdbarch to new_agent_expr.
	(gen_trace_for_expr): Ditto, and clear optimized_out flag.
	(gen_eval_for_expr): Ditto, and require an rvalue.
	(agent_command): Call ax_reqs.
	(agent_eval_command): Ditto.
	* tracepoint.c (report_agent_reqs_errors): Use agent expression fields.
	(validate_action_line): Ditto.
	(collect_symbol): Ditto.
	(encode_actions_1): Ditto.
This commit is contained in:
Stan Shebs 2010-04-23 23:51:05 +00:00
parent 492928e407
commit 35c9c7ba77
5 changed files with 206 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

152
gdb/ax.h
View file

@ -51,6 +51,33 @@
to the host GDB. */
/* Different kinds of flaws an agent expression might have, as
detected by ax_reqs. */
enum agent_flaws
{
agent_flaw_none = 0, /* code is good */
/* There is an invalid instruction in the stream. */
agent_flaw_bad_instruction,
/* There is an incomplete instruction at the end of the expression. */
agent_flaw_incomplete_instruction,
/* ax_reqs was unable to prove that every jump target is to a
valid offset. Valid offsets are within the bounds of the
expression, and to a valid instruction boundary. */
agent_flaw_bad_jump,
/* ax_reqs was unable to prove to its satisfaction that, for each
jump target location, the stack will have the same height whether
that location is reached via a jump or by straight execution. */
agent_flaw_height_mismatch,
/* ax_reqs was unable to prove that every instruction following
an unconditional jump was the target of some other jump. */
agent_flaw_hole
};
/* Agent expression data structures. */
/* The type of an element of the agent expression stack.
@ -67,15 +94,57 @@ union agent_val
/* A buffer containing a agent expression. */
struct agent_expr
{
/* The bytes of the expression. */
unsigned char *buf;
int len; /* number of characters used */
int size; /* allocated size */
/* The number of bytecode in the expression. */
int len;
/* Allocated space available currently. */
int size;
/* The target architecture assumed to be in effect. */
struct gdbarch *gdbarch;
/* The address to which the expression applies. */
CORE_ADDR scope;
/* If the following is not equal to agent_flaw_none, the rest of the
information in this structure is suspect. */
enum agent_flaws flaw;
/* Number of elements left on stack at end; may be negative if expr
only consumes elements. */
int final_height;
/* Maximum and minimum stack height, relative to initial height. */
int max_height, min_height;
/* Largest `ref' or `const' opcode used, in bits. Zero means the
expression has no such instructions. */
int max_data_size;
/* Bit vector of registers needed. Register R is needed iff
reg_mask[R / 8] & (1 << (R % 8))
is non-zero. Note! You may not assume that this bitmask is long
enough to hold bits for all the registers of the machine; the
agent expression code has no idea how many registers the machine
has. However, the bitmask is reg_mask_len bytes long, so the
valid register numbers run from 0 to reg_mask_len * 8 - 1.
Also note that this mask may contain registers that are needed
for the original collection expression to work, but that are
not referenced by any bytecode. This could, for example, occur
when collecting a local variable allocated to a register; the
compiler sets the mask bit and skips generating a bytecode whose
result is going to be discarded anyway.
*/
int reg_mask_len;
unsigned char *reg_mask;
};
/* The actual values of the various bytecode operations.
Other independent implementations of the agent bytecode engine will
@ -143,7 +212,7 @@ enum agent_op
/* Functions for building expressions. */
/* Allocate a new, empty agent expression. */
extern struct agent_expr *new_agent_expr (CORE_ADDR);
extern struct agent_expr *new_agent_expr (struct gdbarch *, CORE_ADDR);
/* Free a agent expression. */
extern void free_agent_expr (struct agent_expr *);
@ -186,6 +255,9 @@ extern void ax_const_d (struct agent_expr *EXPR, LONGEST d);
stack. */
extern void ax_reg (struct agent_expr *EXPR, int REG);
/* Add the given register to the register mask of the expression. */
extern void ax_reg_mask (struct agent_expr *ax, int reg);
/* Assemble code to operate on a trace state variable. */
extern void ax_tsv (struct agent_expr *expr, enum agent_op op, int num);
@ -226,72 +298,8 @@ struct aop_map
/* Map of the bytecodes, indexed by bytecode number. */
extern struct aop_map aop_map[];
/* Different kinds of flaws an agent expression might have, as
detected by agent_reqs. */
enum agent_flaws
{
agent_flaw_none = 0, /* code is good */
/* Given an agent expression AX, analyze and update its requirements. */
/* There is an invalid instruction in the stream. */
agent_flaw_bad_instruction,
/* There is an incomplete instruction at the end of the expression. */
agent_flaw_incomplete_instruction,
/* agent_reqs was unable to prove that every jump target is to a
valid offset. Valid offsets are within the bounds of the
expression, and to a valid instruction boundary. */
agent_flaw_bad_jump,
/* agent_reqs was unable to prove to its satisfaction that, for each
jump target location, the stack will have the same height whether
that location is reached via a jump or by straight execution. */
agent_flaw_height_mismatch,
/* agent_reqs was unable to prove that every instruction following
an unconditional jump was the target of some other jump. */
agent_flaw_hole
};
/* Structure describing the requirements of a bytecode expression. */
struct agent_reqs
{
/* If the following is not equal to agent_flaw_none, the rest of the
information in this structure is suspect. */
enum agent_flaws flaw;
/* Number of elements left on stack at end; may be negative if expr
only consumes elements. */
int final_height;
/* Maximum and minimum stack height, relative to initial height. */
int max_height, min_height;
/* Largest `ref' or `const' opcode used, in bits. Zero means the
expression has no such instructions. */
int max_data_size;
/* Bit vector of registers used. Register R is used iff
reg_mask[R / 8] & (1 << (R % 8))
is non-zero. Note! You may not assume that this bitmask is long
enough to hold bits for all the registers of the machine; the
agent expression code has no idea how many registers the machine
has. However, the bitmask is reg_mask_len bytes long, so the
valid register numbers run from 0 to reg_mask_len * 8 - 1.
We're assuming eight-bit bytes. So sue me.
The caller should free reg_list when done. */
int reg_mask_len;
unsigned char *reg_mask;
};
/* Given an agent expression AX, fill in an agent_reqs structure REQS
describing it. */
extern void ax_reqs (struct agent_expr *ax, struct agent_reqs *reqs);
extern void ax_reqs (struct agent_expr *ax);
#endif /* AGENTEXPR_H */