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