1 /* Agent expression code for remote server.
2 Copyright (C) 2009-2015 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
22 #include "tracepoint.h"
25 static void ax_vdebug (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
27 #ifdef IN_PROCESS_AGENT
32 ax_vdebug (const char *fmt
, ...)
38 vsprintf (buf
, fmt
, ap
);
39 fprintf (stderr
, PROG
"/ax: %s\n", buf
);
43 #define ax_debug_1(level, fmt, args...) \
45 if (level <= debug_threads) \
46 ax_vdebug ((fmt), ##args); \
49 #define ax_debug(FMT, args...) \
50 ax_debug_1 (1, FMT, ##args)
52 /* This enum must exactly match what is documented in
53 gdb/doc/agentexpr.texi, including all the numerical values. */
57 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
58 gdb_agent_op_ ## NAME = VALUE,
64 static const char *gdb_agent_op_names
[gdb_agent_op_last
] =
67 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) , # NAME
72 #ifndef IN_PROCESS_AGENT
73 static const unsigned char gdb_agent_op_sizes
[gdb_agent_op_last
] =
76 #define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) , SIZE
82 /* A wrapper for gdb_agent_op_names that does some bounds-checking. */
85 gdb_agent_op_name (int op
)
87 if (op
< 0 || op
>= gdb_agent_op_last
|| gdb_agent_op_names
[op
] == NULL
)
89 return gdb_agent_op_names
[op
];
92 #ifndef IN_PROCESS_AGENT
94 /* The packet form of an agent expression consists of an 'X', number
95 of bytes in expression, a comma, and then the bytes. */
98 gdb_parse_agent_expr (char **actparm
)
100 char *act
= *actparm
;
102 struct agent_expr
*aexpr
;
104 ++act
; /* skip the X */
105 act
= unpack_varlen_hex (act
, &xlen
);
106 ++act
; /* skip a comma */
107 aexpr
= XNEW (struct agent_expr
);
108 aexpr
->length
= xlen
;
109 aexpr
->bytes
= (unsigned char *) xmalloc (xlen
);
110 hex2bin (act
, aexpr
->bytes
, xlen
);
111 *actparm
= act
+ (xlen
* 2);
116 gdb_free_agent_expr (struct agent_expr
*aexpr
)
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. */
130 gdb_unparse_agent_expr (struct agent_expr
*aexpr
)
134 rslt
= (char *) xmalloc (2 * aexpr
->length
+ 1);
135 bin2hex (aexpr
->bytes
, rslt
, aexpr
->length
);
139 /* Bytecode compilation. */
141 CORE_ADDR current_insn_ptr
;
145 struct bytecode_address
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
;
158 target_emit_ops ()->emit_prologue ();
164 target_emit_ops ()->emit_epilogue ();
170 target_emit_ops ()->emit_add ();
176 target_emit_ops ()->emit_sub ();
182 target_emit_ops ()->emit_mul ();
188 target_emit_ops ()->emit_lsh ();
192 emit_rsh_signed (void)
194 target_emit_ops ()->emit_rsh_signed ();
198 emit_rsh_unsigned (void)
200 target_emit_ops ()->emit_rsh_unsigned ();
206 target_emit_ops ()->emit_ext (arg
);
212 target_emit_ops ()->emit_log_not ();
218 target_emit_ops ()->emit_bit_and ();
224 target_emit_ops ()->emit_bit_or ();
230 target_emit_ops ()->emit_bit_xor ();
236 target_emit_ops ()->emit_bit_not ();
242 target_emit_ops ()->emit_equal ();
246 emit_less_signed (void)
248 target_emit_ops ()->emit_less_signed ();
252 emit_less_unsigned (void)
254 target_emit_ops ()->emit_less_unsigned ();
260 target_emit_ops ()->emit_ref (size
);
264 emit_if_goto (int *offset_p
, int *size_p
)
266 target_emit_ops ()->emit_if_goto (offset_p
, size_p
);
270 emit_goto (int *offset_p
, int *size_p
)
272 target_emit_ops ()->emit_goto (offset_p
, size_p
);
276 write_goto_address (CORE_ADDR from
, CORE_ADDR to
, int size
)
278 target_emit_ops ()->write_goto_address (from
, to
, size
);
282 emit_const (LONGEST num
)
284 target_emit_ops ()->emit_const (num
);
290 target_emit_ops ()->emit_reg (reg
);
296 target_emit_ops ()->emit_pop ();
300 emit_stack_flush (void)
302 target_emit_ops ()->emit_stack_flush ();
306 emit_zero_ext (int arg
)
308 target_emit_ops ()->emit_zero_ext (arg
);
314 target_emit_ops ()->emit_swap ();
318 emit_stack_adjust (int n
)
320 target_emit_ops ()->emit_stack_adjust (n
);
323 /* FN's prototype is `LONGEST(*fn)(int)'. */
326 emit_int_call_1 (CORE_ADDR fn
, int arg1
)
328 target_emit_ops ()->emit_int_call_1 (fn
, arg1
);
331 /* FN's prototype is `void(*fn)(int,LONGEST)'. */
334 emit_void_call_2 (CORE_ADDR fn
, int arg1
)
336 target_emit_ops ()->emit_void_call_2 (fn
, arg1
);
340 emit_eq_goto (int *offset_p
, int *size_p
)
342 target_emit_ops ()->emit_eq_goto (offset_p
, size_p
);
346 emit_ne_goto (int *offset_p
, int *size_p
)
348 target_emit_ops ()->emit_ne_goto (offset_p
, size_p
);
352 emit_lt_goto (int *offset_p
, int *size_p
)
354 target_emit_ops ()->emit_lt_goto (offset_p
, size_p
);
358 emit_ge_goto (int *offset_p
, int *size_p
)
360 target_emit_ops ()->emit_ge_goto (offset_p
, size_p
);
364 emit_gt_goto (int *offset_p
, int *size_p
)
366 target_emit_ops ()->emit_gt_goto (offset_p
, size_p
);
370 emit_le_goto (int *offset_p
, int *size_p
)
372 target_emit_ops ()->emit_le_goto (offset_p
, size_p
);
375 /* Scan an agent expression for any evidence that the given PC is the
376 target of a jump bytecode in the expression. */
379 is_goto_target (struct agent_expr
*aexpr
, int pc
)
384 for (i
= 0; i
< aexpr
->length
; i
+= 1 + gdb_agent_op_sizes
[op
])
386 op
= aexpr
->bytes
[i
];
388 if (op
== gdb_agent_op_goto
|| op
== gdb_agent_op_if_goto
)
390 int target
= (aexpr
->bytes
[i
+ 1] << 8) + aexpr
->bytes
[i
+ 2];
399 /* Given an agent expression, turn it into native code. */
401 enum eval_result_type
402 compile_bytecodes (struct agent_expr
*aexpr
)
406 unsigned char op
, next_op
;
408 /* This is only used to build 64-bit value for constants. */
410 struct bytecode_address
*aentry
, *aentry2
;
415 ax_debug ("Cannot compile op 0x%x\n", op); \
416 return expr_eval_unhandled_opcode; \
419 if (aexpr
->length
== 0)
421 ax_debug ("empty agent expression\n");
422 return expr_eval_empty_expression
;
425 bytecode_address_table
= NULL
;
429 op
= aexpr
->bytes
[pc
];
431 ax_debug ("About to compile op 0x%x, pc=%d\n", op
, pc
);
433 /* Record the compiled-code address of the bytecode, for use by
434 jump instructions. */
435 aentry
= XNEW (struct bytecode_address
);
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
;
449 case gdb_agent_op_add
:
453 case gdb_agent_op_sub
:
457 case gdb_agent_op_mul
:
461 case gdb_agent_op_div_signed
:
465 case gdb_agent_op_div_unsigned
:
469 case gdb_agent_op_rem_signed
:
473 case gdb_agent_op_rem_unsigned
:
477 case gdb_agent_op_lsh
:
481 case gdb_agent_op_rsh_signed
:
485 case gdb_agent_op_rsh_unsigned
:
486 emit_rsh_unsigned ();
489 case gdb_agent_op_trace
:
493 case gdb_agent_op_trace_quick
:
497 case gdb_agent_op_log_not
:
501 case gdb_agent_op_bit_and
:
505 case gdb_agent_op_bit_or
:
509 case gdb_agent_op_bit_xor
:
513 case gdb_agent_op_bit_not
:
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
)
523 ax_debug ("Combining equal & if_goto");
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
));
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
)
536 ax_debug ("Combining equal & log_not & if_goto");
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
));
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
))
553 ax_debug ("Combining less_signed & if_goto");
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
));
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))
566 ax_debug ("Combining less_signed & log_not & if_goto");
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
));
578 case gdb_agent_op_less_unsigned
:
579 emit_less_unsigned ();
582 case gdb_agent_op_ext
:
583 arg
= aexpr
->bytes
[pc
++];
584 if (arg
< (sizeof (LONGEST
) * 8))
588 case gdb_agent_op_ref8
:
592 case gdb_agent_op_ref16
:
596 case gdb_agent_op_ref32
:
600 case gdb_agent_op_ref64
:
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
));
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
));
618 case gdb_agent_op_const8
:
620 top
= aexpr
->bytes
[pc
++];
624 case gdb_agent_op_const16
:
626 top
= aexpr
->bytes
[pc
++];
627 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
631 case gdb_agent_op_const32
:
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
++];
640 case gdb_agent_op_const64
:
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
++];
653 case gdb_agent_op_reg
:
655 arg
= aexpr
->bytes
[pc
++];
656 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
660 case gdb_agent_op_end
:
661 ax_debug ("At end of expression\n");
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);
670 case gdb_agent_op_dup
:
671 /* In our design, dup is equivalent to stack flushing. */
675 case gdb_agent_op_pop
:
679 case gdb_agent_op_zero_ext
:
680 arg
= aexpr
->bytes
[pc
++];
681 if (arg
< (sizeof (LONGEST
) * 8))
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))
693 ax_debug ("Combining swap & less_signed & if_goto");
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
));
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))
708 ax_debug ("Combining swap & less_signed & log_not & if_goto");
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
));
720 case gdb_agent_op_getv
:
722 arg
= aexpr
->bytes
[pc
++];
723 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
724 emit_int_call_1 (get_get_tsv_func_addr (),
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 (),
735 case gdb_agent_op_tracev
:
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
:
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
;
756 /* This catches errors that occur in target-specific code
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
;
765 ax_debug ("Op %s compiled\n", gdb_agent_op_name (op
));
768 /* Now fill in real addresses as goto destinations. */
769 for (aentry
= bytecode_address_table
; aentry
; aentry
= aentry
->next
)
773 if (aentry
->goto_pc
< 0)
776 /* Find the location that we are going to, and call back into
777 target-specific code to write the actual address or
779 for (aentry2
= bytecode_address_table
; aentry2
; aentry2
= aentry2
->next
)
781 if (aentry2
->pc
== aentry
->goto_pc
)
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
);
793 /* Error out if we didn't find a destination. */
796 ax_debug ("Destination of goto %d not found\n",
798 return expr_eval_invalid_goto
;
802 return expr_eval_no_error
;
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
815 ax_printf (CORE_ADDR fn
, CORE_ADDR chan
, const char *format
,
816 int nargs
, ULONGEST
*args
)
818 const char *f
= format
;
819 struct format_piece
*fpieces
;
821 char *current_substring
;
824 ax_debug ("Printf of \"%s\" with %d args", format
, nargs
);
826 fpieces
= parse_format_string (&f
);
829 for (fp
= 0; fpieces
[fp
].string
!= NULL
; fp
++)
830 if (fpieces
[fp
].argclass
!= literal_piece
)
833 if (nargs
!= nargs_wanted
)
834 error (_("Wrong number of arguments for specified format-string"));
837 for (fp
= 0; fpieces
[fp
].string
!= NULL
; fp
++)
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
)
852 /* This is a %s argument. Find the length of the string. */
857 read_inferior_memory (tem
+ j
, &c
, 1);
862 /* Copy the string contents into a string inside GDB. */
863 str
= (gdb_byte
*) alloca (j
+ 1);
865 read_inferior_memory (tem
, str
, j
);
868 printf (current_substring
, (char *) str
);
873 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
875 long long val
= args
[i
];
877 printf (current_substring
, val
);
881 error (_("long long not supported in agent printf"));
887 printf (current_substring
, val
);
895 printf (current_substring
, val
);
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
908 printf (current_substring
, 0);
912 error (_("Format directive in '%s' not supported in agent printf"),
916 /* Maybe advance to the next argument. */
917 if (fpieces
[fp
].argclass
!= literal_piece
)
921 free_format_pieces (fpieces
);
925 /* The agent expression evaluator, as specified by the GDB docs. It
926 returns 0 if everything went OK, and a nonzero error code
929 enum eval_result_type
930 gdb_eval_agent_expr (struct eval_agent_expr_context
*ctx
,
931 struct agent_expr
*aexpr
,
935 #define STACK_MAX 100
936 ULONGEST stack
[STACK_MAX
], top
;
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. */
949 unsigned char bytes
[1];
954 unsigned char bytes
[2];
959 unsigned char bytes
[4];
964 unsigned char bytes
[8];
969 if (aexpr
->length
== 0)
971 ax_debug ("empty agent expression");
972 return expr_eval_empty_expression
;
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. */
982 op
= aexpr
->bytes
[pc
++];
984 ax_debug ("About to interpret byte 0x%x", op
);
988 case gdb_agent_op_add
:
992 case gdb_agent_op_sub
:
993 top
= stack
[--sp
] - top
;
996 case gdb_agent_op_mul
:
1000 case gdb_agent_op_div_signed
:
1003 ax_debug ("Attempted to divide by zero");
1004 return expr_eval_divide_by_zero
;
1006 top
= ((LONGEST
) stack
[--sp
]) / ((LONGEST
) top
);
1009 case gdb_agent_op_div_unsigned
:
1012 ax_debug ("Attempted to divide by zero");
1013 return expr_eval_divide_by_zero
;
1015 top
= stack
[--sp
] / top
;
1018 case gdb_agent_op_rem_signed
:
1021 ax_debug ("Attempted to divide by zero");
1022 return expr_eval_divide_by_zero
;
1024 top
= ((LONGEST
) stack
[--sp
]) % ((LONGEST
) top
);
1027 case gdb_agent_op_rem_unsigned
:
1030 ax_debug ("Attempted to divide by zero");
1031 return expr_eval_divide_by_zero
;
1033 top
= stack
[--sp
] % top
;
1036 case gdb_agent_op_lsh
:
1037 top
= stack
[--sp
] << top
;
1040 case gdb_agent_op_rsh_signed
:
1041 top
= ((LONGEST
) stack
[--sp
]) >> top
;
1044 case gdb_agent_op_rsh_unsigned
:
1045 top
= stack
[--sp
] >> top
;
1048 case gdb_agent_op_trace
:
1049 agent_mem_read (ctx
, NULL
, (CORE_ADDR
) stack
[--sp
],
1055 case gdb_agent_op_trace_quick
:
1056 arg
= aexpr
->bytes
[pc
++];
1057 agent_mem_read (ctx
, NULL
, (CORE_ADDR
) top
, (ULONGEST
) arg
);
1060 case gdb_agent_op_log_not
:
1064 case gdb_agent_op_bit_and
:
1068 case gdb_agent_op_bit_or
:
1072 case gdb_agent_op_bit_xor
:
1076 case gdb_agent_op_bit_not
:
1080 case gdb_agent_op_equal
:
1081 top
= (stack
[--sp
] == top
);
1084 case gdb_agent_op_less_signed
:
1085 top
= (((LONGEST
) stack
[--sp
]) < ((LONGEST
) top
));
1088 case gdb_agent_op_less_unsigned
:
1089 top
= (stack
[--sp
] < top
);
1092 case gdb_agent_op_ext
:
1093 arg
= aexpr
->bytes
[pc
++];
1094 if (arg
< (sizeof (LONGEST
) * 8))
1096 LONGEST mask
= 1 << (arg
- 1);
1097 top
&= ((LONGEST
) 1 << arg
) - 1;
1098 top
= (top
^ mask
) - mask
;
1102 case gdb_agent_op_ref8
:
1103 agent_mem_read (ctx
, cnv
.u8
.bytes
, (CORE_ADDR
) top
, 1);
1107 case gdb_agent_op_ref16
:
1108 agent_mem_read (ctx
, cnv
.u16
.bytes
, (CORE_ADDR
) top
, 2);
1112 case gdb_agent_op_ref32
:
1113 agent_mem_read (ctx
, cnv
.u32
.bytes
, (CORE_ADDR
) top
, 4);
1117 case gdb_agent_op_ref64
:
1118 agent_mem_read (ctx
, cnv
.u64
.bytes
, (CORE_ADDR
) top
, 8);
1122 case gdb_agent_op_if_goto
:
1124 pc
= (aexpr
->bytes
[pc
] << 8) + (aexpr
->bytes
[pc
+ 1]);
1131 case gdb_agent_op_goto
:
1132 pc
= (aexpr
->bytes
[pc
] << 8) + (aexpr
->bytes
[pc
+ 1]);
1135 case gdb_agent_op_const8
:
1136 /* Flush the cached stack top. */
1138 top
= aexpr
->bytes
[pc
++];
1141 case gdb_agent_op_const16
:
1142 /* Flush the cached stack top. */
1144 top
= aexpr
->bytes
[pc
++];
1145 top
= (top
<< 8) + aexpr
->bytes
[pc
++];
1148 case gdb_agent_op_const32
:
1149 /* Flush the cached stack 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
++];
1157 case gdb_agent_op_const64
:
1158 /* Flush the cached stack 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
++];
1170 case gdb_agent_op_reg
:
1171 /* Flush the cached stack top. */
1173 arg
= aexpr
->bytes
[pc
++];
1174 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
1177 struct regcache
*regcache
= ctx
->regcache
;
1179 switch (register_size (regcache
->tdesc
, regnum
))
1182 collect_register (regcache
, regnum
, cnv
.u64
.bytes
);
1186 collect_register (regcache
, regnum
, cnv
.u32
.bytes
);
1190 collect_register (regcache
, regnum
, cnv
.u16
.bytes
);
1194 collect_register (regcache
, regnum
, cnv
.u8
.bytes
);
1198 internal_error (__FILE__
, __LINE__
,
1199 "unhandled register size");
1204 case gdb_agent_op_end
:
1205 ax_debug ("At end of expression, sp=%d, stack top cache=0x%s",
1206 sp
, pulongest (top
));
1211 /* This should be an error */
1212 ax_debug ("Stack is empty, nothing to return");
1213 return expr_eval_empty_stack
;
1217 return expr_eval_no_error
;
1219 case gdb_agent_op_dup
:
1223 case gdb_agent_op_pop
:
1228 case gdb_agent_op_pick
:
1229 arg
= aexpr
->bytes
[pc
++];
1231 top
= stack
[sp
- arg
];
1235 case gdb_agent_op_rot
:
1237 ULONGEST tem
= stack
[sp
- 1];
1239 stack
[sp
- 1] = stack
[sp
- 2];
1240 stack
[sp
- 2] = top
;
1245 case gdb_agent_op_zero_ext
:
1246 arg
= aexpr
->bytes
[pc
++];
1247 if (arg
< (sizeof (LONGEST
) * 8))
1248 top
&= ((LONGEST
) 1 << arg
) - 1;
1251 case gdb_agent_op_swap
:
1252 /* Interchange top two stack elements, making sure top gets
1253 copied back onto stack. */
1255 top
= stack
[sp
- 1];
1256 stack
[sp
- 1] = stack
[sp
];
1259 case gdb_agent_op_getv
:
1260 /* Flush the cached stack top. */
1262 arg
= aexpr
->bytes
[pc
++];
1263 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
1264 top
= agent_get_trace_state_variable_value (arg
);
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. */
1275 case gdb_agent_op_tracev
:
1276 arg
= aexpr
->bytes
[pc
++];
1277 arg
= (arg
<< 8) + aexpr
->bytes
[pc
++];
1278 agent_tsv_read (ctx
, arg
);
1281 case gdb_agent_op_tracenz
:
1282 agent_mem_read_string (ctx
, NULL
, (CORE_ADDR
) stack
[--sp
],
1288 case gdb_agent_op_printf
:
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
];
1296 nargs
= aexpr
->bytes
[pc
++];
1297 slen
= aexpr
->bytes
[pc
++];
1298 slen
= (slen
<< 8) + aexpr
->bytes
[pc
++];
1299 format
= (char *) &(aexpr
->bytes
[pc
]);
1301 /* Pop function and channel. */
1308 /* Pop arguments into a dedicated array. */
1309 for (i
= 0; i
< nargs
; ++i
)
1316 /* A bad format string means something is very wrong; give
1318 if (format
[slen
- 1] != '\0')
1319 error (_("Unterminated format string in printf bytecode"));
1321 ax_printf (fn
, chan
, format
, nargs
, args
);
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",
1335 /* If ever GDB generates any of these, we don't have the
1336 option of ignoring. */
1337 return expr_eval_unhandled_opcode
;
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
;
1345 /* Check for stack badness. */
1346 if (sp
>= (STACK_MAX
- 1))
1348 ax_debug ("Expression stack overflow");
1349 return expr_eval_stack_overflow
;
1354 ax_debug ("Expression stack underflow");
1355 return expr_eval_stack_underflow
;
1358 ax_debug ("Op %s -> sp=%d, top=0x%s",
1359 gdb_agent_op_name (op
), sp
, phex_nz (top
, 0));