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 static void grow_expr (struct agent_expr *x, int n);
33 static void append_const (struct agent_expr *x, LONGEST val, int n);
35 static LONGEST read_const (struct agent_expr *x, int o, int n);
37 static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
39 /* Functions for building expressions. */
41 /* Allocate a new, empty agent expression. */
43 new_agent_expr (CORE_ADDR scope)
45 struct agent_expr *x = xmalloc (sizeof (*x));
47 x->size = 1; /* Change this to a larger value once
48 reallocation code is tested. */
49 x->buf = xmalloc (x->size);
55 /* Free a agent expression. */
57 free_agent_expr (struct agent_expr *x)
64 do_free_agent_expr_cleanup (void *x)
70 make_cleanup_free_agent_expr (struct agent_expr *x)
72 return make_cleanup (do_free_agent_expr_cleanup, x);
76 /* Make sure that X has room for at least N more bytes. This doesn't
77 affect the length, just the allocated size. */
79 grow_expr (struct agent_expr *x, int n)
81 if (x->len + n > x->size)
84 if (x->size < x->len + n)
85 x->size = x->len + n + 10;
86 x->buf = xrealloc (x->buf, x->size);
91 /* Append the low N bytes of VAL as an N-byte integer to the
92 expression X, in big-endian order. */
94 append_const (struct agent_expr *x, LONGEST val, int n)
99 for (i = n - 1; i >= 0; i--)
101 x->buf[x->len + i] = val & 0xff;
108 /* Extract an N-byte big-endian unsigned integer from expression X at
111 read_const (struct agent_expr *x, int o, int n)
116 /* Make sure we're not reading off the end of the expression. */
118 error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
120 for (i = 0; i < n; i++)
121 accum = (accum << 8) | x->buf[o + i];
127 /* Append a simple operator OP to EXPR. */
129 ax_simple (struct agent_expr *x, enum agent_op op)
132 x->buf[x->len++] = op;
136 /* Append a sign-extension or zero-extension instruction to EXPR, to
137 extend an N-bit value. */
139 generic_ext (struct agent_expr *x, enum agent_op op, int n)
141 /* N must fit in a byte. */
142 if (n < 0 || n > 255)
143 error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
144 /* That had better be enough range. */
145 if (sizeof (LONGEST) * 8 > 255)
146 error (_("GDB bug: ax-general.c (generic_ext): opcode has inadequate range"));
149 x->buf[x->len++] = op;
150 x->buf[x->len++] = n;
154 /* Append a sign-extension instruction to EXPR, to extend an N-bit value. */
156 ax_ext (struct agent_expr *x, int n)
158 generic_ext (x, aop_ext, n);
162 /* Append a zero-extension instruction to EXPR, to extend an N-bit value. */
164 ax_zero_ext (struct agent_expr *x, int n)
166 generic_ext (x, aop_zero_ext, n);
170 /* Append a trace_quick instruction to EXPR, to record N bytes. */
172 ax_trace_quick (struct agent_expr *x, int n)
174 /* N must fit in a byte. */
175 if (n < 0 || n > 255)
176 error (_("GDB bug: ax-general.c (ax_trace_quick): size out of range for trace_quick"));
179 x->buf[x->len++] = aop_trace_quick;
180 x->buf[x->len++] = n;
184 /* Append a goto op to EXPR. OP is the actual op (must be aop_goto or
185 aop_if_goto). We assume we don't know the target offset yet,
186 because it's probably a forward branch, so we leave space in EXPR
187 for the target, and return the offset in EXPR of that space, so we
188 can backpatch it once we do know the target offset. Use ax_label
189 to do the backpatching. */
191 ax_goto (struct agent_expr *x, enum agent_op op)
194 x->buf[x->len + 0] = op;
195 x->buf[x->len + 1] = 0xff;
196 x->buf[x->len + 2] = 0xff;
201 /* Suppose a given call to ax_goto returns some value PATCH. When you
202 know the offset TARGET that goto should jump to, call
203 ax_label (EXPR, PATCH, TARGET)
204 to patch TARGET into the ax_goto instruction. */
206 ax_label (struct agent_expr *x, int patch, int target)
208 /* Make sure the value is in range. Don't accept 0xffff as an
209 offset; that's our magic sentinel value for unpatched branches. */
210 if (target < 0 || target >= 0xffff)
211 error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
213 x->buf[patch] = (target >> 8) & 0xff;
214 x->buf[patch + 1] = target & 0xff;
218 /* Assemble code to push a constant on the stack. */
220 ax_const_l (struct agent_expr *x, LONGEST l)
222 static enum agent_op ops[]
224 {aop_const8, aop_const16, aop_const32, aop_const64};
228 /* How big is the number? 'op' keeps track of which opcode to use.
229 Notice that we don't really care whether the original number was
230 signed or unsigned; we always reproduce the value exactly, and
231 use the shortest representation. */
232 for (op = 0, size = 8; size < 64; size *= 2, op++)
234 LONGEST lim = ((LONGEST) 1) << (size - 1);
236 if (-lim <= l && l <= lim - 1)
240 /* Emit the right opcode... */
241 ax_simple (x, ops[op]);
243 /* Emit the low SIZE bytes as an unsigned number. We know that
244 sign-extending this will yield l. */
245 append_const (x, l, size / 8);
247 /* Now, if it was negative, and not full-sized, sign-extend it. */
248 if (l < 0 && size < 64)
254 ax_const_d (struct agent_expr *x, LONGEST d)
256 /* FIXME: floating-point support not present yet. */
257 error (_("GDB bug: ax-general.c (ax_const_d): floating point not supported yet"));
261 /* Assemble code to push the value of register number REG on the
264 ax_reg (struct agent_expr *x, int reg)
266 /* Make sure the register number is in range. */
267 if (reg < 0 || reg > 0xffff)
268 error (_("GDB bug: ax-general.c (ax_reg): register number out of range"));
270 x->buf[x->len] = aop_reg;
271 x->buf[x->len + 1] = (reg >> 8) & 0xff;
272 x->buf[x->len + 2] = (reg) & 0xff;
276 /* Assemble code to operate on a trace state variable. */
279 ax_tsv (struct agent_expr *x, enum agent_op op, int num)
281 /* Make sure the tsv number is in range. */
282 if (num < 0 || num > 0xffff)
283 internal_error (__FILE__, __LINE__, _("ax-general.c (ax_tsv): variable number is %d, out of range"), num);
287 x->buf[x->len + 1] = (num >> 8) & 0xff;
288 x->buf[x->len + 2] = (num) & 0xff;
294 /* Functions for disassembling agent expressions, and otherwise
295 debugging the expression compiler. */
297 struct aop_map aop_map[] =
300 {"float", 0, 0, 0, 0}, /* 0x01 */
301 {"add", 0, 0, 2, 1}, /* 0x02 */
302 {"sub", 0, 0, 2, 1}, /* 0x03 */
303 {"mul", 0, 0, 2, 1}, /* 0x04 */
304 {"div_signed", 0, 0, 2, 1}, /* 0x05 */
305 {"div_unsigned", 0, 0, 2, 1}, /* 0x06 */
306 {"rem_signed", 0, 0, 2, 1}, /* 0x07 */
307 {"rem_unsigned", 0, 0, 2, 1}, /* 0x08 */
308 {"lsh", 0, 0, 2, 1}, /* 0x09 */
309 {"rsh_signed", 0, 0, 2, 1}, /* 0x0a */
310 {"rsh_unsigned", 0, 0, 2, 1}, /* 0x0b */
311 {"trace", 0, 0, 2, 0}, /* 0x0c */
312 {"trace_quick", 1, 0, 1, 1}, /* 0x0d */
313 {"log_not", 0, 0, 1, 1}, /* 0x0e */
314 {"bit_and", 0, 0, 2, 1}, /* 0x0f */
315 {"bit_or", 0, 0, 2, 1}, /* 0x10 */
316 {"bit_xor", 0, 0, 2, 1}, /* 0x11 */
317 {"bit_not", 0, 0, 1, 1}, /* 0x12 */
318 {"equal", 0, 0, 2, 1}, /* 0x13 */
319 {"less_signed", 0, 0, 2, 1}, /* 0x14 */
320 {"less_unsigned", 0, 0, 2, 1}, /* 0x15 */
321 {"ext", 1, 0, 1, 1}, /* 0x16 */
322 {"ref8", 0, 8, 1, 1}, /* 0x17 */
323 {"ref16", 0, 16, 1, 1}, /* 0x18 */
324 {"ref32", 0, 32, 1, 1}, /* 0x19 */
325 {"ref64", 0, 64, 1, 1}, /* 0x1a */
326 {"ref_float", 0, 0, 1, 1}, /* 0x1b */
327 {"ref_double", 0, 0, 1, 1}, /* 0x1c */
328 {"ref_long_double", 0, 0, 1, 1}, /* 0x1d */
329 {"l_to_d", 0, 0, 1, 1}, /* 0x1e */
330 {"d_to_l", 0, 0, 1, 1}, /* 0x1f */
331 {"if_goto", 2, 0, 1, 0}, /* 0x20 */
332 {"goto", 2, 0, 0, 0}, /* 0x21 */
333 {"const8", 1, 8, 0, 1}, /* 0x22 */
334 {"const16", 2, 16, 0, 1}, /* 0x23 */
335 {"const32", 4, 32, 0, 1}, /* 0x24 */
336 {"const64", 8, 64, 0, 1}, /* 0x25 */
337 {"reg", 2, 0, 0, 1}, /* 0x26 */
338 {"end", 0, 0, 0, 0}, /* 0x27 */
339 {"dup", 0, 0, 1, 2}, /* 0x28 */
340 {"pop", 0, 0, 1, 0}, /* 0x29 */
341 {"zero_ext", 1, 0, 1, 1}, /* 0x2a */
342 {"swap", 0, 0, 2, 2}, /* 0x2b */
343 {"getv", 2, 0, 0, 1}, /* 0x2c */
344 {"setv", 2, 0, 0, 1}, /* 0x2d */
345 {"tracev", 2, 0, 0, 1}, /* 0x2e */
346 {0, 0, 0, 0, 0}, /* 0x2f */
347 {"trace16", 2, 0, 1, 1}, /* 0x30 */
351 /* Disassemble the expression EXPR, writing to F. */
353 ax_print (struct ui_file *f, struct agent_expr *x)
358 /* Check the size of the name array against the number of entries in
359 the enum, to catch additions that people didn't sync. */
360 if ((sizeof (aop_map) / sizeof (aop_map[0]))
362 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
364 for (i = 0; i < x->len;)
366 enum agent_op op = x->buf[i];
368 if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
369 || !aop_map[op].name)
371 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op);
375 if (i + 1 + aop_map[op].op_size > x->len)
377 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"),
378 i, aop_map[op].name);
382 fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
383 if (aop_map[op].op_size > 0)
385 fputs_filtered (" ", f);
387 print_longest (f, 'd', 0,
388 read_const (x, i + 1, aop_map[op].op_size));
390 fprintf_filtered (f, "\n");
391 i += 1 + aop_map[op].op_size;
393 is_float = (op == aop_float);
398 /* Given an agent expression AX, fill in an agent_reqs structure REQS
401 ax_reqs (struct agent_expr *ax, struct agent_reqs *reqs)
406 /* Bit vector for registers used. */
407 int reg_mask_len = 1;
408 unsigned char *reg_mask = xmalloc (reg_mask_len * sizeof (reg_mask[0]));
410 /* Jump target table. targets[i] is non-zero iff we have found a
412 char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
414 /* Instruction boundary table. boundary[i] is non-zero iff our scan
415 has reached an instruction starting at offset i. */
416 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
418 /* Stack height record. If either targets[i] or boundary[i] is
419 non-zero, heights[i] is the height the stack should have before
420 executing the bytecode at that point. */
421 int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
423 /* Pointer to a description of the present op. */
426 memset (reg_mask, 0, reg_mask_len * sizeof (reg_mask[0]));
427 memset (targets, 0, ax->len * sizeof (targets[0]));
428 memset (boundary, 0, ax->len * sizeof (boundary[0]));
430 reqs->max_height = reqs->min_height = height = 0;
431 reqs->flaw = agent_flaw_none;
432 reqs->max_data_size = 0;
434 for (i = 0; i < ax->len; i += 1 + op->op_size)
436 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
438 reqs->flaw = agent_flaw_bad_instruction;
443 op = &aop_map[ax->buf[i]];
447 reqs->flaw = agent_flaw_bad_instruction;
452 if (i + 1 + op->op_size > ax->len)
454 reqs->flaw = agent_flaw_incomplete_instruction;
459 /* If this instruction is a forward jump target, does the
460 current stack height match the stack height at the jump
462 if (targets[i] && (heights[i] != height))
464 reqs->flaw = agent_flaw_height_mismatch;
472 height -= op->consumed;
473 if (height < reqs->min_height)
474 reqs->min_height = height;
475 height += op->produced;
476 if (height > reqs->max_height)
477 reqs->max_height = height;
479 if (op->data_size > reqs->max_data_size)
480 reqs->max_data_size = op->data_size;
482 /* For jump instructions, check that the target is a valid
483 offset. If it is, record the fact that that location is a
484 jump target, and record the height we expect there. */
485 if (aop_goto == op - aop_map
486 || aop_if_goto == op - aop_map)
488 int target = read_const (ax, i + 1, 2);
489 if (target < 0 || target >= ax->len)
491 reqs->flaw = agent_flaw_bad_jump;
496 /* Do we have any information about what the stack height
497 should be at the target? */
498 if (targets[target] || boundary[target])
500 if (heights[target] != height)
502 reqs->flaw = agent_flaw_height_mismatch;
508 /* Record the target, along with the stack height we expect. */
510 heights[target] = height;
513 /* For unconditional jumps with a successor, check that the
514 successor is a target, and pick up its stack height. */
515 if (aop_goto == op - aop_map
520 reqs->flaw = agent_flaw_hole;
525 height = heights[i + 3];
528 /* For reg instructions, record the register in the bit mask. */
529 if (aop_reg == op - aop_map)
531 int reg = read_const (ax, i + 1, 2);
534 /* Grow the bit mask if necessary. */
535 if (byte >= reg_mask_len)
537 /* It's not appropriate to double here. This isn't a
539 int new_len = byte + 1;
540 reg_mask = xrealloc (reg_mask,
541 new_len * sizeof (reg_mask[0]));
542 memset (reg_mask + reg_mask_len, 0,
543 (new_len - reg_mask_len) * sizeof (reg_mask[0]));
544 reg_mask_len = new_len;
547 reg_mask[byte] |= 1 << (reg % 8);
551 /* Check that all the targets are on boundaries. */
552 for (i = 0; i < ax->len; i++)
553 if (targets[i] && !boundary[i])
555 reqs->flaw = agent_flaw_bad_jump;
560 reqs->final_height = height;
561 reqs->reg_mask_len = reg_mask_len;
562 reqs->reg_mask = reg_mask;