Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / ax-general.c
CommitLineData
5796c8dc 1/* Functions for manipulating expressions designed to be executed on the agent
ef5ccd6c 2 Copyright (C) 1998-2013 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}
ef5ccd6c
JM
333
334/* Append a string to the expression. Note that the string is going
335 into the bytecodes directly, not on the stack. As a precaution,
336 include both length as prefix, and terminate with a NUL. (The NUL
337 is counted in the length.) */
338
339void
340ax_string (struct agent_expr *x, const char *str, int slen)
341{
342 int i;
343
344 /* Make sure the string length is reasonable. */
345 if (slen < 0 || slen > 0xffff)
346 internal_error (__FILE__, __LINE__,
347 _("ax-general.c (ax_string): string "
348 "length is %d, out of allowed range"), slen);
349
350 grow_expr (x, 2 + slen + 1);
351 x->buf[x->len++] = ((slen + 1) >> 8) & 0xff;
352 x->buf[x->len++] = (slen + 1) & 0xff;
353 for (i = 0; i < slen; ++i)
354 x->buf[x->len++] = str[i];
355 x->buf[x->len++] = '\0';
356}
5796c8dc
SS
357\f
358
359
360/* Functions for disassembling agent expressions, and otherwise
361 debugging the expression compiler. */
362
363struct aop_map aop_map[] =
364{
c50c785c
JM
365 {0, 0, 0, 0, 0}
366#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
367 , { # NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED }
368#include "ax.def"
369#undef DEFOP
5796c8dc
SS
370};
371
372
373/* Disassemble the expression EXPR, writing to F. */
374void
375ax_print (struct ui_file *f, struct agent_expr *x)
376{
377 int i;
5796c8dc 378
cf7f2e2d
JM
379 fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
380 fprintf_filtered (f, _("Reg mask:"));
381 for (i = 0; i < x->reg_mask_len; ++i)
382 fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
383 fprintf_filtered (f, _("\n"));
384
5796c8dc
SS
385 /* Check the size of the name array against the number of entries in
386 the enum, to catch additions that people didn't sync. */
387 if ((sizeof (aop_map) / sizeof (aop_map[0]))
388 != aop_last)
389 error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
390
391 for (i = 0; i < x->len;)
392 {
393 enum agent_op op = x->buf[i];
394
395 if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
396 || !aop_map[op].name)
397 {
398 fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op);
399 i++;
400 continue;
401 }
402 if (i + 1 + aop_map[op].op_size > x->len)
403 {
404 fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"),
405 i, aop_map[op].name);
406 break;
407 }
408
409 fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
410 if (aop_map[op].op_size > 0)
411 {
412 fputs_filtered (" ", f);
413
414 print_longest (f, 'd', 0,
415 read_const (x, i + 1, aop_map[op].op_size));
416 }
ef5ccd6c
JM
417 /* Handle the complicated printf arguments specially. */
418 else if (op == aop_printf)
419 {
420 int slen, nargs;
421
422 i++;
423 nargs = x->buf[i++];
424 slen = x->buf[i++];
425 slen = slen * 256 + x->buf[i++];
426 fprintf_filtered (f, _(" \"%s\", %d args"),
427 &(x->buf[i]), nargs);
428 i += slen - 1;
429 }
5796c8dc
SS
430 fprintf_filtered (f, "\n");
431 i += 1 + aop_map[op].op_size;
5796c8dc
SS
432 }
433}
434
cf7f2e2d
JM
435/* Add register REG to the register mask for expression AX. */
436void
437ax_reg_mask (struct agent_expr *ax, int reg)
438{
c50c785c 439 if (reg >= gdbarch_num_regs (ax->gdbarch))
cf7f2e2d 440 {
c50c785c
JM
441 /* This is a pseudo-register. */
442 if (!gdbarch_ax_pseudo_register_collect_p (ax->gdbarch))
443 error (_("'%s' is a pseudo-register; "
444 "GDB cannot yet trace its contents."),
445 user_reg_map_regnum_to_name (ax->gdbarch, reg));
446 if (gdbarch_ax_pseudo_register_collect (ax->gdbarch, ax, reg))
447 error (_("Trace '%s' failed."),
448 user_reg_map_regnum_to_name (ax->gdbarch, reg));
449 }
450 else
451 {
452 int byte = reg / 8;
453
454 /* Grow the bit mask if necessary. */
455 if (byte >= ax->reg_mask_len)
456 {
457 /* It's not appropriate to double here. This isn't a
458 string buffer. */
459 int new_len = byte + 1;
460 unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
461 new_len
462 * sizeof (ax->reg_mask[0]));
463 memset (new_reg_mask + ax->reg_mask_len, 0,
464 (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
465 ax->reg_mask_len = new_len;
466 ax->reg_mask = new_reg_mask;
467 }
468
469 ax->reg_mask[byte] |= 1 << (reg % 8);
cf7f2e2d 470 }
cf7f2e2d 471}
5796c8dc 472
cf7f2e2d
JM
473/* Given an agent expression AX, fill in requirements and other descriptive
474 bits. */
5796c8dc 475void
cf7f2e2d 476ax_reqs (struct agent_expr *ax)
5796c8dc
SS
477{
478 int i;
479 int height;
480
5796c8dc
SS
481 /* Jump target table. targets[i] is non-zero iff we have found a
482 jump to offset i. */
483 char *targets = (char *) alloca (ax->len * sizeof (targets[0]));
484
485 /* Instruction boundary table. boundary[i] is non-zero iff our scan
486 has reached an instruction starting at offset i. */
487 char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));
488
489 /* Stack height record. If either targets[i] or boundary[i] is
490 non-zero, heights[i] is the height the stack should have before
491 executing the bytecode at that point. */
492 int *heights = (int *) alloca (ax->len * sizeof (heights[0]));
493
494 /* Pointer to a description of the present op. */
495 struct aop_map *op;
496
5796c8dc
SS
497 memset (targets, 0, ax->len * sizeof (targets[0]));
498 memset (boundary, 0, ax->len * sizeof (boundary[0]));
499
cf7f2e2d
JM
500 ax->max_height = ax->min_height = height = 0;
501 ax->flaw = agent_flaw_none;
502 ax->max_data_size = 0;
5796c8dc
SS
503
504 for (i = 0; i < ax->len; i += 1 + op->op_size)
505 {
506 if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
507 {
cf7f2e2d 508 ax->flaw = agent_flaw_bad_instruction;
5796c8dc
SS
509 return;
510 }
511
512 op = &aop_map[ax->buf[i]];
513
514 if (!op->name)
515 {
cf7f2e2d 516 ax->flaw = agent_flaw_bad_instruction;
5796c8dc
SS
517 return;
518 }
519
520 if (i + 1 + op->op_size > ax->len)
521 {
cf7f2e2d 522 ax->flaw = agent_flaw_incomplete_instruction;
5796c8dc
SS
523 return;
524 }
525
526 /* If this instruction is a forward jump target, does the
527 current stack height match the stack height at the jump
528 source? */
529 if (targets[i] && (heights[i] != height))
530 {
cf7f2e2d 531 ax->flaw = agent_flaw_height_mismatch;
5796c8dc
SS
532 return;
533 }
534
535 boundary[i] = 1;
536 heights[i] = height;
537
538 height -= op->consumed;
cf7f2e2d
JM
539 if (height < ax->min_height)
540 ax->min_height = height;
5796c8dc 541 height += op->produced;
cf7f2e2d
JM
542 if (height > ax->max_height)
543 ax->max_height = height;
5796c8dc 544
cf7f2e2d
JM
545 if (op->data_size > ax->max_data_size)
546 ax->max_data_size = op->data_size;
5796c8dc
SS
547
548 /* For jump instructions, check that the target is a valid
549 offset. If it is, record the fact that that location is a
550 jump target, and record the height we expect there. */
551 if (aop_goto == op - aop_map
552 || aop_if_goto == op - aop_map)
553 {
554 int target = read_const (ax, i + 1, 2);
555 if (target < 0 || target >= ax->len)
556 {
cf7f2e2d 557 ax->flaw = agent_flaw_bad_jump;
5796c8dc
SS
558 return;
559 }
560
561 /* Do we have any information about what the stack height
562 should be at the target? */
563 if (targets[target] || boundary[target])
564 {
565 if (heights[target] != height)
566 {
cf7f2e2d 567 ax->flaw = agent_flaw_height_mismatch;
5796c8dc
SS
568 return;
569 }
570 }
571
572 /* Record the target, along with the stack height we expect. */
573 targets[target] = 1;
574 heights[target] = height;
575 }
576
577 /* For unconditional jumps with a successor, check that the
578 successor is a target, and pick up its stack height. */
579 if (aop_goto == op - aop_map
580 && i + 3 < ax->len)
581 {
582 if (!targets[i + 3])
583 {
cf7f2e2d 584 ax->flaw = agent_flaw_hole;
5796c8dc
SS
585 return;
586 }
587
588 height = heights[i + 3];
589 }
590
591 /* For reg instructions, record the register in the bit mask. */
592 if (aop_reg == op - aop_map)
593 {
594 int reg = read_const (ax, i + 1, 2);
5796c8dc 595
cf7f2e2d 596 ax_reg_mask (ax, reg);
5796c8dc
SS
597 }
598 }
599
600 /* Check that all the targets are on boundaries. */
601 for (i = 0; i < ax->len; i++)
602 if (targets[i] && !boundary[i])
603 {
cf7f2e2d 604 ax->flaw = agent_flaw_bad_jump;
5796c8dc
SS
605 return;
606 }
607
cf7f2e2d 608 ax->final_height = height;
5796c8dc 609}