diff options
Diffstat (limited to 'gdb/ax.h')
| -rw-r--r-- | gdb/ax.h | 285 |
1 files changed, 285 insertions, 0 deletions
diff --git a/gdb/ax.h b/gdb/ax.h new file mode 100644 index 0000000..2ee0f0b --- /dev/null +++ b/gdb/ax.h @@ -0,0 +1,285 @@ +/* Definitions for expressions designed to be executed on the agent + Copyright 1998 Free Software Foundation, Inc. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* $Id$ */ + +#ifndef AGENTEXPR_H +#define AGENTEXPR_H + +/* It's sometimes useful to be able to debug programs that you can't + really stop for more than a fraction of a second. To this end, the + user can specify a tracepoint (like a breakpoint, but you don't + stop at it), and specify a bunch of expressions to record the + values of when that tracepoint is reached. As the program runs, + GDB collects the values. At any point (possibly while values are + still being collected), the user can display the collected values. + + This is used with remote debugging; we don't really support it on + native configurations. + + This means that expressions are being evaluated by the remote agent, + which doesn't have any access to the symbol table information, and + needs to be small and simple. + + The agent_expr routines and datatypes are a bytecode language + designed to be executed by the agent. Agent expressions work in + terms of fixed-width values, operators, memory references, and + register references. You can evaluate a agent expression just given + a bunch of memory and register values to sniff at; you don't need + any symbolic information like variable names, types, etc. + + GDB translates source expressions, whose meaning depends on + symbolic information, into agent bytecode expressions, whose meaning + is independent of symbolic information. This means the agent can + evaluate them on the fly without reference to data only available + to the host GDB. */ + + +/* Agent expression data structures. */ + +/* The type of an element of the agent expression stack. + The bytecode operation indicates which element we should access; + the value itself has no typing information. GDB generates all + bytecode streams, so we don't have to worry about type errors. */ + +union agent_val { + LONGEST l; + DOUBLEST d; +}; + +/* A buffer containing a agent expression. */ +struct agent_expr { + unsigned char *buf; + int len; /* number of characters used */ + int size; /* allocated size */ + CORE_ADDR scope; +}; + + + + +/* The actual values of the various bytecode operations. + + Other independent implementations of the agent bytecode engine will + rely on the exact values of these enums, and may not be recompiled + when we change this table. The numeric values should remain fixed + whenever possible. Thus, we assign them values explicitly here (to + allow gaps to form safely), and the disassembly table in + agentexpr.h behaves like an opcode map. If you want to see them + grouped logically, see doc/agentexpr.texi. */ + +enum agent_op { + aop_float = 0x01, + aop_add = 0x02, + aop_sub = 0x03, + aop_mul = 0x04, + aop_div_signed = 0x05, + aop_div_unsigned = 0x06, + aop_rem_signed = 0x07, + aop_rem_unsigned = 0x08, + aop_lsh = 0x09, + aop_rsh_signed = 0x0a, + aop_rsh_unsigned = 0x0b, + aop_trace = 0x0c, + aop_trace_quick = 0x0d, + aop_log_not = 0x0e, + aop_bit_and = 0x0f, + aop_bit_or = 0x10, + aop_bit_xor = 0x11, + aop_bit_not = 0x12, + aop_equal = 0x13, + aop_less_signed = 0x14, + aop_less_unsigned = 0x15, + aop_ext = 0x16, + aop_ref8 = 0x17, + aop_ref16 = 0x18, + aop_ref32 = 0x19, + aop_ref64 = 0x1a, + aop_ref_float = 0x1b, + aop_ref_double = 0x1c, + aop_ref_long_double = 0x1d, + aop_l_to_d = 0x1e, + aop_d_to_l = 0x1f, + aop_if_goto = 0x20, + aop_goto = 0x21, + aop_const8 = 0x22, + aop_const16 = 0x23, + aop_const32 = 0x24, + aop_const64 = 0x25, + aop_reg = 0x26, + aop_end = 0x27, + aop_dup = 0x28, + aop_pop = 0x29, + aop_zero_ext = 0x2a, + aop_swap = 0x2b, + aop_trace16 = 0x30, + aop_last +}; + + + +/* Functions for building expressions. */ + +/* Allocate a new, empty agent expression. */ +extern struct agent_expr *new_agent_expr PARAMS ((CORE_ADDR)); + +/* Free a agent expression. */ +extern void free_agent_expr PARAMS ((struct agent_expr *)); + +/* Append a simple operator OP to EXPR. */ +extern void ax_simple PARAMS ((struct agent_expr *EXPR, enum agent_op OP)); + +/* Append the floating-point prefix, for the next bytecode. */ +#define ax_float(EXPR) (ax_simple ((EXPR), aop_float)) + +/* Append a sign-extension instruction to EXPR, to extend an N-bit value. */ +extern void ax_ext PARAMS ((struct agent_expr *EXPR, int N)); + +/* Append a zero-extension instruction to EXPR, to extend an N-bit value. */ +extern void ax_zero_ext PARAMS ((struct agent_expr *EXPR, int N)); + +/* Append a trace_quick instruction to EXPR, to record N bytes. */ +extern void ax_trace_quick PARAMS ((struct agent_expr *EXPR, int N)); + +/* Append a goto op to EXPR. OP is the actual op (must be aop_goto or + aop_if_goto). We assume we don't know the target offset yet, + because it's probably a forward branch, so we leave space in EXPR + for the target, and return the offset in EXPR of that space, so we + can backpatch it once we do know the target offset. Use ax_label + to do the backpatching. */ +extern int ax_goto PARAMS ((struct agent_expr *EXPR, enum agent_op OP)); + +/* Suppose a given call to ax_goto returns some value PATCH. When you + know the offset TARGET that goto should jump to, call + ax_label (EXPR, PATCH, TARGET) + to patch TARGET into the ax_goto instruction. */ +extern void ax_label PARAMS ((struct agent_expr *EXPR, int patch, int target)); + +/* Assemble code to push a constant on the stack. */ +extern void ax_const_l PARAMS ((struct agent_expr *EXPR, LONGEST l)); +extern void ax_const_d PARAMS ((struct agent_expr *EXPR, LONGEST d)); + +/* Assemble code to push the value of register number REG on the + stack. */ +extern void ax_reg PARAMS ((struct agent_expr *EXPR, int REG)); + + +/* Functions for printing out expressions, and otherwise debugging + things. */ + +/* Disassemble the expression EXPR, writing to F. */ +extern void ax_print PARAMS ((GDB_FILE *f, struct agent_expr *EXPR)); + +/* An entry in the opcode map. */ +struct aop_map { + + /* The name of the opcode. Null means that this entry is not a + valid opcode --- a hole in the opcode space. */ + char *name; + + /* All opcodes take no operands from the bytecode stream, or take + unsigned integers of various sizes. If this is a positive number + n, then the opcode is followed by an n-byte operand, which should + be printed as an unsigned integer. If this is zero, then the + opcode takes no operands from the bytecode stream. + + If we get more complicated opcodes in the future, don't add other + magic values of this; that's a crock. Add an `enum encoding' + field to this, or something like that. */ + int op_size; + + /* The size of the data operated upon, in bits, for bytecodes that + care about that (ref and const). Zero for all others. */ + int data_size; + + /* Number of stack elements consumed, and number produced. */ + int consumed, produced; +}; + +/* 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 */ + + /* 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 PARAMS ((struct agent_expr *ax, + struct agent_reqs *reqs)); + +#endif /* AGENTEXPR_H */ |