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