GDB (xrefs)
/tmp/gdb-7.10/gdb/expprint.c
Go to the documentation of this file.
1 /* Print in infix form a struct expression.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "expression.h"
24 #include "value.h"
25 #include "language.h"
26 #include "parser-defs.h"
27 #include "user-regs.h" /* For user_reg_map_regnum_to_name. */
28 #include "target.h"
29 #include "block.h"
30 #include "objfiles.h"
31 #include "valprint.h"
32 
33 #include <ctype.h>
34 
35 void
36 print_expression (struct expression *exp, struct ui_file *stream)
37 {
38  int pc = 0;
39 
40  print_subexp (exp, &pc, stream, PREC_NULL);
41 }
42 
43 /* Print the subexpression of EXP that starts in position POS, on STREAM.
44  PREC is the precedence of the surrounding operator;
45  if the precedence of the main operator of this subexpression is less,
46  parentheses are needed here. */
47 
48 void
49 print_subexp (struct expression *exp, int *pos,
50  struct ui_file *stream, enum precedence prec)
51 {
52  exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
53 }
54 
55 /* Standard implementation of print_subexp for use in language_defn
56  vectors. */
57 void
58 print_subexp_standard (struct expression *exp, int *pos,
59  struct ui_file *stream, enum precedence prec)
60 {
61  unsigned tem;
62  const struct op_print *op_print_tab;
63  int pc;
64  unsigned nargs;
65  char *op_str;
66  int assign_modify = 0;
67  enum exp_opcode opcode;
68  enum precedence myprec = PREC_NULL;
69  /* Set to 1 for a right-associative operator. */
70  int assoc = 0;
71  struct value *val;
72  char *tempstr = NULL;
73 
74  op_print_tab = exp->language_defn->la_op_print_tab;
75  pc = (*pos)++;
76  opcode = exp->elts[pc].opcode;
77  switch (opcode)
78  {
79  /* Common ops */
80 
81  case OP_TYPE:
82  (*pos) += 2;
83  type_print (exp->elts[pc + 1].type, "", stream, 0);
84  return;
85 
86  case OP_SCOPE:
87  myprec = PREC_PREFIX;
88  assoc = 0;
89  fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
90  fputs_filtered ("::", stream);
91  nargs = longest_to_int (exp->elts[pc + 2].longconst);
92  (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
93  fputs_filtered (&exp->elts[pc + 3].string, stream);
94  return;
95 
96  case OP_LONG:
97  {
98  struct value_print_options opts;
99 
101  (*pos) += 3;
102  value_print (value_from_longest (exp->elts[pc + 1].type,
103  exp->elts[pc + 2].longconst),
104  stream, &opts);
105  }
106  return;
107 
108  case OP_DOUBLE:
109  {
110  struct value_print_options opts;
111 
113  (*pos) += 3;
114  value_print (value_from_double (exp->elts[pc + 1].type,
115  exp->elts[pc + 2].doubleconst),
116  stream, &opts);
117  }
118  return;
119 
120  case OP_VAR_VALUE:
121  {
122  const struct block *b;
123 
124  (*pos) += 3;
125  b = exp->elts[pc + 1].block;
126  if (b != NULL
127  && BLOCK_FUNCTION (b) != NULL
128  && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
129  {
131  fputs_filtered ("::", stream);
132  }
133  fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
134  }
135  return;
136 
137  case OP_VAR_ENTRY_VALUE:
138  {
139  (*pos) += 2;
140  fprintf_filtered (stream, "%s@entry",
141  SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
142  }
143  return;
144 
145  case OP_LAST:
146  (*pos) += 2;
147  fprintf_filtered (stream, "$%d",
148  longest_to_int (exp->elts[pc + 1].longconst));
149  return;
150 
151  case OP_REGISTER:
152  {
153  const char *name = &exp->elts[pc + 2].string;
154 
155  (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
156  fprintf_filtered (stream, "$%s", name);
157  return;
158  }
159 
160  case OP_BOOL:
161  (*pos) += 2;
162  fprintf_filtered (stream, "%s",
163  longest_to_int (exp->elts[pc + 1].longconst)
164  ? "TRUE" : "FALSE");
165  return;
166 
167  case OP_INTERNALVAR:
168  (*pos) += 2;
169  fprintf_filtered (stream, "$%s",
170  internalvar_name (exp->elts[pc + 1].internalvar));
171  return;
172 
173  case OP_FUNCALL:
174  (*pos) += 2;
175  nargs = longest_to_int (exp->elts[pc + 1].longconst);
176  print_subexp (exp, pos, stream, PREC_SUFFIX);
177  fputs_filtered (" (", stream);
178  for (tem = 0; tem < nargs; tem++)
179  {
180  if (tem != 0)
181  fputs_filtered (", ", stream);
182  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
183  }
184  fputs_filtered (")", stream);
185  return;
186 
187  case OP_NAME:
188  nargs = longest_to_int (exp->elts[pc + 1].longconst);
189  (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
190  fputs_filtered (&exp->elts[pc + 2].string, stream);
191  return;
192 
193  case OP_STRING:
194  {
195  struct value_print_options opts;
196 
197  nargs = longest_to_int (exp->elts[pc + 1].longconst);
198  (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
199  /* LA_PRINT_STRING will print using the current repeat count threshold.
200  If necessary, we can temporarily set it to zero, or pass it as an
201  additional parameter to LA_PRINT_STRING. -fnf */
202  get_user_print_options (&opts);
204  (gdb_byte *) &exp->elts[pc + 2].string, nargs,
205  NULL, 0, &opts);
206  }
207  return;
208 
209  case OP_OBJC_NSSTRING: /* Objective-C Foundation Class
210  NSString constant. */
211  {
212  struct value_print_options opts;
213 
214  nargs = longest_to_int (exp->elts[pc + 1].longconst);
215  (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
216  fputs_filtered ("@\"", stream);
217  get_user_print_options (&opts);
219  (gdb_byte *) &exp->elts[pc + 2].string, nargs,
220  NULL, 0, &opts);
221  fputs_filtered ("\"", stream);
222  }
223  return;
224 
225  case OP_OBJC_MSGCALL:
226  { /* Objective C message (method) call. */
227  char *selector;
228 
229  (*pos) += 3;
230  nargs = longest_to_int (exp->elts[pc + 2].longconst);
231  fprintf_unfiltered (stream, "[");
232  print_subexp (exp, pos, stream, PREC_SUFFIX);
233  if (0 == target_read_string (exp->elts[pc + 1].longconst,
234  &selector, 1024, NULL))
235  {
236  error (_("bad selector"));
237  return;
238  }
239  if (nargs)
240  {
241  char *s, *nextS;
242 
243  s = alloca (strlen (selector) + 1);
244  strcpy (s, selector);
245  for (tem = 0; tem < nargs; tem++)
246  {
247  nextS = strchr (s, ':');
248  gdb_assert (nextS); /* Make sure we found ':'. */
249  *nextS = '\0';
250  fprintf_unfiltered (stream, " %s: ", s);
251  s = nextS + 1;
252  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
253  }
254  }
255  else
256  {
257  fprintf_unfiltered (stream, " %s", selector);
258  }
259  fprintf_unfiltered (stream, "]");
260  /* "selector" was malloc'd by target_read_string. Free it. */
261  xfree (selector);
262  return;
263  }
264 
265  case OP_ARRAY:
266  (*pos) += 3;
267  nargs = longest_to_int (exp->elts[pc + 2].longconst);
268  nargs -= longest_to_int (exp->elts[pc + 1].longconst);
269  nargs++;
270  tem = 0;
271  if (exp->elts[pc + 4].opcode == OP_LONG
272  && exp->elts[pc + 5].type
275  {
276  /* Attempt to print C character arrays using string syntax.
277  Walk through the args, picking up one character from each
278  of the OP_LONG expression elements. If any array element
279  does not match our expection of what we should find for
280  a simple string, revert back to array printing. Note that
281  the last expression element is an explicit null terminator
282  byte, which doesn't get printed. */
283  tempstr = alloca (nargs);
284  pc += 4;
285  while (tem < nargs)
286  {
287  if (exp->elts[pc].opcode != OP_LONG
288  || exp->elts[pc + 1].type
289  != builtin_type (exp->gdbarch)->builtin_char)
290  {
291  /* Not a simple array of char, use regular array
292  printing. */
293  tem = 0;
294  break;
295  }
296  else
297  {
298  tempstr[tem++] =
299  longest_to_int (exp->elts[pc + 2].longconst);
300  pc += 4;
301  }
302  }
303  }
304  if (tem > 0)
305  {
306  struct value_print_options opts;
307 
308  get_user_print_options (&opts);
310  (gdb_byte *) tempstr, nargs - 1, NULL, 0, &opts);
311  (*pos) = pc;
312  }
313  else
314  {
315  fputs_filtered (" {", stream);
316  for (tem = 0; tem < nargs; tem++)
317  {
318  if (tem != 0)
319  {
320  fputs_filtered (", ", stream);
321  }
322  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
323  }
324  fputs_filtered ("}", stream);
325  }
326  return;
327 
328  case TERNOP_COND:
329  if ((int) prec > (int) PREC_COMMA)
330  fputs_filtered ("(", stream);
331  /* Print the subexpressions, forcing parentheses
332  around any binary operations within them.
333  This is more parentheses than are strictly necessary,
334  but it looks clearer. */
335  print_subexp (exp, pos, stream, PREC_HYPER);
336  fputs_filtered (" ? ", stream);
337  print_subexp (exp, pos, stream, PREC_HYPER);
338  fputs_filtered (" : ", stream);
339  print_subexp (exp, pos, stream, PREC_HYPER);
340  if ((int) prec > (int) PREC_COMMA)
341  fputs_filtered (")", stream);
342  return;
343 
344  case TERNOP_SLICE:
345  print_subexp (exp, pos, stream, PREC_SUFFIX);
346  fputs_filtered ("(", stream);
347  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
348  fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
349  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
350  fputs_filtered (")", stream);
351  return;
352 
353  case STRUCTOP_STRUCT:
354  tem = longest_to_int (exp->elts[pc + 1].longconst);
355  (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
356  print_subexp (exp, pos, stream, PREC_SUFFIX);
357  fputs_filtered (".", stream);
358  fputs_filtered (&exp->elts[pc + 2].string, stream);
359  return;
360 
361  /* Will not occur for Modula-2. */
362  case STRUCTOP_PTR:
363  tem = longest_to_int (exp->elts[pc + 1].longconst);
364  (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
365  print_subexp (exp, pos, stream, PREC_SUFFIX);
366  fputs_filtered ("->", stream);
367  fputs_filtered (&exp->elts[pc + 2].string, stream);
368  return;
369 
370  case STRUCTOP_MEMBER:
371  print_subexp (exp, pos, stream, PREC_SUFFIX);
372  fputs_filtered (".*", stream);
373  print_subexp (exp, pos, stream, PREC_SUFFIX);
374  return;
375 
376  case STRUCTOP_MPTR:
377  print_subexp (exp, pos, stream, PREC_SUFFIX);
378  fputs_filtered ("->*", stream);
379  print_subexp (exp, pos, stream, PREC_SUFFIX);
380  return;
381 
382  case BINOP_SUBSCRIPT:
383  print_subexp (exp, pos, stream, PREC_SUFFIX);
384  fputs_filtered ("[", stream);
385  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
386  fputs_filtered ("]", stream);
387  return;
388 
389  case UNOP_POSTINCREMENT:
390  print_subexp (exp, pos, stream, PREC_SUFFIX);
391  fputs_filtered ("++", stream);
392  return;
393 
394  case UNOP_POSTDECREMENT:
395  print_subexp (exp, pos, stream, PREC_SUFFIX);
396  fputs_filtered ("--", stream);
397  return;
398 
399  case UNOP_CAST:
400  (*pos) += 2;
401  if ((int) prec > (int) PREC_PREFIX)
402  fputs_filtered ("(", stream);
403  fputs_filtered ("(", stream);
404  type_print (exp->elts[pc + 1].type, "", stream, 0);
405  fputs_filtered (") ", stream);
406  print_subexp (exp, pos, stream, PREC_PREFIX);
407  if ((int) prec > (int) PREC_PREFIX)
408  fputs_filtered (")", stream);
409  return;
410 
411  case UNOP_CAST_TYPE:
412  if ((int) prec > (int) PREC_PREFIX)
413  fputs_filtered ("(", stream);
414  fputs_filtered ("(", stream);
415  print_subexp (exp, pos, stream, PREC_PREFIX);
416  fputs_filtered (") ", stream);
417  print_subexp (exp, pos, stream, PREC_PREFIX);
418  if ((int) prec > (int) PREC_PREFIX)
419  fputs_filtered (")", stream);
420  return;
421 
422  case UNOP_DYNAMIC_CAST:
423  case UNOP_REINTERPRET_CAST:
424  fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast"
425  : "reinterpret_cast", stream);
426  fputs_filtered ("<", stream);
427  print_subexp (exp, pos, stream, PREC_PREFIX);
428  fputs_filtered ("> (", stream);
429  print_subexp (exp, pos, stream, PREC_PREFIX);
430  fputs_filtered (")", stream);
431  return;
432 
433  case UNOP_MEMVAL:
434  (*pos) += 2;
435  if ((int) prec > (int) PREC_PREFIX)
436  fputs_filtered ("(", stream);
437  if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC
438  && exp->elts[pc + 3].opcode == OP_LONG)
439  {
440  struct value_print_options opts;
441 
442  /* We have a minimal symbol fn, probably. It's encoded
443  as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
444  Swallow the OP_LONG (including both its opcodes); ignore
445  its type; print the value in the type of the MEMVAL. */
446  (*pos) += 4;
447  val = value_at_lazy (exp->elts[pc + 1].type,
448  (CORE_ADDR) exp->elts[pc + 5].longconst);
450  value_print (val, stream, &opts);
451  }
452  else
453  {
454  fputs_filtered ("{", stream);
455  type_print (exp->elts[pc + 1].type, "", stream, 0);
456  fputs_filtered ("} ", stream);
457  print_subexp (exp, pos, stream, PREC_PREFIX);
458  }
459  if ((int) prec > (int) PREC_PREFIX)
460  fputs_filtered (")", stream);
461  return;
462 
463  case UNOP_MEMVAL_TYPE:
464  if ((int) prec > (int) PREC_PREFIX)
465  fputs_filtered ("(", stream);
466  fputs_filtered ("{", stream);
467  print_subexp (exp, pos, stream, PREC_PREFIX);
468  fputs_filtered ("} ", stream);
469  print_subexp (exp, pos, stream, PREC_PREFIX);
470  if ((int) prec > (int) PREC_PREFIX)
471  fputs_filtered (")", stream);
472  return;
473 
474  case UNOP_MEMVAL_TLS:
475  (*pos) += 3;
476  if ((int) prec > (int) PREC_PREFIX)
477  fputs_filtered ("(", stream);
478  fputs_filtered ("{", stream);
479  type_print (exp->elts[pc + 2].type, "", stream, 0);
480  fputs_filtered ("} ", stream);
481  print_subexp (exp, pos, stream, PREC_PREFIX);
482  if ((int) prec > (int) PREC_PREFIX)
483  fputs_filtered (")", stream);
484  return;
485 
486  case BINOP_ASSIGN_MODIFY:
487  opcode = exp->elts[pc + 1].opcode;
488  (*pos) += 2;
489  myprec = PREC_ASSIGN;
490  assoc = 1;
491  assign_modify = 1;
492  op_str = "???";
493  for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
494  if (op_print_tab[tem].opcode == opcode)
495  {
496  op_str = op_print_tab[tem].string;
497  break;
498  }
499  if (op_print_tab[tem].opcode != opcode)
500  /* Not found; don't try to keep going because we don't know how
501  to interpret further elements. */
502  error (_("Invalid expression"));
503  break;
504 
505  /* C++ ops */
506 
507  case OP_THIS:
508  ++(*pos);
509  if (exp->language_defn->la_name_of_this)
511  else
512  fprintf_filtered (stream, _("<language %s has no 'this'>"),
513  exp->language_defn->la_name);
514  return;
515 
516  /* Modula-2 ops */
517 
518  case MULTI_SUBSCRIPT:
519  (*pos) += 2;
520  nargs = longest_to_int (exp->elts[pc + 1].longconst);
521  print_subexp (exp, pos, stream, PREC_SUFFIX);
522  fprintf_unfiltered (stream, " [");
523  for (tem = 0; tem < nargs; tem++)
524  {
525  if (tem != 0)
526  fprintf_unfiltered (stream, ", ");
527  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
528  }
529  fprintf_unfiltered (stream, "]");
530  return;
531 
532  case BINOP_VAL:
533  (*pos) += 2;
534  fprintf_unfiltered (stream, "VAL(");
535  type_print (exp->elts[pc + 1].type, "", stream, 0);
536  fprintf_unfiltered (stream, ",");
537  print_subexp (exp, pos, stream, PREC_PREFIX);
538  fprintf_unfiltered (stream, ")");
539  return;
540 
541  case TYPE_INSTANCE:
542  {
543  LONGEST count = exp->elts[pc + 1].longconst;
544 
545  /* The COUNT. */
546  (*pos)++;
547  fputs_unfiltered ("TypesInstance(", stream);
548  while (count-- > 0)
549  {
550  type_print (exp->elts[(*pos)++].type, "", stream, 0);
551  if (count > 0)
552  fputs_unfiltered (",", stream);
553  }
554  fputs_unfiltered (",", stream);
555  /* Ending COUNT and ending TYPE_INSTANCE. */
556  (*pos) += 2;
557  print_subexp (exp, pos, stream, PREC_PREFIX);
558  fputs_unfiltered (")", stream);
559  return;
560  }
561 
562  /* Default ops */
563 
564  default:
565  op_str = "???";
566  for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
567  if (op_print_tab[tem].opcode == opcode)
568  {
569  op_str = op_print_tab[tem].string;
570  myprec = op_print_tab[tem].precedence;
571  assoc = op_print_tab[tem].right_assoc;
572  break;
573  }
574  if (op_print_tab[tem].opcode != opcode)
575  /* Not found; don't try to keep going because we don't know how
576  to interpret further elements. For example, this happens
577  if opcode is OP_TYPE. */
578  error (_("Invalid expression"));
579  }
580 
581  /* Note that PREC_BUILTIN will always emit parentheses. */
582  if ((int) myprec < (int) prec)
583  fputs_filtered ("(", stream);
584  if ((int) opcode > (int) BINOP_END)
585  {
586  if (assoc)
587  {
588  /* Unary postfix operator. */
589  print_subexp (exp, pos, stream, PREC_SUFFIX);
590  fputs_filtered (op_str, stream);
591  }
592  else
593  {
594  /* Unary prefix operator. */
595  fputs_filtered (op_str, stream);
596  if (myprec == PREC_BUILTIN_FUNCTION)
597  fputs_filtered ("(", stream);
598  print_subexp (exp, pos, stream, PREC_PREFIX);
599  if (myprec == PREC_BUILTIN_FUNCTION)
600  fputs_filtered (")", stream);
601  }
602  }
603  else
604  {
605  /* Binary operator. */
606  /* Print left operand.
607  If operator is right-associative,
608  increment precedence for this operand. */
609  print_subexp (exp, pos, stream,
610  (enum precedence) ((int) myprec + assoc));
611  /* Print the operator itself. */
612  if (assign_modify)
613  fprintf_filtered (stream, " %s= ", op_str);
614  else if (op_str[0] == ',')
615  fprintf_filtered (stream, "%s ", op_str);
616  else
617  fprintf_filtered (stream, " %s ", op_str);
618  /* Print right operand.
619  If operator is left-associative,
620  increment precedence for this operand. */
621  print_subexp (exp, pos, stream,
622  (enum precedence) ((int) myprec + !assoc));
623  }
624 
625  if ((int) myprec < (int) prec)
626  fputs_filtered (")", stream);
627 }
628 
629 /* Return the operator corresponding to opcode OP as
630  a string. NULL indicates that the opcode was not found in the
631  current language table. */
632 char *
634 {
635  int tem;
636  const struct op_print *op_print_tab;
637 
638  op_print_tab = current_language->la_op_print_tab;
639  for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
640  if (op_print_tab[tem].opcode == op)
641  return op_print_tab[tem].string;
642  return NULL;
643 }
644 
645 /* Support for dumping the raw data from expressions in a human readable
646  form. */
647 
648 static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
649 
650 /* Name for OPCODE, when it appears in expression EXP. */
651 
652 char *
653 op_name (struct expression *exp, enum exp_opcode opcode)
654 {
655  return exp->language_defn->la_exp_desc->op_name (opcode);
656 }
657 
658 /* Default name for the standard operator OPCODE (i.e., one defined in
659  the definition of enum exp_opcode). */
660 
661 char *
663 {
664  switch (opcode)
665  {
666  default:
667  {
668  static char buf[30];
669 
670  xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode);
671  return buf;
672  }
673 #define OP(name) \
674  case name: \
675  return #name ;
676 #include "std-operator.def"
677 #undef OP
678  }
679 }
680 
681 /* Print a raw dump of expression EXP to STREAM.
682  NOTE, if non-NULL, is printed as extra explanatory text. */
683 
684 void
685 dump_raw_expression (struct expression *exp, struct ui_file *stream,
686  char *note)
687 {
688  int elt;
689  char *opcode_name;
690  char *eltscan;
691  int eltsize;
692 
693  fprintf_filtered (stream, "Dump of expression @ ");
694  gdb_print_host_address (exp, stream);
695  if (note)
696  fprintf_filtered (stream, ", %s:", note);
697  fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
698  exp->language_defn->la_name, exp->nelts,
699  (long) sizeof (union exp_element));
700  fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
701  "Hex Value", "String Value");
702  for (elt = 0; elt < exp->nelts; elt++)
703  {
704  fprintf_filtered (stream, "\t%5d ", elt);
705  opcode_name = op_name (exp, exp->elts[elt].opcode);
706 
707  fprintf_filtered (stream, "%20s ", opcode_name);
708  print_longest (stream, 'd', 0, exp->elts[elt].longconst);
709  fprintf_filtered (stream, " ");
710 
711  for (eltscan = (char *) &exp->elts[elt],
712  eltsize = sizeof (union exp_element);
713  eltsize-- > 0;
714  eltscan++)
715  {
716  fprintf_filtered (stream, "%c",
717  isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
718  }
719  fprintf_filtered (stream, "\n");
720  }
721 }
722 
723 /* Dump the subexpression of prefix expression EXP whose operator is at
724  position ELT onto STREAM. Returns the position of the next
725  subexpression in EXP. */
726 
727 int
728 dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
729 {
730  static int indent = 0;
731  int i;
732 
733  fprintf_filtered (stream, "\n");
734  fprintf_filtered (stream, "\t%5d ", elt);
735 
736  for (i = 1; i <= indent; i++)
737  fprintf_filtered (stream, " ");
738  indent += 2;
739 
740  fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode));
741 
742  elt = dump_subexp_body (exp, stream, elt);
743 
744  indent -= 2;
745 
746  return elt;
747 }
748 
749 /* Dump the operands of prefix expression EXP whose opcode is at
750  position ELT onto STREAM. Returns the position of the next
751  subexpression in EXP. */
752 
753 static int
754 dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
755 {
756  return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
757 }
758 
759 /* Default value for subexp_body in exp_descriptor vector. */
760 
761 int
763  struct ui_file *stream, int elt)
764 {
765  int opcode = exp->elts[elt++].opcode;
766 
767  switch (opcode)
768  {
769  case TERNOP_COND:
770  case TERNOP_SLICE:
771  elt = dump_subexp (exp, stream, elt);
772  /* FALL THROUGH */
773  case BINOP_ADD:
774  case BINOP_SUB:
775  case BINOP_MUL:
776  case BINOP_DIV:
777  case BINOP_REM:
778  case BINOP_MOD:
779  case BINOP_LSH:
780  case BINOP_RSH:
781  case BINOP_LOGICAL_AND:
782  case BINOP_LOGICAL_OR:
783  case BINOP_BITWISE_AND:
784  case BINOP_BITWISE_IOR:
785  case BINOP_BITWISE_XOR:
786  case BINOP_EQUAL:
787  case BINOP_NOTEQUAL:
788  case BINOP_LESS:
789  case BINOP_GTR:
790  case BINOP_LEQ:
791  case BINOP_GEQ:
792  case BINOP_REPEAT:
793  case BINOP_ASSIGN:
794  case BINOP_COMMA:
795  case BINOP_SUBSCRIPT:
796  case BINOP_EXP:
797  case BINOP_MIN:
798  case BINOP_MAX:
799  case BINOP_INTDIV:
800  case BINOP_ASSIGN_MODIFY:
801  case BINOP_VAL:
802  case BINOP_CONCAT:
803  case BINOP_END:
804  case STRUCTOP_MEMBER:
805  case STRUCTOP_MPTR:
806  elt = dump_subexp (exp, stream, elt);
807  /* FALL THROUGH */
808  case UNOP_NEG:
809  case UNOP_LOGICAL_NOT:
810  case UNOP_COMPLEMENT:
811  case UNOP_IND:
812  case UNOP_ADDR:
813  case UNOP_PREINCREMENT:
814  case UNOP_POSTINCREMENT:
815  case UNOP_PREDECREMENT:
816  case UNOP_POSTDECREMENT:
817  case UNOP_SIZEOF:
818  case UNOP_PLUS:
819  case UNOP_CAP:
820  case UNOP_CHR:
821  case UNOP_ORD:
822  case UNOP_ABS:
823  case UNOP_FLOAT:
824  case UNOP_HIGH:
825  case UNOP_MAX:
826  case UNOP_MIN:
827  case UNOP_ODD:
828  case UNOP_TRUNC:
829  elt = dump_subexp (exp, stream, elt);
830  break;
831  case OP_LONG:
832  fprintf_filtered (stream, "Type @");
833  gdb_print_host_address (exp->elts[elt].type, stream);
834  fprintf_filtered (stream, " (");
835  type_print (exp->elts[elt].type, NULL, stream, 0);
836  fprintf_filtered (stream, "), value %ld (0x%lx)",
837  (long) exp->elts[elt + 1].longconst,
838  (long) exp->elts[elt + 1].longconst);
839  elt += 3;
840  break;
841  case OP_DOUBLE:
842  fprintf_filtered (stream, "Type @");
843  gdb_print_host_address (exp->elts[elt].type, stream);
844  fprintf_filtered (stream, " (");
845  type_print (exp->elts[elt].type, NULL, stream, 0);
846  fprintf_filtered (stream, "), value %g",
847  (double) exp->elts[elt + 1].doubleconst);
848  elt += 3;
849  break;
850  case OP_VAR_VALUE:
851  fprintf_filtered (stream, "Block @");
852  gdb_print_host_address (exp->elts[elt].block, stream);
853  fprintf_filtered (stream, ", symbol @");
854  gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
855  fprintf_filtered (stream, " (%s)",
856  SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
857  elt += 3;
858  break;
859  case OP_VAR_ENTRY_VALUE:
860  fprintf_filtered (stream, "Entry value of symbol @");
861  gdb_print_host_address (exp->elts[elt].symbol, stream);
862  fprintf_filtered (stream, " (%s)",
863  SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
864  elt += 2;
865  break;
866  case OP_LAST:
867  fprintf_filtered (stream, "History element %ld",
868  (long) exp->elts[elt].longconst);
869  elt += 2;
870  break;
871  case OP_REGISTER:
872  fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
873  elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
874  break;
875  case OP_INTERNALVAR:
876  fprintf_filtered (stream, "Internal var @");
877  gdb_print_host_address (exp->elts[elt].internalvar, stream);
878  fprintf_filtered (stream, " (%s)",
879  internalvar_name (exp->elts[elt].internalvar));
880  elt += 2;
881  break;
882  case OP_FUNCALL:
883  {
884  int i, nargs;
885 
886  nargs = longest_to_int (exp->elts[elt].longconst);
887 
888  fprintf_filtered (stream, "Number of args: %d", nargs);
889  elt += 2;
890 
891  for (i = 1; i <= nargs + 1; i++)
892  elt = dump_subexp (exp, stream, elt);
893  }
894  break;
895  case OP_ARRAY:
896  {
897  int lower, upper;
898  int i;
899 
900  lower = longest_to_int (exp->elts[elt].longconst);
901  upper = longest_to_int (exp->elts[elt + 1].longconst);
902 
903  fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
904  elt += 3;
905 
906  for (i = 1; i <= upper - lower + 1; i++)
907  elt = dump_subexp (exp, stream, elt);
908  }
909  break;
910  case UNOP_DYNAMIC_CAST:
911  case UNOP_REINTERPRET_CAST:
912  case UNOP_CAST_TYPE:
913  case UNOP_MEMVAL_TYPE:
914  fprintf_filtered (stream, " (");
915  elt = dump_subexp (exp, stream, elt);
916  fprintf_filtered (stream, ")");
917  elt = dump_subexp (exp, stream, elt);
918  break;
919  case UNOP_MEMVAL:
920  case UNOP_CAST:
921  fprintf_filtered (stream, "Type @");
922  gdb_print_host_address (exp->elts[elt].type, stream);
923  fprintf_filtered (stream, " (");
924  type_print (exp->elts[elt].type, NULL, stream, 0);
925  fprintf_filtered (stream, ")");
926  elt = dump_subexp (exp, stream, elt + 2);
927  break;
928  case UNOP_MEMVAL_TLS:
929  fprintf_filtered (stream, "TLS type @");
930  gdb_print_host_address (exp->elts[elt + 1].type, stream);
931  fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
932  (exp->elts[elt].objfile == NULL ? "(null)"
933  : objfile_name (exp->elts[elt].objfile)));
934  type_print (exp->elts[elt + 1].type, NULL, stream, 0);
935  fprintf_filtered (stream, ")");
936  elt = dump_subexp (exp, stream, elt + 3);
937  break;
938  case OP_TYPE:
939  fprintf_filtered (stream, "Type @");
940  gdb_print_host_address (exp->elts[elt].type, stream);
941  fprintf_filtered (stream, " (");
942  type_print (exp->elts[elt].type, NULL, stream, 0);
943  fprintf_filtered (stream, ")");
944  elt += 2;
945  break;
946  case OP_TYPEOF:
947  case OP_DECLTYPE:
948  fprintf_filtered (stream, "Typeof (");
949  elt = dump_subexp (exp, stream, elt);
950  fprintf_filtered (stream, ")");
951  break;
952  case OP_TYPEID:
953  fprintf_filtered (stream, "typeid (");
954  elt = dump_subexp (exp, stream, elt);
955  fprintf_filtered (stream, ")");
956  break;
957  case STRUCTOP_STRUCT:
958  case STRUCTOP_PTR:
959  {
960  char *elem_name;
961  int len;
962 
963  len = longest_to_int (exp->elts[elt].longconst);
964  elem_name = &exp->elts[elt + 1].string;
965 
966  fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
967  elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
968  }
969  break;
970  case OP_SCOPE:
971  {
972  char *elem_name;
973  int len;
974 
975  fprintf_filtered (stream, "Type @");
976  gdb_print_host_address (exp->elts[elt].type, stream);
977  fprintf_filtered (stream, " (");
978  type_print (exp->elts[elt].type, NULL, stream, 0);
979  fprintf_filtered (stream, ") ");
980 
981  len = longest_to_int (exp->elts[elt + 1].longconst);
982  elem_name = &exp->elts[elt + 2].string;
983 
984  fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
985  elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
986  }
987  break;
988  case TYPE_INSTANCE:
989  {
990  LONGEST len;
991 
992  len = exp->elts[elt++].longconst;
993  fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
994  while (len-- > 0)
995  {
996  fprintf_filtered (stream, "Type @");
997  gdb_print_host_address (exp->elts[elt].type, stream);
998  fprintf_filtered (stream, " (");
999  type_print (exp->elts[elt].type, NULL, stream, 0);
1000  fprintf_filtered (stream, ")");
1001  elt++;
1002  if (len > 0)
1003  fputs_filtered (", ", stream);
1004  }
1005  /* Ending LEN and ending TYPE_INSTANCE. */
1006  elt += 2;
1007  elt = dump_subexp (exp, stream, elt);
1008  }
1009  break;
1010  case OP_STRING:
1011  {
1012  LONGEST len = exp->elts[elt].longconst;
1013  LONGEST type = exp->elts[elt + 1].longconst;
1014 
1015  fprintf_filtered (stream, "Language-specific string type: %s",
1016  plongest (type));
1017 
1018  /* Skip length. */
1019  elt += 1;
1020 
1021  /* Skip string content. */
1022  elt += BYTES_TO_EXP_ELEM (len);
1023 
1024  /* Skip length and ending OP_STRING. */
1025  elt += 2;
1026  }
1027  break;
1028  default:
1029  case OP_NULL:
1030  case MULTI_SUBSCRIPT:
1031  case OP_F77_UNDETERMINED_ARGLIST:
1032  case OP_COMPLEX:
1033  case OP_BOOL:
1034  case OP_M2_STRING:
1035  case OP_THIS:
1036  case OP_NAME:
1037  fprintf_filtered (stream, "Unknown format");
1038  }
1039 
1040  return elt;
1041 }
1042 
1043 void
1044 dump_prefix_expression (struct expression *exp, struct ui_file *stream)
1045 {
1046  int elt;
1047 
1048  fprintf_filtered (stream, "Dump of expression @ ");
1049  gdb_print_host_address (exp, stream);
1050  fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
1051  print_expression (exp, stream);
1052  fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
1053  exp->language_defn->la_name, exp->nelts,
1054  (long) sizeof (union exp_element));
1055  fputs_filtered ("\n", stream);
1056 
1057  for (elt = 0; elt < exp->nelts;)
1058  elt = dump_subexp (exp, stream, elt);
1059  fputs_filtered ("\n", stream);
1060 }
union exp_element elts[1]
Definition: expression.h:85
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:870
enum exp_opcode opcode
Definition: expression.h:65
enum exp_opcode opcode
Definition: parser-defs.h:317
bfd_vma CORE_ADDR
Definition: common-types.h:41
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
void xfree(void *)
Definition: common-utils.c:97
void dump_raw_expression(struct expression *exp, struct ui_file *stream, char *note)
Definition: expprint.c:685
const struct language_defn * language_defn
Definition: expression.h:81
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
enum language la_language
Definition: language.h:152
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:137
#define _(String)
Definition: gdb_locale.h:40
#define BYTES_TO_EXP_ELEM(bytes)
Definition: expression.h:93
int longest_to_int(LONGEST)
Definition: valprint.c:1054
struct internalvar * internalvar
Definition: expression.h:74
int dump_subexp(struct expression *exp, struct ui_file *stream, int elt)
Definition: expprint.c:728
struct symbol * symbol
Definition: expression.h:66
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
struct type * type
Definition: expression.h:73
enum precedence precedence
Definition: parser-defs.h:319
char * op_name(struct expression *exp, enum exp_opcode opcode)
Definition: expprint.c:653
const struct block * block
Definition: expression.h:75
const char *const name
Definition: aarch64-tdep.c:68
const struct exp_descriptor * la_exp_desc
Definition: language.h:170
void dump_prefix_expression(struct expression *exp, struct ui_file *stream)
Definition: expprint.c:1044
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
void print_expression(struct expression *exp, struct ui_file *stream)
Definition: expprint.c:36
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
DOUBLEST doubleconst
Definition: expression.h:68
Definition: gdbtypes.h:749
char string
Definition: expression.h:72
char * internalvar_name(struct internalvar *var)
Definition: value.c:2407
int dump_subexp_body_standard(struct expression *exp, struct ui_file *stream, int elt)
Definition: expprint.c:762
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:951
char * op_name_standard(enum exp_opcode opcode)
Definition: expprint.c:662
struct value * value_from_double(struct type *type, DOUBLEST num)
Definition: value.c:3563
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
char * string
Definition: parser-defs.h:316
Definition: block.h:60
Definition: value.c:172
unsigned short selector
Definition: go32-nat.c:1064
bfd_byte gdb_byte
Definition: common-types.h:38
struct type * builtin_char
Definition: gdbtypes.h:1481
const struct language_defn * current_language
Definition: language.c:85
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1016
void gdb_print_host_address(const void *addr, struct ui_file *stream)
Definition: utils.c:1106
void print_subexp_standard(struct expression *exp, int *pos, struct ui_file *stream, enum precedence prec)
Definition: expprint.c:58
void print_subexp(struct expression *exp, int *pos, struct ui_file *stream, enum precedence prec)
Definition: expprint.c:49
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
precedence
Definition: parser-defs.h:303
const struct op_print * la_op_print_tab
Definition: language.h:286
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
exp_opcode
Definition: expression.h:43
int(* dump_subexp_body)(struct expression *, struct ui_file *, int)
Definition: parser-defs.h:361
struct objfile * objfile
Definition: expression.h:76
char *(* op_name)(enum exp_opcode)
Definition: parser-defs.h:356
LONGEST longconst
Definition: expression.h:67
int right_assoc
Definition: parser-defs.h:323
struct gdbarch * gdbarch
Definition: expression.h:83
static int dump_subexp_body(struct expression *exp, struct ui_file *, int)
Definition: expprint.c:754
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:496
void(* print_subexp)(struct expression *, int *, struct ui_file *, enum precedence)
Definition: parser-defs.h:332
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1361
char * la_name_of_this
Definition: language.h:264
char * op_string(enum exp_opcode op)
Definition: expprint.c:633
const char * la_name
Definition: language.h:144
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
Definition: target.c:915
void error(const char *fmt,...)
Definition: errors.c:38
long long LONGEST
Definition: common-types.h:52
const ULONGEST const LONGEST len
Definition: target.h:309