projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add missing files from previous commit.
[deliverable/binutils-gdb.git] / gdb / gdbserver / ax.c
CommitLineData
9f14eebc
LM		 1/* Agent expression code for remote server.
2 Copyright (C) 2009-2012 Free Software Foundation, Inc.
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#include "server.h"
20#include "ax.h"
21
22static void ax_vdebug (const char *, ...) ATTR_FORMAT (printf, 1, 2);
23
24#ifdef IN_PROCESS_AGENT
25int debug_agent = 0;
26#endif
27
28static void
29ax_vdebug (const char *fmt, ...)
30{
31 char buf[1024];
32 va_list ap;
33
34 va_start (ap, fmt);
35 vsprintf (buf, fmt, ap);
36 fprintf (stderr, PROG "/ax: %s\n", buf);
37 va_end (ap);
38}
39
40#define ax_debug_1(level, fmt, args...) \
41 do { \
42 if (level <= debug_threads) \
43 ax_vdebug ((fmt), ##args); \
44 } while (0)
45
46#define ax_debug(FMT, args...) \
47 ax_debug_1 (1, FMT, ##args)
48
49/* This enum must exactly match what is documented in
50 gdb/doc/agentexpr.texi, including all the numerical values. */
51
52enum gdb_agent_op
53 {
54#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
55 gdb_agent_op_ ## NAME = VALUE,
56#include "ax.def"
57#undef DEFOP
58 gdb_agent_op_last
59 };
60
61static const char *gdb_agent_op_names [gdb_agent_op_last] =
62 {
63 "?undef?"
64#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) , # NAME
65#include "ax.def"
66#undef DEFOP
67 };
68
69static const unsigned char gdb_agent_op_sizes [gdb_agent_op_last] =
70 {
71 0
72#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) , SIZE
73#include "ax.def"
74#undef DEFOP
75 };
76
77/* A wrapper for gdb_agent_op_names that does some bounds-checking. */
78
79static const char *
80gdb_agent_op_name (int op)
81{
82 if (op < 0 || op >= gdb_agent_op_last || gdb_agent_op_names[op] == NULL)
83 return "?undef?";
84 return gdb_agent_op_names[op];
85}
86
87#ifndef IN_PROCESS_AGENT
88
89/* The packet form of an agent expression consists of an 'X', number
90 of bytes in expression, a comma, and then the bytes. */
91
92struct agent_expr *
93gdb_parse_agent_expr (char **actparm)
94{
95 char *act = *actparm;
96 ULONGEST xlen;
97 struct agent_expr *aexpr;
98
99 ++act; /* skip the X */
100 act = unpack_varlen_hex (act, &xlen);
101 ++act; /* skip a comma */
102 aexpr = xmalloc (sizeof (struct agent_expr));
103 aexpr->length = xlen;
104 aexpr->bytes = xmalloc (xlen);
105 convert_ascii_to_int (act, aexpr->bytes, xlen);
106 *actparm = act + (xlen * 2);
107 return aexpr;
108}
109
110/* Convert the bytes of an agent expression back into hex digits, so
111 they can be printed or uploaded. This allocates the buffer,
112 callers should free when they are done with it. */
113
114char *
115gdb_unparse_agent_expr (struct agent_expr *aexpr)
116{
117 char *rslt;
118
119 rslt = xmalloc (2 * aexpr->length + 1);
120 convert_int_to_ascii (aexpr->bytes, rslt, aexpr->length);
121 return rslt;
122}
123
124/* Bytecode compilation. */
125
126CORE_ADDR current_insn_ptr;
127
128int emit_error;
129
130struct bytecode_address
131{
132 int pc;
133 CORE_ADDR address;
134 int goto_pc;
135 /* Offset and size of field to be modified in the goto block. */
136 int from_offset, from_size;
137 struct bytecode_address *next;
138} *bytecode_address_table;
139
140void
141emit_prologue (void)
142{
143 target_emit_ops ()->emit_prologue ();
144}
145
146void
147emit_epilogue (void)
148{
149 target_emit_ops ()->emit_epilogue ();
150}
151
152static void
153emit_add (void)
154{
155 target_emit_ops ()->emit_add ();
156}
157
158static void
159emit_sub (void)
160{
161 target_emit_ops ()->emit_sub ();
162}
163
164static void
165emit_mul (void)
166{
167 target_emit_ops ()->emit_mul ();
168}
169
170static void
171emit_lsh (void)
172{
173 target_emit_ops ()->emit_lsh ();
174}
175
176static void
177emit_rsh_signed (void)
178{
179 target_emit_ops ()->emit_rsh_signed ();
180}
181
182static void
183emit_rsh_unsigned (void)
184{
185 target_emit_ops ()->emit_rsh_unsigned ();
186}
187
188static void
189emit_ext (int arg)
190{
191 target_emit_ops ()->emit_ext (arg);
192}
193
194static void
195emit_log_not (void)
196{
197 target_emit_ops ()->emit_log_not ();
198}
199
200static void
201emit_bit_and (void)
202{
203 target_emit_ops ()->emit_bit_and ();
204}
205
206static void
207emit_bit_or (void)
208{
209 target_emit_ops ()->emit_bit_or ();
210}
211
212static void
213emit_bit_xor (void)
214{
215 target_emit_ops ()->emit_bit_xor ();
216}
217
218static void
219emit_bit_not (void)
220{
221 target_emit_ops ()->emit_bit_not ();
222}
223
224static void
225emit_equal (void)
226{
227 target_emit_ops ()->emit_equal ();
228}
229
230static void
231emit_less_signed (void)
232{
233 target_emit_ops ()->emit_less_signed ();
234}
235
236static void
237emit_less_unsigned (void)
238{
239 target_emit_ops ()->emit_less_unsigned ();
240}
241
242static void
243emit_ref (int size)
244{
245 target_emit_ops ()->emit_ref (size);
246}
247
248static void
249emit_if_goto (int *offset_p, int *size_p)
250{
251 target_emit_ops ()->emit_if_goto (offset_p, size_p);
252}
253
254static void
255emit_goto (int *offset_p, int *size_p)
256{
257 target_emit_ops ()->emit_goto (offset_p, size_p);
258}
259
260static void
261write_goto_address (CORE_ADDR from, CORE_ADDR to, int size)
262{
263 target_emit_ops ()->write_goto_address (from, to, size);
264}
265
266static void
267emit_const (LONGEST num)
268{
269 target_emit_ops ()->emit_const (num);
270}
271
272static void
273emit_reg (int reg)
274{
275 target_emit_ops ()->emit_reg (reg);
276}
277
278static void
279emit_pop (void)
280{
281 target_emit_ops ()->emit_pop ();
282}
283
284static void
285emit_stack_flush (void)
286{
287 target_emit_ops ()->emit_stack_flush ();
288}
289
290static void
291emit_zero_ext (int arg)
292{
293 target_emit_ops ()->emit_zero_ext (arg);
294}
295
296static void
297emit_swap (void)
298{
299 target_emit_ops ()->emit_swap ();
300}
301
302static void
303emit_stack_adjust (int n)
304{
305 target_emit_ops ()->emit_stack_adjust (n);
306}
307
308/* FN's prototype is `LONGEST(*fn)(int)'. */
309
310static void
311emit_int_call_1 (CORE_ADDR fn, int arg1)
312{
313 target_emit_ops ()->emit_int_call_1 (fn, arg1);
314}
315
316/* FN's prototype is `void(*fn)(int,LONGEST)'. */
317
318static void
319emit_void_call_2 (CORE_ADDR fn, int arg1)
320{
321 target_emit_ops ()->emit_void_call_2 (fn, arg1);
322}
323
324static void
325emit_eq_goto (int *offset_p, int *size_p)
326{
327 target_emit_ops ()->emit_eq_goto (offset_p, size_p);
328}
329
330static void
331emit_ne_goto (int *offset_p, int *size_p)
332{
333 target_emit_ops ()->emit_ne_goto (offset_p, size_p);
334}
335
336static void
337emit_lt_goto (int *offset_p, int *size_p)
338{
339 target_emit_ops ()->emit_lt_goto (offset_p, size_p);
340}
341
342static void
343emit_ge_goto (int *offset_p, int *size_p)
344{
345 target_emit_ops ()->emit_ge_goto (offset_p, size_p);
346}
347
348static void
349emit_gt_goto (int *offset_p, int *size_p)
350{
351 target_emit_ops ()->emit_gt_goto (offset_p, size_p);
352}
353
354static void
355emit_le_goto (int *offset_p, int *size_p)
356{
357 target_emit_ops ()->emit_le_goto (offset_p, size_p);
358}
359
360/* Scan an agent expression for any evidence that the given PC is the
361 target of a jump bytecode in the expression. */
362
363int
364is_goto_target (struct agent_expr *aexpr, int pc)
365{
366 int i;
367 unsigned char op;
368
369 for (i = 0; i < aexpr->length; i += 1 + gdb_agent_op_sizes[op])
370 {
371 op = aexpr->bytes[i];
372
373 if (op == gdb_agent_op_goto || op == gdb_agent_op_if_goto)
374 {
375 int target = (aexpr->bytes[i + 1] << 8) + aexpr->bytes[i + 2];
376 if (target == pc)
377 return 1;
378 }
379 }
380
381 return 0;
382}
383
384/* Given an agent expression, turn it into native code. */
385
386enum eval_result_type
387compile_bytecodes (struct agent_expr *aexpr)
388{
389 int pc = 0;
390 int done = 0;
391 unsigned char op, next_op;
392 int arg;
393 /* This is only used to build 64-bit value for constants. */
394 ULONGEST top;
395 struct bytecode_address *aentry, *aentry2;
396
397#define UNHANDLED \
398 do \
399 { \
400 ax_debug ("Cannot compile op 0x%x\n", op); \
401 return expr_eval_unhandled_opcode; \
402 } while (0)
403
404 if (aexpr->length == 0)
405 {
406 ax_debug ("empty agent expression\n");
407 return expr_eval_empty_expression;
408 }
409
410 bytecode_address_table = NULL;
411
412 while (!done)
413 {
414 op = aexpr->bytes[pc];
415
416 ax_debug ("About to compile op 0x%x, pc=%d\n", op, pc);
417
418 /* Record the compiled-code address of the bytecode, for use by
419 jump instructions. */
420 aentry = xmalloc (sizeof (struct bytecode_address));
421 aentry->pc = pc;
422 aentry->address = current_insn_ptr;
423 aentry->goto_pc = -1;
424 aentry->from_offset = aentry->from_size = 0;
425 aentry->next = bytecode_address_table;
426 bytecode_address_table = aentry;
427
428 ++pc;
429
430 emit_error = 0;
431
432 switch (op)
433 {
434 case gdb_agent_op_add:
435 emit_add ();
436 break;
437
438 case gdb_agent_op_sub:
439 emit_sub ();
440 break;
441
442 case gdb_agent_op_mul:
443 emit_mul ();
444 break;
445
446 case gdb_agent_op_div_signed:
447 UNHANDLED;
448 break;
449
450 case gdb_agent_op_div_unsigned:
451 UNHANDLED;
452 break;
453
454 case gdb_agent_op_rem_signed:
455 UNHANDLED;
456 break;
457
458 case gdb_agent_op_rem_unsigned:
459 UNHANDLED;
460 break;
461
462 case gdb_agent_op_lsh:
463 emit_lsh ();
464 break;
465
466 case gdb_agent_op_rsh_signed:
467 emit_rsh_signed ();
468 break;
469
470 case gdb_agent_op_rsh_unsigned:
471 emit_rsh_unsigned ();
472 break;
473
474 case gdb_agent_op_trace:
475 UNHANDLED;
476 break;
477
478 case gdb_agent_op_trace_quick:
479 UNHANDLED;
480 break;
481
482 case gdb_agent_op_log_not:
483 emit_log_not ();
484 break;
485
486 case gdb_agent_op_bit_and:
487 emit_bit_and ();
488 break;
489
490 case gdb_agent_op_bit_or:
491 emit_bit_or ();
492 break;
493
494 case gdb_agent_op_bit_xor:
495 emit_bit_xor ();
496 break;
497
498 case gdb_agent_op_bit_not:
499 emit_bit_not ();
500 break;
501
502 case gdb_agent_op_equal:
503 next_op = aexpr->bytes[pc];
504 if (next_op == gdb_agent_op_if_goto
505 && !is_goto_target (aexpr, pc)
506 && target_emit_ops ()->emit_eq_goto)
507 {
508 ax_debug ("Combining equal & if_goto");
509 pc += 1;
510 aentry->pc = pc;
511 arg = aexpr->bytes[pc++];
512 arg = (arg << 8) + aexpr->bytes[pc++];
513 aentry->goto_pc = arg;
514 emit_eq_goto (&(aentry->from_offset), &(aentry->from_size));
515 }
516 else if (next_op == gdb_agent_op_log_not
517 && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
518 && !is_goto_target (aexpr, pc + 1)
519 && target_emit_ops ()->emit_ne_goto)
520 {
521 ax_debug ("Combining equal & log_not & if_goto");
522 pc += 2;
523 aentry->pc = pc;
524 arg = aexpr->bytes[pc++];
525 arg = (arg << 8) + aexpr->bytes[pc++];
526 aentry->goto_pc = arg;
527 emit_ne_goto (&(aentry->from_offset), &(aentry->from_size));
528 }
529 else
530 emit_equal ();
531 break;
532
533 case gdb_agent_op_less_signed:
534 next_op = aexpr->bytes[pc];
535 if (next_op == gdb_agent_op_if_goto
536 && !is_goto_target (aexpr, pc))
537 {
538 ax_debug ("Combining less_signed & if_goto");
539 pc += 1;
540 aentry->pc = pc;
541 arg = aexpr->bytes[pc++];
542 arg = (arg << 8) + aexpr->bytes[pc++];
543 aentry->goto_pc = arg;
544 emit_lt_goto (&(aentry->from_offset), &(aentry->from_size));
545 }
546 else if (next_op == gdb_agent_op_log_not
547 && !is_goto_target (aexpr, pc)
548 && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
549 && !is_goto_target (aexpr, pc + 1))
550 {
551 ax_debug ("Combining less_signed & log_not & if_goto");
552 pc += 2;
553 aentry->pc = pc;
554 arg = aexpr->bytes[pc++];
555 arg = (arg << 8) + aexpr->bytes[pc++];
556 aentry->goto_pc = arg;
557 emit_ge_goto (&(aentry->from_offset), &(aentry->from_size));
558 }
559 else
560 emit_less_signed ();
561 break;
562
563 case gdb_agent_op_less_unsigned:
564 emit_less_unsigned ();
565 break;
566
567 case gdb_agent_op_ext:
568 arg = aexpr->bytes[pc++];
569 if (arg < (sizeof (LONGEST) * 8))
570 emit_ext (arg);
571 break;
572
573 case gdb_agent_op_ref8:
574 emit_ref (1);
575 break;
576
577 case gdb_agent_op_ref16:
578 emit_ref (2);
579 break;
580
581 case gdb_agent_op_ref32:
582 emit_ref (4);
583 break;
584
585 case gdb_agent_op_ref64:
586 emit_ref (8);
587 break;
588
589 case gdb_agent_op_if_goto:
590 arg = aexpr->bytes[pc++];
591 arg = (arg << 8) + aexpr->bytes[pc++];
592 aentry->goto_pc = arg;
593 emit_if_goto (&(aentry->from_offset), &(aentry->from_size));
594 break;
595
596 case gdb_agent_op_goto:
597 arg = aexpr->bytes[pc++];
598 arg = (arg << 8) + aexpr->bytes[pc++];
599 aentry->goto_pc = arg;
600 emit_goto (&(aentry->from_offset), &(aentry->from_size));
601 break;
602
603 case gdb_agent_op_const8:
604 emit_stack_flush ();
605 top = aexpr->bytes[pc++];
606 emit_const (top);
607 break;
608
609 case gdb_agent_op_const16:
610 emit_stack_flush ();
611 top = aexpr->bytes[pc++];
612 top = (top << 8) + aexpr->bytes[pc++];
613 emit_const (top);
614 break;
615
616 case gdb_agent_op_const32:
617 emit_stack_flush ();
618 top = aexpr->bytes[pc++];
619 top = (top << 8) + aexpr->bytes[pc++];
620 top = (top << 8) + aexpr->bytes[pc++];
621 top = (top << 8) + aexpr->bytes[pc++];
622 emit_const (top);
623 break;
624
625 case gdb_agent_op_const64:
626 emit_stack_flush ();
627 top = aexpr->bytes[pc++];
628 top = (top << 8) + aexpr->bytes[pc++];
629 top = (top << 8) + aexpr->bytes[pc++];
630 top = (top << 8) + aexpr->bytes[pc++];
631 top = (top << 8) + aexpr->bytes[pc++];
632 top = (top << 8) + aexpr->bytes[pc++];
633 top = (top << 8) + aexpr->bytes[pc++];
634 top = (top << 8) + aexpr->bytes[pc++];
635 emit_const (top);
636 break;
637
638 case gdb_agent_op_reg:
639 emit_stack_flush ();
640 arg = aexpr->bytes[pc++];
641 arg = (arg << 8) + aexpr->bytes[pc++];
642 emit_reg (arg);
643 break;
644
645 case gdb_agent_op_end:
646 ax_debug ("At end of expression\n");
647
648 /* Assume there is one stack element left, and that it is
649 cached in "top" where emit_epilogue can get to it. */
650 emit_stack_adjust (1);
651
652 done = 1;
653 break;
654
655 case gdb_agent_op_dup:
656 /* In our design, dup is equivalent to stack flushing. */
657 emit_stack_flush ();
658 break;
659
660 case gdb_agent_op_pop:
661 emit_pop ();
662 break;
663
664 case gdb_agent_op_zero_ext:
665 arg = aexpr->bytes[pc++];
666 if (arg < (sizeof (LONGEST) * 8))
667 emit_zero_ext (arg);
668 break;
669
670 case gdb_agent_op_swap:
671 next_op = aexpr->bytes[pc];
672 /* Detect greater-than comparison sequences. */
673 if (next_op == gdb_agent_op_less_signed
674 && !is_goto_target (aexpr, pc)
675 && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
676 && !is_goto_target (aexpr, pc + 1))
677 {
678 ax_debug ("Combining swap & less_signed & if_goto");
679 pc += 2;
680 aentry->pc = pc;
681 arg = aexpr->bytes[pc++];
682 arg = (arg << 8) + aexpr->bytes[pc++];
683 aentry->goto_pc = arg;
684 emit_gt_goto (&(aentry->from_offset), &(aentry->from_size));
685 }
686 else if (next_op == gdb_agent_op_less_signed
687 && !is_goto_target (aexpr, pc)
688 && (aexpr->bytes[pc + 1] == gdb_agent_op_log_not)
689 && !is_goto_target (aexpr, pc + 1)
690 && (aexpr->bytes[pc + 2] == gdb_agent_op_if_goto)
691 && !is_goto_target (aexpr, pc + 2))
692 {
693 ax_debug ("Combining swap & less_signed & log_not & if_goto");
694 pc += 3;
695 aentry->pc = pc;
696 arg = aexpr->bytes[pc++];
697 arg = (arg << 8) + aexpr->bytes[pc++];
698 aentry->goto_pc = arg;
699 emit_le_goto (&(aentry->from_offset), &(aentry->from_size));
700 }
701 else
702 emit_swap ();
703 break;
704
705 case gdb_agent_op_getv:
706 emit_stack_flush ();
707 arg = aexpr->bytes[pc++];
708 arg = (arg << 8) + aexpr->bytes[pc++];
709 emit_int_call_1 (get_get_tsv_func_addr (),
710 arg);
711 break;
712
713 case gdb_agent_op_setv:
714 arg = aexpr->bytes[pc++];
715 arg = (arg << 8) + aexpr->bytes[pc++];
716 emit_void_call_2 (get_set_tsv_func_addr (),
717 arg);
718 break;
719
720 case gdb_agent_op_tracev:
721 UNHANDLED;
722 break;
723
724 /* GDB never (currently) generates any of these ops. */
725 case gdb_agent_op_float:
726 case gdb_agent_op_ref_float:
727 case gdb_agent_op_ref_double:
728 case gdb_agent_op_ref_long_double:
729 case gdb_agent_op_l_to_d:
730 case gdb_agent_op_d_to_l:
731 case gdb_agent_op_trace16:
732 UNHANDLED;
733 break;
734
735 default:
736 ax_debug ("Agent expression op 0x%x not recognized\n", op);
737 /* Don't struggle on, things will just get worse. */
738 return expr_eval_unrecognized_opcode;
739 }
740
741 /* This catches errors that occur in target-specific code
742 emission. */
743 if (emit_error)
744 {
745 ax_debug ("Error %d while emitting code for %s\n",
746 emit_error, gdb_agent_op_name (op));
747 return expr_eval_unhandled_opcode;
748 }
749
750 ax_debug ("Op %s compiled\n", gdb_agent_op_name (op));
751 }
752
753 /* Now fill in real addresses as goto destinations. */
754 for (aentry = bytecode_address_table; aentry; aentry = aentry->next)
755 {
756 int written = 0;
757
758 if (aentry->goto_pc < 0)
759 continue;
760
761 /* Find the location that we are going to, and call back into
762 target-specific code to write the actual address or
763 displacement. */
764 for (aentry2 = bytecode_address_table; aentry2; aentry2 = aentry2->next)
765 {
766 if (aentry2->pc == aentry->goto_pc)
767 {
768 ax_debug ("Want to jump from %s to %s\n",
769 paddress (aentry->address),
770 paddress (aentry2->address));
771 write_goto_address (aentry->address + aentry->from_offset,
772 aentry2->address, aentry->from_size);
773 written = 1;
774 break;
775 }
776 }
777
778 /* Error out if we didn't find a destination. */
779 if (!written)
780 {
781 ax_debug ("Destination of goto %d not found\n",
782 aentry->goto_pc);
783 return expr_eval_invalid_goto;
784 }
785 }
786
787 return expr_eval_no_error;
788}
789
790#endif
791
792/* The agent expression evaluator, as specified by the GDB docs. It
793 returns 0 if everything went OK, and a nonzero error code
794 otherwise. */
795
796enum eval_result_type
797gdb_eval_agent_expr (struct regcache *regcache,
798 struct traceframe *tframe,
799 struct agent_expr *aexpr,
800 ULONGEST *rslt)
801{
802 int pc = 0;
803#define STACK_MAX 100
804 ULONGEST stack[STACK_MAX], top;
805 int sp = 0;
806 unsigned char op;
807 int arg;
808
809 /* This union is a convenient way to convert representations. For
810 now, assume a standard architecture where the hardware integer
811 types have 8, 16, 32, 64 bit types. A more robust solution would
812 be to import stdint.h from gnulib. */
813 union
814 {
815 union
816 {
817 unsigned char bytes[1];
818 unsigned char val;
819 } u8;
820 union
821 {
822 unsigned char bytes[2];
823 unsigned short val;
824 } u16;
825 union
826 {
827 unsigned char bytes[4];
828 unsigned int val;
829 } u32;
830 union
831 {
832 unsigned char bytes[8];
833 ULONGEST val;
834 } u64;
835 } cnv;
836
837 if (aexpr->length == 0)
838 {
839 ax_debug ("empty agent expression");
840 return expr_eval_empty_expression;
841 }
842
843 /* Cache the stack top in its own variable. Much of the time we can
844 operate on this variable, rather than dinking with the stack. It
845 needs to be copied to the stack when sp changes. */
846 top = 0;
847
848 while (1)
849 {
850 op = aexpr->bytes[pc++];
851
852 ax_debug ("About to interpret byte 0x%x", op);
853
854 switch (op)
855 {
856 case gdb_agent_op_add:
857 top += stack[--sp];
858 break;
859
860 case gdb_agent_op_sub:
861 top = stack[--sp] - top;
862 break;
863
864 case gdb_agent_op_mul:
865 top *= stack[--sp];
866 break;
867
868 case gdb_agent_op_div_signed:
869 if (top == 0)
870 {
871 ax_debug ("Attempted to divide by zero");
872 return expr_eval_divide_by_zero;
873 }
874 top = ((LONGEST) stack[--sp]) / ((LONGEST) top);
875 break;
876
877 case gdb_agent_op_div_unsigned:
878 if (top == 0)
879 {
880 ax_debug ("Attempted to divide by zero");
881 return expr_eval_divide_by_zero;
882 }
883 top = stack[--sp] / top;
884 break;
885
886 case gdb_agent_op_rem_signed:
887 if (top == 0)
888 {
889 ax_debug ("Attempted to divide by zero");
890 return expr_eval_divide_by_zero;
891 }
892 top = ((LONGEST) stack[--sp]) % ((LONGEST) top);
893 break;
894
895 case gdb_agent_op_rem_unsigned:
896 if (top == 0)
897 {
898 ax_debug ("Attempted to divide by zero");
899 return expr_eval_divide_by_zero;
900 }
901 top = stack[--sp] % top;
902 break;
903
904 case gdb_agent_op_lsh:
905 top = stack[--sp] << top;
906 break;
907
908 case gdb_agent_op_rsh_signed:
909 top = ((LONGEST) stack[--sp]) >> top;
910 break;
911
912 case gdb_agent_op_rsh_unsigned:
913 top = stack[--sp] >> top;
914 break;
915
916 case gdb_agent_op_trace:
917 agent_mem_read (tframe,
918 NULL, (CORE_ADDR) stack[--sp], (ULONGEST) top);
919 if (--sp >= 0)
920 top = stack[sp];
921 break;
922
923 case gdb_agent_op_trace_quick:
924 arg = aexpr->bytes[pc++];
925 agent_mem_read (tframe, NULL, (CORE_ADDR) top, (ULONGEST) arg);
926 break;
927
928 case gdb_agent_op_log_not:
929 top = !top;
930 break;
931
932 case gdb_agent_op_bit_and:
933 top &= stack[--sp];
934 break;
935
936 case gdb_agent_op_bit_or:
937 top |= stack[--sp];
938 break;
939
940 case gdb_agent_op_bit_xor:
941 top ^= stack[--sp];
942 break;
943
944 case gdb_agent_op_bit_not:
945 top = ~top;
946 break;
947
948 case gdb_agent_op_equal:
949 top = (stack[--sp] == top);
950 break;
951
952 case gdb_agent_op_less_signed:
953 top = (((LONGEST) stack[--sp]) < ((LONGEST) top));
954 break;
955
956 case gdb_agent_op_less_unsigned:
957 top = (stack[--sp] < top);
958 break;
959
960 case gdb_agent_op_ext:
961 arg = aexpr->bytes[pc++];
962 if (arg < (sizeof (LONGEST) * 8))
963 {
964 LONGEST mask = 1 << (arg - 1);
965 top &= ((LONGEST) 1 << arg) - 1;
966 top = (top ^ mask) - mask;
967 }
968 break;
969
970 case gdb_agent_op_ref8:
971 agent_mem_read (tframe, cnv.u8.bytes, (CORE_ADDR) top, 1);
972 top = cnv.u8.val;
973 break;
974
975 case gdb_agent_op_ref16:
976 agent_mem_read (tframe, cnv.u16.bytes, (CORE_ADDR) top, 2);
977 top = cnv.u16.val;
978 break;
979
980 case gdb_agent_op_ref32:
981 agent_mem_read (tframe, cnv.u32.bytes, (CORE_ADDR) top, 4);
982 top = cnv.u32.val;
983 break;
984
985 case gdb_agent_op_ref64:
986 agent_mem_read (tframe, cnv.u64.bytes, (CORE_ADDR) top, 8);
987 top = cnv.u64.val;
988 break;
989
990 case gdb_agent_op_if_goto:
991 if (top)
992 pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
993 else
994 pc += 2;
995 if (--sp >= 0)
996 top = stack[sp];
997 break;
998
999 case gdb_agent_op_goto:
1000 pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
1001 break;
1002
1003 case gdb_agent_op_const8:
1004 /* Flush the cached stack top. */
1005 stack[sp++] = top;
1006 top = aexpr->bytes[pc++];
1007 break;
1008
1009 case gdb_agent_op_const16:
1010 /* Flush the cached stack top. */
1011 stack[sp++] = top;
1012 top = aexpr->bytes[pc++];
1013 top = (top << 8) + aexpr->bytes[pc++];
1014 break;
1015
1016 case gdb_agent_op_const32:
1017 /* Flush the cached stack top. */
1018 stack[sp++] = top;
1019 top = aexpr->bytes[pc++];
1020 top = (top << 8) + aexpr->bytes[pc++];
1021 top = (top << 8) + aexpr->bytes[pc++];
1022 top = (top << 8) + aexpr->bytes[pc++];
1023 break;
1024
1025 case gdb_agent_op_const64:
1026 /* Flush the cached stack top. */
1027 stack[sp++] = top;
1028 top = aexpr->bytes[pc++];
1029 top = (top << 8) + aexpr->bytes[pc++];
1030 top = (top << 8) + aexpr->bytes[pc++];
1031 top = (top << 8) + aexpr->bytes[pc++];
1032 top = (top << 8) + aexpr->bytes[pc++];
1033 top = (top << 8) + aexpr->bytes[pc++];
1034 top = (top << 8) + aexpr->bytes[pc++];
1035 top = (top << 8) + aexpr->bytes[pc++];
1036 break;
1037
1038 case gdb_agent_op_reg:
1039 /* Flush the cached stack top. */
1040 stack[sp++] = top;
1041 arg = aexpr->bytes[pc++];
1042 arg = (arg << 8) + aexpr->bytes[pc++];
1043 {
1044 int regnum = arg;
1045
1046 switch (register_size (regnum))
1047 {
1048 case 8:
1049 collect_register (regcache, regnum, cnv.u64.bytes);
1050 top = cnv.u64.val;
1051 break;
1052 case 4:
1053 collect_register (regcache, regnum, cnv.u32.bytes);
1054 top = cnv.u32.val;
1055 break;
1056 case 2:
1057 collect_register (regcache, regnum, cnv.u16.bytes);
1058 top = cnv.u16.val;
1059 break;
1060 case 1:
1061 collect_register (regcache, regnum, cnv.u8.bytes);
1062 top = cnv.u8.val;
1063 break;
1064 default:
1065 internal_error (__FILE__, __LINE__,
1066 "unhandled register size");
1067 }
1068 }
1069 break;
1070
1071 case gdb_agent_op_end:
1072 ax_debug ("At end of expression, sp=%d, stack top cache=0x%s",
1073 sp, pulongest (top));
1074 if (rslt)
1075 {
1076 if (sp <= 0)
1077 {
1078 /* This should be an error */
1079 ax_debug ("Stack is empty, nothing to return");
1080 return expr_eval_empty_stack;
1081 }
1082 *rslt = top;
1083 }
1084 return expr_eval_no_error;
1085
1086 case gdb_agent_op_dup:
1087 stack[sp++] = top;
1088 break;
1089
1090 case gdb_agent_op_pop:
1091 if (--sp >= 0)
1092 top = stack[sp];
1093 break;
1094
1095 case gdb_agent_op_pick:
1096 arg = aexpr->bytes[pc++];
1097 stack[sp] = top;
1098 top = stack[sp - arg];
1099 ++sp;
1100 break;
1101
1102 case gdb_agent_op_rot:
1103 {
1104 ULONGEST tem = stack[sp - 1];
1105
1106 stack[sp - 1] = stack[sp - 2];
1107 stack[sp - 2] = top;
1108 top = tem;
1109 }
1110 break;
1111
1112 case gdb_agent_op_zero_ext:
1113 arg = aexpr->bytes[pc++];
1114 if (arg < (sizeof (LONGEST) * 8))
1115 top &= ((LONGEST) 1 << arg) - 1;
1116 break;
1117
1118 case gdb_agent_op_swap:
1119 /* Interchange top two stack elements, making sure top gets
1120 copied back onto stack. */
1121 stack[sp] = top;
1122 top = stack[sp - 1];
1123 stack[sp - 1] = stack[sp];
1124 break;
1125
1126 case gdb_agent_op_getv:
1127 /* Flush the cached stack top. */
1128 stack[sp++] = top;
1129 arg = aexpr->bytes[pc++];
1130 arg = (arg << 8) + aexpr->bytes[pc++];
1131 top = agent_get_trace_state_variable_value (arg);
1132 break;
1133
1134 case gdb_agent_op_setv:
1135 arg = aexpr->bytes[pc++];
1136 arg = (arg << 8) + aexpr->bytes[pc++];
1137 agent_set_trace_state_variable_value (arg, top);
1138 /* Note that we leave the value on the stack, for the
1139 benefit of later/enclosing expressions. */
1140 break;
1141
1142 case gdb_agent_op_tracev:
1143 arg = aexpr->bytes[pc++];
1144 arg = (arg << 8) + aexpr->bytes[pc++];
1145 agent_tsv_read (tframe, arg);
1146 break;
1147
1148 case gdb_agent_op_tracenz:
1149 agent_mem_read_string (tframe, NULL, (CORE_ADDR) stack[--sp],
1150 (ULONGEST) top);
1151 if (--sp >= 0)
1152 top = stack[sp];
1153 break;
1154
1155 /* GDB never (currently) generates any of these ops. */
1156 case gdb_agent_op_float:
1157 case gdb_agent_op_ref_float:
1158 case gdb_agent_op_ref_double:
1159 case gdb_agent_op_ref_long_double:
1160 case gdb_agent_op_l_to_d:
1161 case gdb_agent_op_d_to_l:
1162 case gdb_agent_op_trace16:
1163 ax_debug ("Agent expression op 0x%x valid, but not handled",
1164 op);
1165 /* If ever GDB generates any of these, we don't have the
1166 option of ignoring. */
1167 return 1;
1168
1169 default:
1170 ax_debug ("Agent expression op 0x%x not recognized", op);
1171 /* Don't struggle on, things will just get worse. */
1172 return expr_eval_unrecognized_opcode;
1173 }
1174
1175 /* Check for stack badness. */
1176 if (sp >= (STACK_MAX - 1))
1177 {
1178 ax_debug ("Expression stack overflow");
1179 return expr_eval_stack_overflow;
1180 }
1181
1182 if (sp < 0)
1183 {
1184 ax_debug ("Expression stack underflow");
1185 return expr_eval_stack_underflow;
1186 }
1187
1188 ax_debug ("Op %s -> sp=%d, top=0x%s",
1189 gdb_agent_op_name (op), sp, pulongest (top));
1190 }
1191}
GDB Binutils - Deliverables
This page took 0.0679 seconds and 4 git commands to generate.