| 1 | /* Definitions for expressions designed to be executed on the agent |
| 2 | Copyright (C) 1998-2020 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_H |
| 20 | #define AX_H |
| 21 | |
| 22 | /* It's sometimes useful to be able to debug programs that you can't |
| 23 | really stop for more than a fraction of a second. To this end, the |
| 24 | user can specify a tracepoint (like a breakpoint, but you don't |
| 25 | stop at it), and specify a bunch of expressions to record the |
| 26 | values of when that tracepoint is reached. As the program runs, |
| 27 | GDB collects the values. At any point (possibly while values are |
| 28 | still being collected), the user can display the collected values. |
| 29 | |
| 30 | This is used with remote debugging; we don't really support it on |
| 31 | native configurations. |
| 32 | |
| 33 | This means that expressions are being evaluated by the remote agent, |
| 34 | which doesn't have any access to the symbol table information, and |
| 35 | needs to be small and simple. |
| 36 | |
| 37 | The agent_expr routines and datatypes are a bytecode language |
| 38 | designed to be executed by the agent. Agent expressions work in |
| 39 | terms of fixed-width values, operators, memory references, and |
| 40 | register references. You can evaluate a agent expression just given |
| 41 | a bunch of memory and register values to sniff at; you don't need |
| 42 | any symbolic information like variable names, types, etc. |
| 43 | |
| 44 | GDB translates source expressions, whose meaning depends on |
| 45 | symbolic information, into agent bytecode expressions, whose meaning |
| 46 | is independent of symbolic information. This means the agent can |
| 47 | evaluate them on the fly without reference to data only available |
| 48 | to the host GDB. */ |
| 49 | \f |
| 50 | |
| 51 | /* Different kinds of flaws an agent expression might have, as |
| 52 | detected by ax_reqs. */ |
| 53 | enum agent_flaws |
| 54 | { |
| 55 | agent_flaw_none = 0, /* code is good */ |
| 56 | |
| 57 | /* There is an invalid instruction in the stream. */ |
| 58 | agent_flaw_bad_instruction, |
| 59 | |
| 60 | /* There is an incomplete instruction at the end of the expression. */ |
| 61 | agent_flaw_incomplete_instruction, |
| 62 | |
| 63 | /* ax_reqs was unable to prove that every jump target is to a |
| 64 | valid offset. Valid offsets are within the bounds of the |
| 65 | expression, and to a valid instruction boundary. */ |
| 66 | agent_flaw_bad_jump, |
| 67 | |
| 68 | /* ax_reqs was unable to prove to its satisfaction that, for each |
| 69 | jump target location, the stack will have the same height whether |
| 70 | that location is reached via a jump or by straight execution. */ |
| 71 | agent_flaw_height_mismatch, |
| 72 | |
| 73 | /* ax_reqs was unable to prove that every instruction following |
| 74 | an unconditional jump was the target of some other jump. */ |
| 75 | agent_flaw_hole |
| 76 | }; |
| 77 | |
| 78 | /* Agent expression data structures. */ |
| 79 | |
| 80 | /* A buffer containing a agent expression. */ |
| 81 | struct agent_expr |
| 82 | { |
| 83 | /* Construct an empty agent expression. */ |
| 84 | explicit agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope); |
| 85 | |
| 86 | ~agent_expr (); |
| 87 | |
| 88 | /* The bytes of the expression. */ |
| 89 | unsigned char *buf; |
| 90 | |
| 91 | /* The number of bytecode in the expression. */ |
| 92 | int len; |
| 93 | |
| 94 | /* Allocated space available currently. */ |
| 95 | int size; |
| 96 | |
| 97 | /* The target architecture assumed to be in effect. */ |
| 98 | struct gdbarch *gdbarch; |
| 99 | |
| 100 | /* The address to which the expression applies. */ |
| 101 | CORE_ADDR scope; |
| 102 | |
| 103 | /* If the following is not equal to agent_flaw_none, the rest of the |
| 104 | information in this structure is suspect. */ |
| 105 | enum agent_flaws flaw; |
| 106 | |
| 107 | /* Number of elements left on stack at end; may be negative if expr |
| 108 | only consumes elements. */ |
| 109 | int final_height; |
| 110 | |
| 111 | /* Maximum and minimum stack height, relative to initial height. */ |
| 112 | int max_height, min_height; |
| 113 | |
| 114 | /* Largest `ref' or `const' opcode used, in bits. Zero means the |
| 115 | expression has no such instructions. */ |
| 116 | int max_data_size; |
| 117 | |
| 118 | /* Bit vector of registers needed. Register R is needed iff |
| 119 | |
| 120 | reg_mask[R / 8] & (1 << (R % 8)) |
| 121 | |
| 122 | is non-zero. Note! You may not assume that this bitmask is long |
| 123 | enough to hold bits for all the registers of the machine; the |
| 124 | agent expression code has no idea how many registers the machine |
| 125 | has. However, the bitmask is reg_mask_len bytes long, so the |
| 126 | valid register numbers run from 0 to reg_mask_len * 8 - 1. |
| 127 | |
| 128 | Also note that this mask may contain registers that are needed |
| 129 | for the original collection expression to work, but that are |
| 130 | not referenced by any bytecode. This could, for example, occur |
| 131 | when collecting a local variable allocated to a register; the |
| 132 | compiler sets the mask bit and skips generating a bytecode whose |
| 133 | result is going to be discarded anyway. |
| 134 | */ |
| 135 | int reg_mask_len; |
| 136 | unsigned char *reg_mask; |
| 137 | |
| 138 | /* For the data tracing facility, we need to insert `trace' bytecodes |
| 139 | before each data fetch; this records all the memory that the |
| 140 | expression touches in the course of evaluation, so that memory will |
| 141 | be available when the user later tries to evaluate the expression |
| 142 | in GDB. |
| 143 | |
| 144 | Setting the flag 'tracing' to non-zero enables the code that |
| 145 | emits the trace bytecodes at the appropriate points. */ |
| 146 | |
| 147 | unsigned int tracing : 1; |
| 148 | |
| 149 | /* This indicates that pointers to chars should get an added |
| 150 | tracenz bytecode to record nonzero bytes, up to a length that |
| 151 | is the value of trace_string. */ |
| 152 | |
| 153 | int trace_string; |
| 154 | }; |
| 155 | |
| 156 | /* An agent_expr owning pointer. */ |
| 157 | typedef std::unique_ptr<agent_expr> agent_expr_up; |
| 158 | |
| 159 | /* The actual values of the various bytecode operations. */ |
| 160 | |
| 161 | enum agent_op |
| 162 | { |
| 163 | #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \ |
| 164 | aop_ ## NAME = VALUE, |
| 165 | #include "gdbsupport/ax.def" |
| 166 | #undef DEFOP |
| 167 | aop_last |
| 168 | }; |
| 169 | \f |
| 170 | |
| 171 | |
| 172 | /* Functions for building expressions. */ |
| 173 | |
| 174 | /* Append a raw byte to EXPR. */ |
| 175 | extern void ax_raw_byte (struct agent_expr *expr, gdb_byte byte); |
| 176 | |
| 177 | /* Append a simple operator OP to EXPR. */ |
| 178 | extern void ax_simple (struct agent_expr *EXPR, enum agent_op OP); |
| 179 | |
| 180 | /* Append a pick operator to EXPR. DEPTH is the stack item to pick, |
| 181 | with 0 being top of stack. */ |
| 182 | extern void ax_pick (struct agent_expr *EXPR, int DEPTH); |
| 183 | |
| 184 | /* Append the floating-point prefix, for the next bytecode. */ |
| 185 | #define ax_float(EXPR) (ax_simple ((EXPR), aop_float)) |
| 186 | |
| 187 | /* Append a sign-extension instruction to EXPR, to extend an N-bit value. */ |
| 188 | extern void ax_ext (struct agent_expr *EXPR, int N); |
| 189 | |
| 190 | /* Append a zero-extension instruction to EXPR, to extend an N-bit value. */ |
| 191 | extern void ax_zero_ext (struct agent_expr *EXPR, int N); |
| 192 | |
| 193 | /* Append a trace_quick instruction to EXPR, to record N bytes. */ |
| 194 | extern void ax_trace_quick (struct agent_expr *EXPR, int N); |
| 195 | |
| 196 | /* Append a goto op to EXPR. OP is the actual op (must be aop_goto or |
| 197 | aop_if_goto). We assume we don't know the target offset yet, |
| 198 | because it's probably a forward branch, so we leave space in EXPR |
| 199 | for the target, and return the offset in EXPR of that space, so we |
| 200 | can backpatch it once we do know the target offset. Use ax_label |
| 201 | to do the backpatching. */ |
| 202 | extern int ax_goto (struct agent_expr *EXPR, enum agent_op OP); |
| 203 | |
| 204 | /* Suppose a given call to ax_goto returns some value PATCH. When you |
| 205 | know the offset TARGET that goto should jump to, call |
| 206 | ax_label (EXPR, PATCH, TARGET) |
| 207 | to patch TARGET into the ax_goto instruction. */ |
| 208 | extern void ax_label (struct agent_expr *EXPR, int patch, int target); |
| 209 | |
| 210 | /* Assemble code to push a constant on the stack. */ |
| 211 | extern void ax_const_l (struct agent_expr *EXPR, LONGEST l); |
| 212 | extern void ax_const_d (struct agent_expr *EXPR, LONGEST d); |
| 213 | |
| 214 | /* Assemble code to push the value of register number REG on the |
| 215 | stack. */ |
| 216 | extern void ax_reg (struct agent_expr *EXPR, int REG); |
| 217 | |
| 218 | /* Add the given register to the register mask of the expression. */ |
| 219 | extern void ax_reg_mask (struct agent_expr *ax, int reg); |
| 220 | |
| 221 | /* Assemble code to operate on a trace state variable. */ |
| 222 | extern void ax_tsv (struct agent_expr *expr, enum agent_op op, int num); |
| 223 | |
| 224 | /* Append a string to the bytecode stream. */ |
| 225 | extern void ax_string (struct agent_expr *x, const char *str, int slen); |
| 226 | \f |
| 227 | |
| 228 | /* Functions for printing out expressions, and otherwise debugging |
| 229 | things. */ |
| 230 | |
| 231 | /* Disassemble the expression EXPR, writing to F. */ |
| 232 | extern void ax_print (struct ui_file *f, struct agent_expr * EXPR); |
| 233 | |
| 234 | /* An entry in the opcode map. */ |
| 235 | struct aop_map |
| 236 | { |
| 237 | |
| 238 | /* The name of the opcode. Null means that this entry is not a |
| 239 | valid opcode --- a hole in the opcode space. */ |
| 240 | const char *name; |
| 241 | |
| 242 | /* All opcodes take no operands from the bytecode stream, or take |
| 243 | unsigned integers of various sizes. If this is a positive number |
| 244 | n, then the opcode is followed by an n-byte operand, which should |
| 245 | be printed as an unsigned integer. If this is zero, then the |
| 246 | opcode takes no operands from the bytecode stream. |
| 247 | |
| 248 | If we get more complicated opcodes in the future, don't add other |
| 249 | magic values of this; that's a crock. Add an `enum encoding' |
| 250 | field to this, or something like that. */ |
| 251 | int op_size; |
| 252 | |
| 253 | /* The size of the data operated upon, in bits, for bytecodes that |
| 254 | care about that (ref and const). Zero for all others. */ |
| 255 | int data_size; |
| 256 | |
| 257 | /* Number of stack elements consumed, and number produced. */ |
| 258 | int consumed, produced; |
| 259 | }; |
| 260 | |
| 261 | /* Map of the bytecodes, indexed by bytecode number. */ |
| 262 | extern struct aop_map aop_map[]; |
| 263 | |
| 264 | /* Given an agent expression AX, analyze and update its requirements. */ |
| 265 | |
| 266 | extern void ax_reqs (struct agent_expr *ax); |
| 267 | |
| 268 | #endif /* AX_H */ |