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