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