1 /* Functions for manipulating expressions designed to be executed on the agent
2 Copyright (C) 1998, 1999, 2000, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* Despite what the above comment says about this file being part of
21 GDB, we would like to keep these functions free of GDB
22 dependencies, since we want to be able to use them in contexts
23 outside of GDB (test suites, the stub, etc.) */
29 #include "gdb_string.h"
31 #include "user-regs.h"
33 static void grow_expr (struct agent_expr *x, int n);
35 static void append_const (struct agent_expr *x, LONGEST val, int n);
37 static LONGEST read_const (struct agent_expr *x, int o, int n);
39 static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
41 /* Functions for building expressions. */
43 /* Allocate a new, empty agent expression. */
45 new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
47 struct agent_expr *x = xmalloc (sizeof (*x));
50 x->size = 1; /* Change this to a larger value once
51 reallocation code is tested. */
52 x->buf = xmalloc (x->size);
57 /* Bit vector for registers used. */
59 x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0]));
60 memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0]));
65 /* Free a agent expression. */
67 free_agent_expr (struct agent_expr *x)
75 do_free_agent_expr_cleanup (void *x)
81 make_cleanup_free_agent_expr (struct agent_expr *x)
83 return make_cleanup (do_free_agent_expr_cleanup, x);
87 /* Make sure that X has room for at least N more bytes. This doesn't
88 affect the length, just the allocated size. */
90 grow_expr (struct agent_expr *x, int n)
92 if (x->len + n > x->size)
95 if (x->size < x->len + n)
96 x->size = x->len + n + 10;
97 x->buf = xrealloc (x->buf, x->size);
102 /* Append the low N bytes of VAL as an N-byte integer to the
103 expression X, in big-endian order. */
105 append_const (struct agent_expr *x, LONGEST val, int n)
110 for (i = n - 1; i >= 0; i--)
112 x->buf[x->len + i] = val & 0xff;
119 /* Extract an N-byte big-endian unsigned integer from expression X at
122 read_const (struct agent_expr *x, int o, int n)
127 /* Make sure we're not reading off the end of the expression. */
129 error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
131 for (i = 0; i < n; i++)
132 accum = (accum << 8) | x->buf[o + i];
138 /* Append a simple operator OP to EXPR. */
140 ax_simple (struct agent_expr *x, enum agent_op op)
143 x->buf[x->len++] = op;
147 /* Append a sign-extension or zero-extension instruction to EXPR, to
148 extend an N-bit value. */
150 generic_ext (struct agent_expr *x, enum agent_op op, int n)
152 /* N must fit in a byte. */
153 if (n < 0 || n > 255)
154 error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
155 /* That had better be enough range. */
156 if (sizeof (LONGEST) * 8 > 255)
157 error (_("GDB bug: ax-general.c (generic_ext): opcode has inadequate range"));
160 x->buf[x->len++] = op;
161 x->buf[x->len++] = n;
165 /* Append a sign-extension instruction to EXPR, to extend an N-bit value. */
167 ax_ext (struct agent_expr *x, int n)
169 generic_ext (x, aop_ext, n);
173 /* Append a zero-extension instruction to EXPR, to extend an N-bit value. */
175 ax_zero_ext (struct agent_expr *x, int n)
177 generic_ext (x, aop_zero_ext, n);
181 /* Append a trace_quick instruction to EXPR, to record N bytes. */
183 ax_trace_quick (struct agent_expr *x, int n)
185 /* N must fit in a byte. */
186 if (n < 0 || n > 255)
187 error (_("GDB bug: ax-general.c (ax_trace_quick): size out of range for trace_quick"));
190 x->buf[x->len++] = aop_trace_quick;
191 x->buf[x->len++] = n;
195 /* Append a goto op to EXPR. OP is the actual op (must be aop_goto or
196 aop_if_goto). We assume we don't know the target offset yet,
197 because it's probably a forward branch, so we leave space in EXPR
198 for the target, and return the offset in EXPR of that space, so we
199 can backpatch it once we do know the target offset. Use ax_label
200 to do the backpatching. */
202 ax_goto (struct agent_expr *x, enum agent_op op)
205 x->buf[x->len + 0] = op;
206 x->buf[x->len + 1] = 0xff;
207 x->buf[x->len + 2] = 0xff;
212 /* Suppose a given call to ax_goto returns some value PATCH. When you
213 know the offset TARGET that goto should jump to, call
214 ax_label (EXPR, PATCH, TARGET)
215 to patch TARGET into the ax_goto instruction. */
217 ax_label (struct agent_expr *x, int patch, int target)
219 /* Make sure the value is in range. Don't accept 0xffff as an
220 offset; that's our magic sentinel value for unpatched branches. */
221 if (target < 0 || target >= 0xffff)
222 error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
224 x->buf[patch] = (target >> 8) & 0xff;
225 x->buf[patch + 1] = target & 0xff;
229 /* Assemble code to push a constant on the stack. */
231 ax_const_l (struct agent_expr *x, LONGEST l)
233 static enum agent_op ops[]
235 {aop_const8, aop_const16, aop_const32, aop_const64};
239 /* How big is the number? 'op' keeps track of which opcode to use.
240 Notice that we don't really care whether the original number was
241 signed or unsigned; we always reproduce the value exactly, and
242 use the shortest representation. */
243 for (op = 0, size = 8; size < 64; size *= 2, op++)
245 LONGEST lim = ((LONGEST) 1) << (size - 1);
247 if (-lim <= l && l <= lim - 1)
251 /* Emit the right opcode... */
252 ax_simple (x, ops[op]);
254 /* Emit the low SIZE bytes as an unsigned number. We know that
255 sign-extending this will yield l. */
256 append_const (x, l, size / 8);
258 /* Now, if it was negative, and not full-sized, sign-extend it. */
259 if (l < 0 && size < 64)
265 ax_const_d (struct agent_expr *x, LONGEST d)
267 /* FIXME: floating-point support not present yet. */
268 error (_("GDB bug: ax-general.c (ax_const_d): floating point not supported yet"));
272 /* Assemble code to push the value of register number REG on the
275 ax_reg (struct agent_expr *x, int reg)
277 if (reg >= gdbarch_num_regs (x->gdbarch))
279 /* This is a pseudo-register. */
280 if (!gdbarch_ax_pseudo_register_push_stack_p (x->gdbarch))
281 error (_("'%s' is a pseudo-register; "
282 "GDB cannot yet trace its contents."),
283 user_reg_map_regnum_to_name (x->gdbarch, reg));
284 if (gdbarch_ax_pseudo_register_push_stack (x->gdbarch, x, reg))
285 error (_("Trace '%s' failed."),
286 user_reg_map_regnum_to_name (x->gdbarch, reg));
290 /* Make sure the register number is in range. */
291 if (reg < 0 || reg > 0xffff)
292 error (_("GDB bug: ax-general.c (ax_reg): register number out of range"));
294 x->buf[x->len] = aop_reg;
295 x->buf[x->len + 1] = (reg >> 8) & 0xff;
296 x->buf[x->len + 2] = (reg) & 0xff;
301 /* Assemble code to operate on a trace state variable. */
304 ax_tsv (struct agent_expr *x, enum agent_op op, int num)
306 /* Make sure the tsv number is in range. */
307 if (num < 0 || num > 0xffff)
308 internal_error (__FILE__, __LINE__, _("ax-general.c (ax_tsv): variable number is %d, out of range"), num);
312 x->buf[x->len + 1] = (num >> 8) & 0xff;
313 x->buf[x->len + 2] = (num) & 0xff;
319 /* Functions for disassembling agent expressions, and otherwise
320 debugging the expression compiler. */
322 struct aop_map aop_map[] =
325 {"float", 0, 0, 0, 0}, /* 0x01 */
326 {"add", 0, 0, 2, 1}, /* 0x02 */
327 {"sub", 0, 0, 2, 1}, /* 0x03 */
328 {"mul", 0, 0, 2, 1}, /* 0x04 */
329 {"div_signed", 0, 0, 2, 1}, /* 0x05 */
330 {"div_unsigned", 0, 0, 2, 1}, /* 0x06 */
331 {"rem_signed", 0, 0, 2, 1}, /* 0x07 */
332 {"rem_unsigned", 0, 0, 2, 1}, /* 0x08 */
333 {"lsh", 0, 0, 2, 1}, /* 0x09 */
334 {"rsh_signed", 0, 0, 2, 1}, /* 0x0a */
335 {"rsh_unsigned", 0, 0, 2, 1}, /* 0x0b */
336 {"trace", 0, 0, 2, 0}, /* 0x0c */
337 {"trace_quick", 1, 0, 1, 1}, /* 0x0d */
338 {"log_not", 0, 0, 1, 1}, /* 0x0e */
339 {"bit_and", 0, 0, 2, 1}, /* 0x0f */
340 {"bit_or", 0, 0, 2, 1}, /* 0x10 */
341 {"bit_xor", 0, 0, 2, 1}, /* 0x11 */
342 {"bit_not", 0, 0, 1, 1}, /* 0x12 */
343 {"equal", 0, 0, 2, 1}, /* 0x13 */
344 {"less_signed", 0, 0, 2, 1}, /* 0x14 */
345 {"less_unsigned", 0, 0, 2, 1}, /* 0x15 */
346 {"ext", 1, 0, 1, 1}, /* 0x16 */
347 {"ref8", 0, 8, 1, 1}, /* 0x17 */
348 {"ref16", 0, 16, 1, 1}, /* 0x18 */
349 {"ref32", 0, 32, 1, 1}, /* 0x19 */
350 {"ref64", 0, 64, 1, 1}, /* 0x1a */
351 {"ref_float", 0, 0, 1, 1}, /* 0x1b */
352 {"ref_double", 0, 0, 1, 1}, /* 0x1c */
353 {"ref_long_double", 0, 0, 1, 1}, /* 0x1d */
354 {"l_to_d", 0, 0, 1, 1}, /* 0x1e */
355 {"d_to_l", 0, 0, 1, 1}, /* 0x1f */
356 {"if_goto", 2, 0, 1, 0}, /* 0x20 */
357 {"goto", 2, 0, 0, 0}, /* 0x21 */
358 {"const8", 1, 8, 0, 1}, /* 0x22 */
359 {"const16", 2, 16, 0, 1}, /* 0x23 */
360 {"const32", 4, 32, 0, 1}, /* 0x24 */
361 {"const64", 8, 64, 0, 1}, /* 0x25 */
362 {"reg", 2, 0, 0, 1}, /* 0x26 */
363 {"end", 0, 0, 0, 0}, /* 0x27 */
364 {"dup", 0, 0, 1, 2}, /* 0x28 */
365 {"pop", 0, 0, 1, 0}, /* 0x29 */
366 {"zero_ext", 1, 0, 1, 1}, /* 0x2a */
367 {"swap", 0, 0, 2, 2}, /* 0x2b */
368 {"getv", 2, 0, 0, 1}, /* 0x2c */
369 {"setv", 2, 0, 0, 1}, /* 0x2d */
370 {"tracev", 2, 0, 0, 1}, /* 0x2e */
371 {0, 0, 0, 0, 0}, /* 0x2f */
372 {"trace16", 2, 0, 1, 1}, /* 0x30 */
376 /* Disassemble the expression EXPR, writing to F. */
378 ax_print (struct ui_file *f, struct agent_expr *x)
383 fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
384 fprintf_filtered (f, _("Reg mask:"));
385 for (i = 0; i < x->reg_mask_len; ++i)
386 fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
387 fprintf_filtered (f, _("\n"));
389 /* Check the size of the name array against the number of entries in
390 the enum, to catch additions that people didn't sync. */
391 if ((sizeof (aop_map) / sizeof (aop_map[0]))
393 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
395 for (i = 0; i < x->len;)
397 enum agent_op op = x->buf[i];
399 if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
400 || !aop_map[op].name)
402 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op);
406 if (i + 1 + aop_map[op].op_size > x->len)
408 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"),
409 i, aop_map[op].name);
413 fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
414 if (aop_map[op].op_size > 0)
416 fputs_filtered (" ", f);
418 print_longest (f, 'd', 0,
419 read_const (x, i + 1, aop_map[op].op_size));
421 fprintf_filtered (f, "\n");
422 i += 1 + aop_map[op].op_size;
424 is_float = (op == aop_float);
428 /* Add register REG to the register mask for expression AX. */
430 ax_reg_mask (struct agent_expr *ax, int reg)
432 if (reg >= gdbarch_num_regs (ax->gdbarch))
434 /* This is a pseudo-register. */
435 if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
436 error (_("'%s' is a pseudo-register; "
437 "GDB cannot yet trace its contents."),
438 user_reg_map_regnum_to_name (ax->gdbarch, reg));
439 if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
440 error (_("Trace '%s' failed."),
441 user_reg_map_regnum_to_name (ax->gdbarch, reg));
447 /* Grow the bit mask if necessary. */
448 if (byte >= ax->reg_mask_len)
450 /* It's not appropriate to double here. This isn't a
452 int new_len = byte + 1;
453 unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
455 * sizeof (ax->reg_mask[0]));
456 memset (new_reg_mask + ax->reg_mask_len, 0,
457 (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
458 ax->reg_mask_len = new_len;
459 ax->reg_mask = new_reg_mask;
462 ax->reg_mask[byte] |= 1 << (reg % 8);
466 /* Given an agent expression AX, fill in requirements and other descriptive
469 ax_reqs (struct agent_expr *ax)
474 /* Jump target table. targets[i] is non-zero iff we have found a
476 char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
478 /* Instruction boundary table. boundary[i] is non-zero iff our scan
479 has reached an instruction starting at offset i. */
480 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
482 /* Stack height record. If either targets[i] or boundary[i] is
483 non-zero, heights[i] is the height the stack should have before
484 executing the bytecode at that point. */
485 int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
487 /* Pointer to a description of the present op. */
490 memset (targets, 0, ax->len * sizeof (targets[0]));
491 memset (boundary, 0, ax->len * sizeof (boundary[0]));
493 ax->max_height = ax->min_height = height = 0;
494 ax->flaw = agent_flaw_none;
495 ax->max_data_size = 0;
497 for (i = 0; i < ax->len; i += 1 + op->op_size)
499 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
501 ax->flaw = agent_flaw_bad_instruction;
505 op = &aop_map[ax->buf[i]];
509 ax->flaw = agent_flaw_bad_instruction;
513 if (i + 1 + op->op_size > ax->len)
515 ax->flaw = agent_flaw_incomplete_instruction;
519 /* If this instruction is a forward jump target, does the
520 current stack height match the stack height at the jump
522 if (targets[i] && (heights[i] != height))
524 ax->flaw = agent_flaw_height_mismatch;
531 height -= op->consumed;
532 if (height < ax->min_height)
533 ax->min_height = height;
534 height += op->produced;
535 if (height > ax->max_height)
536 ax->max_height = height;
538 if (op->data_size > ax->max_data_size)
539 ax->max_data_size = op->data_size;
541 /* For jump instructions, check that the target is a valid
542 offset. If it is, record the fact that that location is a
543 jump target, and record the height we expect there. */
544 if (aop_goto == op - aop_map
545 || aop_if_goto == op - aop_map)
547 int target = read_const (ax, i + 1, 2);
548 if (target < 0 || target >= ax->len)
550 ax->flaw = agent_flaw_bad_jump;
554 /* Do we have any information about what the stack height
555 should be at the target? */
556 if (targets[target] || boundary[target])
558 if (heights[target] != height)
560 ax->flaw = agent_flaw_height_mismatch;
565 /* Record the target, along with the stack height we expect. */
567 heights[target] = height;
570 /* For unconditional jumps with a successor, check that the
571 successor is a target, and pick up its stack height. */
572 if (aop_goto == op - aop_map
577 ax->flaw = agent_flaw_hole;
581 height = heights[i + 3];
584 /* For reg instructions, record the register in the bit mask. */
585 if (aop_reg == op - aop_map)
587 int reg = read_const (ax, i + 1, 2);
589 ax_reg_mask (ax, reg);
593 /* Check that all the targets are on boundaries. */
594 for (i = 0; i < ax->len; i++)
595 if (targets[i] && !boundary[i])
597 ax->flaw = agent_flaw_bad_jump;
601 ax->final_height = height;