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