gdb vendor branch: Bring in additional source files
[dragonfly.git] / contrib / gdb-7 / gdb / ax-general.c
CommitLineData
5796c8dc 1/* Functions for manipulating expressions designed to be executed on the agent
a45ae5f8 2 Copyright (C) 1998-2000, 2007-2012 Free Software Foundation, Inc.
5796c8dc
SS
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/* Despite what the above comment says about this file being part of
20 GDB, we would like to keep these functions free of GDB
21 dependencies, since we want to be able to use them in contexts
22 outside of GDB (test suites, the stub, etc.) */
23
24#include "defs.h"
25#include "ax.h"
26
27#include "value.h"
28#include "gdb_string.h"
29
c50c785c
JM
30#include "user-regs.h"
31
5796c8dc
SS
32static void grow_expr (struct agent_expr *x, int n);
33
34static void append_const (struct agent_expr *x, LONGEST val, int n);
35
36static LONGEST read_const (struct agent_expr *x, int o, int n);
37
38static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
39\f
40/* Functions for building expressions. */
41
42/* Allocate a new, empty agent expression. */
43struct agent_expr *
cf7f2e2d 44new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
5796c8dc
SS
45{
46 struct agent_expr *x = xmalloc (sizeof (*x));
cf7f2e2d 47
5796c8dc
SS
48 x->len = 0;
49 x->size = 1; /* Change this to a larger value once
50 reallocation code is tested. */
51 x->buf = xmalloc (x->size);
cf7f2e2d
JM
52
53 x->gdbarch = gdbarch;
5796c8dc
SS
54 x->scope = scope;
55
cf7f2e2d
JM
56 /* Bit vector for registers used. */
57 x->reg_mask_len = 1;
58 x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0]));
59 memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0]));
60
5796c8dc
SS
61 return x;
62}
63
64/* Free a agent expression. */
65void
66free_agent_expr (struct agent_expr *x)
67{
68 xfree (x->buf);
cf7f2e2d 69 xfree (x->reg_mask);
5796c8dc
SS
70 xfree (x);
71}
72
73static void
74do_free_agent_expr_cleanup (void *x)
75{
76 free_agent_expr (x);
77}
78
79struct cleanup *
80make_cleanup_free_agent_expr (struct agent_expr *x)
81{
82 return make_cleanup (do_free_agent_expr_cleanup, x);
83}
84
85
86/* Make sure that X has room for at least N more bytes. This doesn't
87 affect the length, just the allocated size. */
88static void
89grow_expr (struct agent_expr *x, int n)
90{
91 if (x->len + n > x->size)
92 {
93 x->size *= 2;
94 if (x->size < x->len + n)
95 x->size = x->len + n + 10;
96 x->buf = xrealloc (x->buf, x->size);
97 }
98}
99
100
101/* Append the low N bytes of VAL as an N-byte integer to the
102 expression X, in big-endian order. */
103static void
104append_const (struct agent_expr *x, LONGEST val, int n)
105{
106 int i;
107
108 grow_expr (x, n);
109 for (i = n - 1; i >= 0; i--)
110 {
111 x->buf[x->len + i] = val & 0xff;
112 val >>= 8;
113 }
114 x->len += n;
115}
116
117
118/* Extract an N-byte big-endian unsigned integer from expression X at
119 offset O. */
120static LONGEST
121read_const (struct agent_expr *x, int o, int n)
122{
123 int i;
124 LONGEST accum = 0;
125
126 /* Make sure we're not reading off the end of the expression. */
127 if (o + n > x->len)
128 error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
129
130 for (i = 0; i < n; i++)
131 accum = (accum << 8) | x->buf[o + i];
132
133 return accum;
134}
135
136
137/* Append a simple operator OP to EXPR. */
138void
139ax_simple (struct agent_expr *x, enum agent_op op)
140{
141 grow_expr (x, 1);
142 x->buf[x->len++] = op;
143}
144
c50c785c
JM
145/* Append a pick operator to EXPR. DEPTH is the stack item to pick,
146 with 0 being top of stack. */
147
148void
149ax_pick (struct agent_expr *x, int depth)
150{
151 if (depth < 0 || depth > 255)
152 error (_("GDB bug: ax-general.c (ax_pick): stack depth out of range"));
153 ax_simple (x, aop_pick);
154 append_const (x, 1, depth);
155}
156
5796c8dc
SS
157
158/* Append a sign-extension or zero-extension instruction to EXPR, to
159 extend an N-bit value. */
160static void
161generic_ext (struct agent_expr *x, enum agent_op op, int n)
162{
163 /* N must fit in a byte. */
164 if (n < 0 || n > 255)
165 error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
166 /* That had better be enough range. */
167 if (sizeof (LONGEST) * 8 > 255)
c50c785c
JM
168 error (_("GDB bug: ax-general.c (generic_ext): "
169 "opcode has inadequate range"));
5796c8dc
SS
170
171 grow_expr (x, 2);
172 x->buf[x->len++] = op;
173 x->buf[x->len++] = n;
174}
175
176
177/* Append a sign-extension instruction to EXPR, to extend an N-bit value. */
178void
179ax_ext (struct agent_expr *x, int n)
180{
181 generic_ext (x, aop_ext, n);
182}
183
184
185/* Append a zero-extension instruction to EXPR, to extend an N-bit value. */
186void
187ax_zero_ext (struct agent_expr *x, int n)
188{
189 generic_ext (x, aop_zero_ext, n);
190}
191
192
193/* Append a trace_quick instruction to EXPR, to record N bytes. */
194void
195ax_trace_quick (struct agent_expr *x, int n)
196{
197 /* N must fit in a byte. */
198 if (n < 0 || n > 255)
c50c785c
JM
199 error (_("GDB bug: ax-general.c (ax_trace_quick): "
200 "size out of range for trace_quick"));
5796c8dc
SS
201
202 grow_expr (x, 2);
203 x->buf[x->len++] = aop_trace_quick;
204 x->buf[x->len++] = n;
205}
206
207
208/* Append a goto op to EXPR. OP is the actual op (must be aop_goto or
209 aop_if_goto). We assume we don't know the target offset yet,
210 because it's probably a forward branch, so we leave space in EXPR
211 for the target, and return the offset in EXPR of that space, so we
212 can backpatch it once we do know the target offset. Use ax_label
213 to do the backpatching. */
214int
215ax_goto (struct agent_expr *x, enum agent_op op)
216{
217 grow_expr (x, 3);
218 x->buf[x->len + 0] = op;
219 x->buf[x->len + 1] = 0xff;
220 x->buf[x->len + 2] = 0xff;
221 x->len += 3;
222 return x->len - 2;
223}
224
225/* Suppose a given call to ax_goto returns some value PATCH. When you
226 know the offset TARGET that goto should jump to, call
227 ax_label (EXPR, PATCH, TARGET)
228 to patch TARGET into the ax_goto instruction. */
229void
230ax_label (struct agent_expr *x, int patch, int target)
231{
232 /* Make sure the value is in range. Don't accept 0xffff as an
233 offset; that's our magic sentinel value for unpatched branches. */
234 if (target < 0 || target >= 0xffff)
235 error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
236
237 x->buf[patch] = (target >> 8) & 0xff;
238 x->buf[patch + 1] = target & 0xff;
239}
240
241
242/* Assemble code to push a constant on the stack. */
243void
244ax_const_l (struct agent_expr *x, LONGEST l)
245{
246 static enum agent_op ops[]
247 =
248 {aop_const8, aop_const16, aop_const32, aop_const64};
249 int size;
250 int op;
251
252 /* How big is the number? 'op' keeps track of which opcode to use.
253 Notice that we don't really care whether the original number was
254 signed or unsigned; we always reproduce the value exactly, and
255 use the shortest representation. */
256 for (op = 0, size = 8; size < 64; size *= 2, op++)
257 {
cf7f2e2d 258 LONGEST lim = ((LONGEST) 1) << (size - 1);
5796c8dc
SS
259
260 if (-lim <= l && l <= lim - 1)
261 break;
262 }
263
c50c785c 264 /* Emit the right opcode... */
5796c8dc
SS
265 ax_simple (x, ops[op]);
266
267 /* Emit the low SIZE bytes as an unsigned number. We know that
268 sign-extending this will yield l. */
269 append_const (x, l, size / 8);
270
271 /* Now, if it was negative, and not full-sized, sign-extend it. */
272 if (l < 0 && size < 64)
273 ax_ext (x, size);
274}
275
276
277void
278ax_const_d (struct agent_expr *x, LONGEST d)
279{
280 /* FIXME: floating-point support not present yet. */
c50c785c
JM
281 error (_("GDB bug: ax-general.c (ax_const_d): "
282 "floating point not supported yet"));
5796c8dc
SS
283}
284
285
286/* Assemble code to push the value of register number REG on the
287 stack. */
288void
289ax_reg (struct agent_expr *x, int reg)
290{
c50c785c
JM
291 if (reg >= gdbarch_num_regs (x->gdbarch))
292 {
293 /* This is a pseudo-register. */
294 if (!gdbarch_ax_pseudo_register_push_stack_p (x->gdbarch))
295 error (_("'%s' is a pseudo-register; "
296 "GDB cannot yet trace its contents."),
297 user_reg_map_regnum_to_name (x->gdbarch, reg));
298 if (gdbarch_ax_pseudo_register_push_stack (x->gdbarch, x, reg))
299 error (_("Trace '%s' failed."),
300 user_reg_map_regnum_to_name (x->gdbarch, reg));
301 }
302 else
303 {
304 /* Make sure the register number is in range. */
305 if (reg < 0 || reg > 0xffff)
306 error (_("GDB bug: ax-general.c (ax_reg): "
307 "register number out of range"));
308 grow_expr (x, 3);
309 x->buf[x->len] = aop_reg;
310 x->buf[x->len + 1] = (reg >> 8) & 0xff;
311 x->buf[x->len + 2] = (reg) & 0xff;
312 x->len += 3;
313 }
5796c8dc 314}
cf7f2e2d
JM
315
316/* Assemble code to operate on a trace state variable. */
317
318void
319ax_tsv (struct agent_expr *x, enum agent_op op, int num)
320{
321 /* Make sure the tsv number is in range. */
322 if (num < 0 || num > 0xffff)
c50c785c
JM
323 internal_error (__FILE__, __LINE__,
324 _("ax-general.c (ax_tsv): variable "
325 "number is %d, out of range"), num);
cf7f2e2d
JM
326
327 grow_expr (x, 3);
328 x->buf[x->len] = op;
329 x->buf[x->len + 1] = (num >> 8) & 0xff;
330 x->buf[x->len + 2] = (num) & 0xff;
331 x->len += 3;
332}
5796c8dc
SS
333\f
334
335
336/* Functions for disassembling agent expressions, and otherwise
337 debugging the expression compiler. */
338
339struct aop_map aop_map[] =
340{
c50c785c
JM
341 {0, 0, 0, 0, 0}
342#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
343 , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED }
344#include "ax.def"
345#undef DEFOP
5796c8dc
SS
346};
347
348
349/* Disassemble the expression EXPR, writing to F. */
350void
351ax_print (struct ui_file *f, struct agent_expr *x)
352{
353 int i;
354 int is_float = 0;
355
cf7f2e2d
JM
356 fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
357 fprintf_filtered (f, _("Reg mask:"));
358 for (i = 0; i < x->reg_mask_len; ++i)
359 fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
360 fprintf_filtered (f, _("\n"));
361
5796c8dc
SS
362 /* Check the size of the name array against the number of entries in
363 the enum, to catch additions that people didn't sync. */
364 if ((sizeof (aop_map) / sizeof (aop_map[0]))
365 != aop_last)
366 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
367
368 for (i = 0; i < x->len;)
369 {
370 enum agent_op op = x->buf[i];
371
372 if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
373 || !aop_map[op].name)
374 {
375 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op);
376 i++;
377 continue;
378 }
379 if (i + 1 + aop_map[op].op_size > x->len)
380 {
381 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"),
382 i, aop_map[op].name);
383 break;
384 }
385
386 fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
387 if (aop_map[op].op_size > 0)
388 {
389 fputs_filtered (" ", f);
390
391 print_longest (f, 'd', 0,
392 read_const (x, i + 1, aop_map[op].op_size));
393 }
394 fprintf_filtered (f, "\n");
395 i += 1 + aop_map[op].op_size;
396
397 is_float = (op == aop_float);
398 }
399}
400
cf7f2e2d
JM
401/* Add register REG to the register mask for expression AX. */
402void
403ax_reg_mask (struct agent_expr *ax, int reg)
404{
c50c785c 405 if (reg >= gdbarch_num_regs (ax->gdbarch))
cf7f2e2d 406 {
c50c785c
JM
407 /* This is a pseudo-register. */
408 if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
409 error (_("'%s' is a pseudo-register; "
410 "GDB cannot yet trace its contents."),
411 user_reg_map_regnum_to_name (ax->gdbarch, reg));
412 if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
413 error (_("Trace '%s' failed."),
414 user_reg_map_regnum_to_name (ax->gdbarch, reg));
415 }
416 else
417 {
418 int byte = reg / 8;
419
420 /* Grow the bit mask if necessary. */
421 if (byte >= ax->reg_mask_len)
422 {
423 /* It's not appropriate to double here. This isn't a
424 string buffer. */
425 int new_len = byte + 1;
426 unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
427 new_len
428 * sizeof (ax->reg_mask[0]));
429 memset (new_reg_mask + ax->reg_mask_len, 0,
430 (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
431 ax->reg_mask_len = new_len;
432 ax->reg_mask = new_reg_mask;
433 }
434
435 ax->reg_mask[byte] |= 1 << (reg % 8);
cf7f2e2d 436 }
cf7f2e2d 437}
5796c8dc 438
cf7f2e2d
JM
439/* Given an agent expression AX, fill in requirements and other descriptive
440 bits. */
5796c8dc 441void
cf7f2e2d 442ax_reqs (struct agent_expr *ax)
5796c8dc
SS
443{
444 int i;
445 int height;
446
5796c8dc
SS
447 /* Jump target table. targets[i] is non-zero iff we have found a
448 jump to offset i. */
449 char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
450
451 /* Instruction boundary table. boundary[i] is non-zero iff our scan
452 has reached an instruction starting at offset i. */
453 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
454
455 /* Stack height record. If either targets[i] or boundary[i] is
456 non-zero, heights[i] is the height the stack should have before
457 executing the bytecode at that point. */
458 int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
459
460 /* Pointer to a description of the present op. */
461 struct aop_map *op;
462
5796c8dc
SS
463 memset (targets, 0, ax->len * sizeof (targets[0]));
464 memset (boundary, 0, ax->len * sizeof (boundary[0]));
465
cf7f2e2d
JM
466 ax->max_height = ax->min_height = height = 0;
467 ax->flaw = agent_flaw_none;
468 ax->max_data_size = 0;
5796c8dc
SS
469
470 for (i = 0; i < ax->len; i += 1 + op->op_size)
471 {
472 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
473 {
cf7f2e2d 474 ax->flaw = agent_flaw_bad_instruction;
5796c8dc
SS
475 return;
476 }
477
478 op = &aop_map[ax->buf[i]];
479
480 if (!op->name)
481 {
cf7f2e2d 482 ax->flaw = agent_flaw_bad_instruction;
5796c8dc
SS
483 return;
484 }
485
486 if (i + 1 + op->op_size > ax->len)
487 {
cf7f2e2d 488 ax->flaw = agent_flaw_incomplete_instruction;
5796c8dc
SS
489 return;
490 }
491
492 /* If this instruction is a forward jump target, does the
493 current stack height match the stack height at the jump
494 source? */
495 if (targets[i] && (heights[i] != height))
496 {
cf7f2e2d 497 ax->flaw = agent_flaw_height_mismatch;
5796c8dc
SS
498 return;
499 }
500
501 boundary[i] = 1;
502 heights[i] = height;
503
504 height -= op->consumed;
cf7f2e2d
JM
505 if (height < ax->min_height)
506 ax->min_height = height;
5796c8dc 507 height += op->produced;
cf7f2e2d
JM
508 if (height > ax->max_height)
509 ax->max_height = height;
5796c8dc 510
cf7f2e2d
JM
511 if (op->data_size > ax->max_data_size)
512 ax->max_data_size = op->data_size;
5796c8dc
SS
513
514 /* For jump instructions, check that the target is a valid
515 offset. If it is, record the fact that that location is a
516 jump target, and record the height we expect there. */
517 if (aop_goto == op - aop_map
518 || aop_if_goto == op - aop_map)
519 {
520 int target = read_const (ax, i + 1, 2);
521 if (target < 0 || target >= ax->len)
522 {
cf7f2e2d 523 ax->flaw = agent_flaw_bad_jump;
5796c8dc
SS
524 return;
525 }
526
527 /* Do we have any information about what the stack height
528 should be at the target? */
529 if (targets[target] || boundary[target])
530 {
531 if (heights[target] != height)
532 {
cf7f2e2d 533 ax->flaw = agent_flaw_height_mismatch;
5796c8dc
SS
534 return;
535 }
536 }
537
538 /* Record the target, along with the stack height we expect. */
539 targets[target] = 1;
540 heights[target] = height;
541 }
542
543 /* For unconditional jumps with a successor, check that the
544 successor is a target, and pick up its stack height. */
545 if (aop_goto == op - aop_map
546 && i + 3 < ax->len)
547 {
548 if (!targets[i + 3])
549 {
cf7f2e2d 550 ax->flaw = agent_flaw_hole;
5796c8dc
SS
551 return;
552 }
553
554 height = heights[i + 3];
555 }
556
557 /* For reg instructions, record the register in the bit mask. */
558 if (aop_reg == op - aop_map)
559 {
560 int reg = read_const (ax, i + 1, 2);
5796c8dc 561
cf7f2e2d 562 ax_reg_mask (ax, reg);
5796c8dc
SS
563 }
564 }
565
566 /* Check that all the targets are on boundaries. */
567 for (i = 0; i < ax->len; i++)
568 if (targets[i] && !boundary[i])
569 {
cf7f2e2d 570 ax->flaw = agent_flaw_bad_jump;
5796c8dc
SS
571 return;
572 }
573
cf7f2e2d 574 ax->final_height = height;
5796c8dc 575}