|
0
|
1 /* Pretty formatting of GENERIC trees in C syntax.
|
|
|
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 #include "config.h"
|
|
|
23 #include "system.h"
|
|
|
24 #include "coretypes.h"
|
|
|
25 #include "tm.h"
|
|
|
26 #include "tree.h"
|
|
|
27 #include "output.h"
|
|
|
28 #include "diagnostic.h"
|
|
|
29 #include "real.h"
|
|
|
30 #include "hashtab.h"
|
|
|
31 #include "tree-flow.h"
|
|
|
32 #include "langhooks.h"
|
|
|
33 #include "tree-iterator.h"
|
|
|
34 #include "tree-chrec.h"
|
|
|
35 #include "tree-pass.h"
|
|
|
36 #include "fixed-value.h"
|
|
|
37 #include "value-prof.h"
|
|
|
38 #include "predict.h"
|
|
|
39
|
|
|
40 /* Local functions, macros and variables. */
|
|
|
41 static const char *op_symbol (const_tree);
|
|
|
42 static void pretty_print_string (pretty_printer *, const char*);
|
|
|
43 static void print_call_name (pretty_printer *, const_tree);
|
|
|
44 static void newline_and_indent (pretty_printer *, int);
|
|
|
45 static void maybe_init_pretty_print (FILE *);
|
|
|
46 static void print_struct_decl (pretty_printer *, const_tree, int, int);
|
|
|
47 static void do_niy (pretty_printer *, const_tree);
|
|
|
48
|
|
|
49 #define INDENT(SPACE) do { \
|
|
|
50 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
|
|
|
51
|
|
|
52 #define NIY do_niy(buffer,node)
|
|
|
53
|
|
|
54 #define PRINT_FUNCTION_NAME(NODE) pp_printf \
|
|
|
55 (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
|
|
|
56 lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
|
|
|
57 lang_hooks.decl_printable_name (NODE, 1))
|
|
|
58
|
|
|
59 static pretty_printer buffer;
|
|
|
60 static int initialized = 0;
|
|
|
61
|
|
|
62 /* Try to print something for an unknown tree code. */
|
|
|
63
|
|
|
64 static void
|
|
|
65 do_niy (pretty_printer *buffer, const_tree node)
|
|
|
66 {
|
|
|
67 int i, len;
|
|
|
68
|
|
|
69 pp_string (buffer, "<<< Unknown tree: ");
|
|
|
70 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
|
|
|
71
|
|
|
72 if (EXPR_P (node))
|
|
|
73 {
|
|
|
74 len = TREE_OPERAND_LENGTH (node);
|
|
|
75 for (i = 0; i < len; ++i)
|
|
|
76 {
|
|
|
77 newline_and_indent (buffer, 2);
|
|
|
78 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
|
|
|
79 }
|
|
|
80 }
|
|
|
81
|
|
|
82 pp_string (buffer, " >>>\n");
|
|
|
83 }
|
|
|
84
|
|
|
85 /* Debugging function to print out a generic expression. */
|
|
|
86
|
|
|
87 void
|
|
|
88 debug_generic_expr (tree t)
|
|
|
89 {
|
|
|
90 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
|
|
|
91 fprintf (stderr, "\n");
|
|
|
92 }
|
|
|
93
|
|
|
94 /* Debugging function to print out a generic statement. */
|
|
|
95
|
|
|
96 void
|
|
|
97 debug_generic_stmt (tree t)
|
|
|
98 {
|
|
|
99 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
|
|
|
100 fprintf (stderr, "\n");
|
|
|
101 }
|
|
|
102
|
|
|
103 /* Debugging function to print out a chain of trees . */
|
|
|
104
|
|
|
105 void
|
|
|
106 debug_tree_chain (tree t)
|
|
|
107 {
|
|
|
108 while (t)
|
|
|
109 {
|
|
|
110 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
|
|
|
111 fprintf(stderr, " ");
|
|
|
112 t = TREE_CHAIN (t);
|
|
|
113 }
|
|
|
114 fprintf (stderr, "\n");
|
|
|
115 }
|
|
|
116
|
|
|
117 /* Prints declaration DECL to the FILE with details specified by FLAGS. */
|
|
|
118 void
|
|
|
119 print_generic_decl (FILE *file, tree decl, int flags)
|
|
|
120 {
|
|
|
121 maybe_init_pretty_print (file);
|
|
|
122 print_declaration (&buffer, decl, 2, flags);
|
|
|
123 pp_write_text_to_stream (&buffer);
|
|
|
124 }
|
|
|
125
|
|
|
126 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
|
|
|
127 to show in the dump. See TDF_* in tree-pass.h. */
|
|
|
128
|
|
|
129 void
|
|
|
130 print_generic_stmt (FILE *file, tree t, int flags)
|
|
|
131 {
|
|
|
132 maybe_init_pretty_print (file);
|
|
|
133 dump_generic_node (&buffer, t, 0, flags, true);
|
|
|
134 pp_flush (&buffer);
|
|
|
135 }
|
|
|
136
|
|
|
137 /* Print tree T, and its successors, on file FILE. FLAGS specifies details
|
|
|
138 to show in the dump. See TDF_* in tree-pass.h. The output is indented by
|
|
|
139 INDENT spaces. */
|
|
|
140
|
|
|
141 void
|
|
|
142 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
|
|
|
143 {
|
|
|
144 int i;
|
|
|
145
|
|
|
146 maybe_init_pretty_print (file);
|
|
|
147
|
|
|
148 for (i = 0; i < indent; i++)
|
|
|
149 pp_space (&buffer);
|
|
|
150 dump_generic_node (&buffer, t, indent, flags, true);
|
|
|
151 pp_flush (&buffer);
|
|
|
152 }
|
|
|
153
|
|
|
154 /* Print a single expression T on file FILE. FLAGS specifies details to show
|
|
|
155 in the dump. See TDF_* in tree-pass.h. */
|
|
|
156
|
|
|
157 void
|
|
|
158 print_generic_expr (FILE *file, tree t, int flags)
|
|
|
159 {
|
|
|
160 maybe_init_pretty_print (file);
|
|
|
161 dump_generic_node (&buffer, t, 0, flags, false);
|
|
|
162 }
|
|
|
163
|
|
|
164 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
|
|
|
165 in FLAGS. */
|
|
|
166
|
|
|
167 static void
|
|
|
168 dump_decl_name (pretty_printer *buffer, tree node, int flags)
|
|
|
169 {
|
|
|
170 tree t = node;
|
|
|
171
|
|
|
172 if (DECL_NAME (t))
|
|
|
173 pp_tree_identifier (buffer, DECL_NAME (t));
|
|
|
174 if ((flags & TDF_UID)
|
|
|
175 || DECL_NAME (t) == NULL_TREE)
|
|
|
176 {
|
|
|
177 if (TREE_CODE (t) == LABEL_DECL
|
|
|
178 && LABEL_DECL_UID (t) != -1)
|
|
|
179 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
|
|
|
180 else
|
|
|
181 {
|
|
|
182 char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
|
|
|
183 pp_printf (buffer, "%c.%u", c, DECL_UID (t));
|
|
|
184 }
|
|
|
185 }
|
|
|
186 }
|
|
|
187
|
|
|
188 /* Like the above, but used for pretty printing function calls. */
|
|
|
189
|
|
|
190 static void
|
|
|
191 dump_function_name (pretty_printer *buffer, tree node)
|
|
|
192 {
|
|
|
193 if (DECL_NAME (node))
|
|
|
194 PRINT_FUNCTION_NAME (node);
|
|
|
195 else
|
|
|
196 dump_decl_name (buffer, node, 0);
|
|
|
197 }
|
|
|
198
|
|
|
199 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
|
|
|
200 FLAGS are as in dump_generic_node. */
|
|
|
201
|
|
|
202 static void
|
|
|
203 dump_function_declaration (pretty_printer *buffer, tree node,
|
|
|
204 int spc, int flags)
|
|
|
205 {
|
|
|
206 bool wrote_arg = false;
|
|
|
207 tree arg;
|
|
|
208
|
|
|
209 pp_space (buffer);
|
|
|
210 pp_character (buffer, '(');
|
|
|
211
|
|
|
212 /* Print the argument types. The last element in the list is a VOID_TYPE.
|
|
|
213 The following avoids printing the last element. */
|
|
|
214 arg = TYPE_ARG_TYPES (node);
|
|
|
215 while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
|
|
|
216 {
|
|
|
217 wrote_arg = true;
|
|
|
218 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
|
|
|
219 arg = TREE_CHAIN (arg);
|
|
|
220 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
|
|
|
221 {
|
|
|
222 pp_character (buffer, ',');
|
|
|
223 pp_space (buffer);
|
|
|
224 }
|
|
|
225 }
|
|
|
226
|
|
|
227 if (!wrote_arg)
|
|
|
228 pp_string (buffer, "void");
|
|
|
229
|
|
|
230 pp_character (buffer, ')');
|
|
|
231 }
|
|
|
232
|
|
|
233 /* Dump the domain associated with an array. */
|
|
|
234
|
|
|
235 static void
|
|
|
236 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
|
|
|
237 {
|
|
|
238 pp_character (buffer, '[');
|
|
|
239 if (domain)
|
|
|
240 {
|
|
|
241 tree min = TYPE_MIN_VALUE (domain);
|
|
|
242 tree max = TYPE_MAX_VALUE (domain);
|
|
|
243
|
|
|
244 if (min && max
|
|
|
245 && integer_zerop (min)
|
|
|
246 && host_integerp (max, 0))
|
|
|
247 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
|
|
|
248 else
|
|
|
249 {
|
|
|
250 if (min)
|
|
|
251 dump_generic_node (buffer, min, spc, flags, false);
|
|
|
252 pp_character (buffer, ':');
|
|
|
253 if (max)
|
|
|
254 dump_generic_node (buffer, max, spc, flags, false);
|
|
|
255 }
|
|
|
256 }
|
|
|
257 else
|
|
|
258 pp_string (buffer, "<unknown>");
|
|
|
259 pp_character (buffer, ']');
|
|
|
260 }
|
|
|
261
|
|
|
262
|
|
|
263 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
|
|
|
264 dump_generic_node. */
|
|
|
265
|
|
|
266 static void
|
|
|
267 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
|
|
|
268 {
|
|
|
269 const char *name;
|
|
|
270
|
|
|
271 switch (OMP_CLAUSE_CODE (clause))
|
|
|
272 {
|
|
|
273 case OMP_CLAUSE_PRIVATE:
|
|
|
274 name = "private";
|
|
|
275 goto print_remap;
|
|
|
276 case OMP_CLAUSE_SHARED:
|
|
|
277 name = "shared";
|
|
|
278 goto print_remap;
|
|
|
279 case OMP_CLAUSE_FIRSTPRIVATE:
|
|
|
280 name = "firstprivate";
|
|
|
281 goto print_remap;
|
|
|
282 case OMP_CLAUSE_LASTPRIVATE:
|
|
|
283 name = "lastprivate";
|
|
|
284 goto print_remap;
|
|
|
285 case OMP_CLAUSE_COPYIN:
|
|
|
286 name = "copyin";
|
|
|
287 goto print_remap;
|
|
|
288 case OMP_CLAUSE_COPYPRIVATE:
|
|
|
289 name = "copyprivate";
|
|
|
290 goto print_remap;
|
|
|
291 print_remap:
|
|
|
292 pp_string (buffer, name);
|
|
|
293 pp_character (buffer, '(');
|
|
|
294 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
|
|
|
295 spc, flags, false);
|
|
|
296 pp_character (buffer, ')');
|
|
|
297 break;
|
|
|
298
|
|
|
299 case OMP_CLAUSE_REDUCTION:
|
|
|
300 pp_string (buffer, "reduction(");
|
|
|
301 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
|
|
|
302 pp_character (buffer, ':');
|
|
|
303 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
|
|
|
304 spc, flags, false);
|
|
|
305 pp_character (buffer, ')');
|
|
|
306 break;
|
|
|
307
|
|
|
308 case OMP_CLAUSE_IF:
|
|
|
309 pp_string (buffer, "if(");
|
|
|
310 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
|
|
|
311 spc, flags, false);
|
|
|
312 pp_character (buffer, ')');
|
|
|
313 break;
|
|
|
314
|
|
|
315 case OMP_CLAUSE_NUM_THREADS:
|
|
|
316 pp_string (buffer, "num_threads(");
|
|
|
317 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
|
|
|
318 spc, flags, false);
|
|
|
319 pp_character (buffer, ')');
|
|
|
320 break;
|
|
|
321
|
|
|
322 case OMP_CLAUSE_NOWAIT:
|
|
|
323 pp_string (buffer, "nowait");
|
|
|
324 break;
|
|
|
325 case OMP_CLAUSE_ORDERED:
|
|
|
326 pp_string (buffer, "ordered");
|
|
|
327 break;
|
|
|
328
|
|
|
329 case OMP_CLAUSE_DEFAULT:
|
|
|
330 pp_string (buffer, "default(");
|
|
|
331 switch (OMP_CLAUSE_DEFAULT_KIND (clause))
|
|
|
332 {
|
|
|
333 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
|
|
|
334 break;
|
|
|
335 case OMP_CLAUSE_DEFAULT_SHARED:
|
|
|
336 pp_string (buffer, "shared");
|
|
|
337 break;
|
|
|
338 case OMP_CLAUSE_DEFAULT_NONE:
|
|
|
339 pp_string (buffer, "none");
|
|
|
340 break;
|
|
|
341 case OMP_CLAUSE_DEFAULT_PRIVATE:
|
|
|
342 pp_string (buffer, "private");
|
|
|
343 break;
|
|
|
344 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
|
|
|
345 pp_string (buffer, "firstprivate");
|
|
|
346 break;
|
|
|
347 default:
|
|
|
348 gcc_unreachable ();
|
|
|
349 }
|
|
|
350 pp_character (buffer, ')');
|
|
|
351 break;
|
|
|
352
|
|
|
353 case OMP_CLAUSE_SCHEDULE:
|
|
|
354 pp_string (buffer, "schedule(");
|
|
|
355 switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
|
|
|
356 {
|
|
|
357 case OMP_CLAUSE_SCHEDULE_STATIC:
|
|
|
358 pp_string (buffer, "static");
|
|
|
359 break;
|
|
|
360 case OMP_CLAUSE_SCHEDULE_DYNAMIC:
|
|
|
361 pp_string (buffer, "dynamic");
|
|
|
362 break;
|
|
|
363 case OMP_CLAUSE_SCHEDULE_GUIDED:
|
|
|
364 pp_string (buffer, "guided");
|
|
|
365 break;
|
|
|
366 case OMP_CLAUSE_SCHEDULE_RUNTIME:
|
|
|
367 pp_string (buffer, "runtime");
|
|
|
368 break;
|
|
|
369 case OMP_CLAUSE_SCHEDULE_AUTO:
|
|
|
370 pp_string (buffer, "auto");
|
|
|
371 break;
|
|
|
372 default:
|
|
|
373 gcc_unreachable ();
|
|
|
374 }
|
|
|
375 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
|
|
|
376 {
|
|
|
377 pp_character (buffer, ',');
|
|
|
378 dump_generic_node (buffer,
|
|
|
379 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
|
|
|
380 spc, flags, false);
|
|
|
381 }
|
|
|
382 pp_character (buffer, ')');
|
|
|
383 break;
|
|
|
384
|
|
|
385 case OMP_CLAUSE_UNTIED:
|
|
|
386 pp_string (buffer, "untied");
|
|
|
387 break;
|
|
|
388
|
|
|
389 case OMP_CLAUSE_COLLAPSE:
|
|
|
390 pp_string (buffer, "collapse(");
|
|
|
391 dump_generic_node (buffer,
|
|
|
392 OMP_CLAUSE_COLLAPSE_EXPR (clause),
|
|
|
393 spc, flags, false);
|
|
|
394 pp_character (buffer, ')');
|
|
|
395 break;
|
|
|
396
|
|
|
397 default:
|
|
|
398 /* Should never happen. */
|
|
|
399 dump_generic_node (buffer, clause, spc, flags, false);
|
|
|
400 break;
|
|
|
401 }
|
|
|
402 }
|
|
|
403
|
|
|
404
|
|
|
405 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
|
|
|
406 dump_generic_node. */
|
|
|
407
|
|
|
408 void
|
|
|
409 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
|
|
|
410 {
|
|
|
411 if (clause == NULL)
|
|
|
412 return;
|
|
|
413
|
|
|
414 pp_space (buffer);
|
|
|
415 while (1)
|
|
|
416 {
|
|
|
417 dump_omp_clause (buffer, clause, spc, flags);
|
|
|
418 clause = OMP_CLAUSE_CHAIN (clause);
|
|
|
419 if (clause == NULL)
|
|
|
420 return;
|
|
|
421 pp_space (buffer);
|
|
|
422 }
|
|
|
423 }
|
|
|
424
|
|
|
425
|
|
|
426 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
|
|
|
427 indent. FLAGS specifies details to show in the dump (see TDF_* in
|
|
|
428 tree-pass.h). If IS_STMT is true, the object printed is considered
|
|
|
429 to be a statement and it is terminated by ';' if appropriate. */
|
|
|
430
|
|
|
431 int
|
|
|
432 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
|
|
|
433 bool is_stmt)
|
|
|
434 {
|
|
|
435 tree type;
|
|
|
436 tree op0, op1;
|
|
|
437 const char *str;
|
|
|
438 bool is_expr;
|
|
|
439
|
|
|
440 if (node == NULL_TREE)
|
|
|
441 return spc;
|
|
|
442
|
|
|
443 is_expr = EXPR_P (node);
|
|
|
444
|
|
|
445 if (is_stmt && (flags & TDF_STMTADDR))
|
|
|
446 pp_printf (buffer, "<&%p> ", (void *)node);
|
|
|
447
|
|
|
448 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
|
|
|
449 {
|
|
|
450 expanded_location xloc = expand_location (EXPR_LOCATION (node));
|
|
|
451 pp_character (buffer, '[');
|
|
|
452 if (xloc.file)
|
|
|
453 {
|
|
|
454 pp_string (buffer, xloc.file);
|
|
|
455 pp_string (buffer, " : ");
|
|
|
456 }
|
|
|
457 pp_decimal_int (buffer, xloc.line);
|
|
|
458 pp_string (buffer, "] ");
|
|
|
459 }
|
|
|
460
|
|
|
461 switch (TREE_CODE (node))
|
|
|
462 {
|
|
|
463 case ERROR_MARK:
|
|
|
464 pp_string (buffer, "<<< error >>>");
|
|
|
465 break;
|
|
|
466
|
|
|
467 case IDENTIFIER_NODE:
|
|
|
468 pp_tree_identifier (buffer, node);
|
|
|
469 break;
|
|
|
470
|
|
|
471 case TREE_LIST:
|
|
|
472 while (node && node != error_mark_node)
|
|
|
473 {
|
|
|
474 if (TREE_PURPOSE (node))
|
|
|
475 {
|
|
|
476 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
|
|
|
477 pp_space (buffer);
|
|
|
478 }
|
|
|
479 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
|
|
|
480 node = TREE_CHAIN (node);
|
|
|
481 if (node && TREE_CODE (node) == TREE_LIST)
|
|
|
482 {
|
|
|
483 pp_character (buffer, ',');
|
|
|
484 pp_space (buffer);
|
|
|
485 }
|
|
|
486 }
|
|
|
487 break;
|
|
|
488
|
|
|
489 case TREE_BINFO:
|
|
|
490 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
|
|
|
491
|
|
|
492 case TREE_VEC:
|
|
|
493 {
|
|
|
494 size_t i;
|
|
|
495 if (TREE_VEC_LENGTH (node) > 0)
|
|
|
496 {
|
|
|
497 size_t len = TREE_VEC_LENGTH (node);
|
|
|
498 for (i = 0; i < len - 1; i++)
|
|
|
499 {
|
|
|
500 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
|
|
|
501 false);
|
|
|
502 pp_character (buffer, ',');
|
|
|
503 pp_space (buffer);
|
|
|
504 }
|
|
|
505 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
|
|
|
506 flags, false);
|
|
|
507 }
|
|
|
508 }
|
|
|
509 break;
|
|
|
510
|
|
|
511 case VOID_TYPE:
|
|
|
512 case INTEGER_TYPE:
|
|
|
513 case REAL_TYPE:
|
|
|
514 case FIXED_POINT_TYPE:
|
|
|
515 case COMPLEX_TYPE:
|
|
|
516 case VECTOR_TYPE:
|
|
|
517 case ENUMERAL_TYPE:
|
|
|
518 case BOOLEAN_TYPE:
|
|
|
519 {
|
|
|
520 unsigned int quals = TYPE_QUALS (node);
|
|
|
521 enum tree_code_class tclass;
|
|
|
522
|
|
|
523 if (quals & TYPE_QUAL_CONST)
|
|
|
524 pp_string (buffer, "const ");
|
|
|
525 else if (quals & TYPE_QUAL_VOLATILE)
|
|
|
526 pp_string (buffer, "volatile ");
|
|
|
527 else if (quals & TYPE_QUAL_RESTRICT)
|
|
|
528 pp_string (buffer, "restrict ");
|
|
|
529
|
|
|
530 tclass = TREE_CODE_CLASS (TREE_CODE (node));
|
|
|
531
|
|
|
532 if (tclass == tcc_declaration)
|
|
|
533 {
|
|
|
534 if (DECL_NAME (node))
|
|
|
535 dump_decl_name (buffer, node, flags);
|
|
|
536 else
|
|
|
537 pp_string (buffer, "<unnamed type decl>");
|
|
|
538 }
|
|
|
539 else if (tclass == tcc_type)
|
|
|
540 {
|
|
|
541 if (TYPE_NAME (node))
|
|
|
542 {
|
|
|
543 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
|
|
|
544 pp_tree_identifier (buffer, TYPE_NAME (node));
|
|
|
545 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
|
|
|
546 && DECL_NAME (TYPE_NAME (node)))
|
|
|
547 dump_decl_name (buffer, TYPE_NAME (node), flags);
|
|
|
548 else
|
|
|
549 pp_string (buffer, "<unnamed type>");
|
|
|
550 }
|
|
|
551 else if (TREE_CODE (node) == VECTOR_TYPE)
|
|
|
552 {
|
|
|
553 pp_string (buffer, "vector ");
|
|
|
554 dump_generic_node (buffer, TREE_TYPE (node),
|
|
|
555 spc, flags, false);
|
|
|
556 }
|
|
|
557 else if (TREE_CODE (node) == INTEGER_TYPE)
|
|
|
558 {
|
|
|
559 pp_string (buffer, (TYPE_UNSIGNED (node)
|
|
|
560 ? "<unnamed-unsigned:"
|
|
|
561 : "<unnamed-signed:"));
|
|
|
562 pp_decimal_int (buffer, TYPE_PRECISION (node));
|
|
|
563 pp_string (buffer, ">");
|
|
|
564 }
|
|
|
565 else
|
|
|
566 pp_string (buffer, "<unnamed type>");
|
|
|
567 }
|
|
|
568 break;
|
|
|
569 }
|
|
|
570
|
|
|
571 case POINTER_TYPE:
|
|
|
572 case REFERENCE_TYPE:
|
|
|
573 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
|
|
|
574
|
|
|
575 if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
|
|
|
576 {
|
|
|
577 tree fnode = TREE_TYPE (node);
|
|
|
578
|
|
|
579 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
|
|
|
580 pp_space (buffer);
|
|
|
581 pp_character (buffer, '(');
|
|
|
582 pp_string (buffer, str);
|
|
|
583 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
|
|
|
584 dump_decl_name (buffer, TYPE_NAME (node), flags);
|
|
|
585 else
|
|
|
586 pp_printf (buffer, "<T%x>", TYPE_UID (node));
|
|
|
587
|
|
|
588 pp_character (buffer, ')');
|
|
|
589 dump_function_declaration (buffer, fnode, spc, flags);
|
|
|
590 }
|
|
|
591 else
|
|
|
592 {
|
|
|
593 unsigned int quals = TYPE_QUALS (node);
|
|
|
594
|
|
|
595 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
|
|
|
596 pp_space (buffer);
|
|
|
597 pp_string (buffer, str);
|
|
|
598
|
|
|
599 if (quals & TYPE_QUAL_CONST)
|
|
|
600 pp_string (buffer, " const");
|
|
|
601 if (quals & TYPE_QUAL_VOLATILE)
|
|
|
602 pp_string (buffer, " volatile");
|
|
|
603 if (quals & TYPE_QUAL_RESTRICT)
|
|
|
604 pp_string (buffer, " restrict");
|
|
|
605
|
|
|
606 if (TYPE_REF_CAN_ALIAS_ALL (node))
|
|
|
607 pp_string (buffer, " {ref-all}");
|
|
|
608 }
|
|
|
609 break;
|
|
|
610
|
|
|
611 case OFFSET_TYPE:
|
|
|
612 NIY;
|
|
|
613 break;
|
|
|
614
|
|
|
615 case METHOD_TYPE:
|
|
|
616 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
|
|
|
617 pp_string (buffer, "::");
|
|
|
618 break;
|
|
|
619
|
|
|
620 case TARGET_MEM_REF:
|
|
|
621 {
|
|
|
622 const char *sep = "";
|
|
|
623 tree tmp;
|
|
|
624
|
|
|
625 pp_string (buffer, "MEM[");
|
|
|
626
|
|
|
627 tmp = TMR_SYMBOL (node);
|
|
|
628 if (tmp)
|
|
|
629 {
|
|
|
630 pp_string (buffer, sep);
|
|
|
631 sep = ", ";
|
|
|
632 pp_string (buffer, "symbol: ");
|
|
|
633 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
634 }
|
|
|
635 tmp = TMR_BASE (node);
|
|
|
636 if (tmp)
|
|
|
637 {
|
|
|
638 pp_string (buffer, sep);
|
|
|
639 sep = ", ";
|
|
|
640 pp_string (buffer, "base: ");
|
|
|
641 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
642 }
|
|
|
643 tmp = TMR_INDEX (node);
|
|
|
644 if (tmp)
|
|
|
645 {
|
|
|
646 pp_string (buffer, sep);
|
|
|
647 sep = ", ";
|
|
|
648 pp_string (buffer, "index: ");
|
|
|
649 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
650 }
|
|
|
651 tmp = TMR_STEP (node);
|
|
|
652 if (tmp)
|
|
|
653 {
|
|
|
654 pp_string (buffer, sep);
|
|
|
655 sep = ", ";
|
|
|
656 pp_string (buffer, "step: ");
|
|
|
657 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
658 }
|
|
|
659 tmp = TMR_OFFSET (node);
|
|
|
660 if (tmp)
|
|
|
661 {
|
|
|
662 pp_string (buffer, sep);
|
|
|
663 sep = ", ";
|
|
|
664 pp_string (buffer, "offset: ");
|
|
|
665 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
666 }
|
|
|
667 pp_string (buffer, "]");
|
|
|
668 if (flags & TDF_DETAILS)
|
|
|
669 {
|
|
|
670 pp_string (buffer, "{");
|
|
|
671 dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
|
|
|
672 false);
|
|
|
673 pp_string (buffer, "}");
|
|
|
674 }
|
|
|
675 }
|
|
|
676 break;
|
|
|
677
|
|
|
678 case ARRAY_TYPE:
|
|
|
679 {
|
|
|
680 tree tmp;
|
|
|
681
|
|
|
682 /* Print the innermost component type. */
|
|
|
683 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
|
|
|
684 tmp = TREE_TYPE (tmp))
|
|
|
685 ;
|
|
|
686 dump_generic_node (buffer, tmp, spc, flags, false);
|
|
|
687
|
|
|
688 /* Print the dimensions. */
|
|
|
689 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
|
|
|
690 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
|
|
|
691 break;
|
|
|
692 }
|
|
|
693
|
|
|
694 case RECORD_TYPE:
|
|
|
695 case UNION_TYPE:
|
|
|
696 case QUAL_UNION_TYPE:
|
|
|
697 {
|
|
|
698 unsigned int quals = TYPE_QUALS (node);
|
|
|
699
|
|
|
700 if (quals & TYPE_QUAL_CONST)
|
|
|
701 pp_string (buffer, "const ");
|
|
|
702 if (quals & TYPE_QUAL_VOLATILE)
|
|
|
703 pp_string (buffer, "volatile ");
|
|
|
704
|
|
|
705 /* Print the name of the structure. */
|
|
|
706 if (TREE_CODE (node) == RECORD_TYPE)
|
|
|
707 pp_string (buffer, "struct ");
|
|
|
708 else if (TREE_CODE (node) == UNION_TYPE)
|
|
|
709 pp_string (buffer, "union ");
|
|
|
710
|
|
|
711 if (TYPE_NAME (node))
|
|
|
712 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
|
|
|
713 else
|
|
|
714 print_struct_decl (buffer, node, spc, flags);
|
|
|
715 break;
|
|
|
716 }
|
|
|
717
|
|
|
718 case LANG_TYPE:
|
|
|
719 NIY;
|
|
|
720 break;
|
|
|
721
|
|
|
722 case INTEGER_CST:
|
|
|
723 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
|
|
|
724 {
|
|
|
725 /* In the case of a pointer, one may want to divide by the
|
|
|
726 size of the pointed-to type. Unfortunately, this not
|
|
|
727 straightforward. The C front-end maps expressions
|
|
|
728
|
|
|
729 (int *) 5
|
|
|
730 int *p; (p + 5)
|
|
|
731
|
|
|
732 in such a way that the two INTEGER_CST nodes for "5" have
|
|
|
733 different values but identical types. In the latter
|
|
|
734 case, the 5 is multiplied by sizeof (int) in c-common.c
|
|
|
735 (pointer_int_sum) to convert it to a byte address, and
|
|
|
736 yet the type of the node is left unchanged. Argh. What
|
|
|
737 is consistent though is that the number value corresponds
|
|
|
738 to bytes (UNITS) offset.
|
|
|
739
|
|
|
740 NB: Neither of the following divisors can be trivially
|
|
|
741 used to recover the original literal:
|
|
|
742
|
|
|
743 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
|
|
|
744 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */
|
|
|
745 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
|
|
|
746 pp_string (buffer, "B"); /* pseudo-unit */
|
|
|
747 }
|
|
|
748 else if (! host_integerp (node, 0))
|
|
|
749 {
|
|
|
750 tree val = node;
|
|
|
751 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
|
|
|
752 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
|
|
|
753
|
|
|
754 if (tree_int_cst_sgn (val) < 0)
|
|
|
755 {
|
|
|
756 pp_character (buffer, '-');
|
|
|
757 high = ~high + !low;
|
|
|
758 low = -low;
|
|
|
759 }
|
|
|
760 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
|
|
|
761 systems? */
|
|
|
762 sprintf (pp_buffer (buffer)->digit_buffer,
|
|
|
763 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
|
|
|
764 (unsigned HOST_WIDE_INT) high, low);
|
|
|
765 pp_string (buffer, pp_buffer (buffer)->digit_buffer);
|
|
|
766 }
|
|
|
767 else
|
|
|
768 pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
|
|
|
769 break;
|
|
|
770
|
|
|
771 case REAL_CST:
|
|
|
772 /* Code copied from print_node. */
|
|
|
773 {
|
|
|
774 REAL_VALUE_TYPE d;
|
|
|
775 if (TREE_OVERFLOW (node))
|
|
|
776 pp_string (buffer, " overflow");
|
|
|
777
|
|
|
778 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
|
|
|
779 d = TREE_REAL_CST (node);
|
|
|
780 if (REAL_VALUE_ISINF (d))
|
|
|
781 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
|
|
|
782 else if (REAL_VALUE_ISNAN (d))
|
|
|
783 pp_string (buffer, " Nan");
|
|
|
784 else
|
|
|
785 {
|
|
|
786 char string[100];
|
|
|
787 real_to_decimal (string, &d, sizeof (string), 0, 1);
|
|
|
788 pp_string (buffer, string);
|
|
|
789 }
|
|
|
790 #else
|
|
|
791 {
|
|
|
792 HOST_WIDE_INT i;
|
|
|
793 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
|
|
|
794 pp_string (buffer, "0x");
|
|
|
795 for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
|
|
|
796 output_formatted_integer (buffer, "%02x", *p++);
|
|
|
797 }
|
|
|
798 #endif
|
|
|
799 break;
|
|
|
800 }
|
|
|
801
|
|
|
802 case FIXED_CST:
|
|
|
803 {
|
|
|
804 char string[100];
|
|
|
805 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
|
|
|
806 pp_string (buffer, string);
|
|
|
807 break;
|
|
|
808 }
|
|
|
809
|
|
|
810 case COMPLEX_CST:
|
|
|
811 pp_string (buffer, "__complex__ (");
|
|
|
812 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
|
|
|
813 pp_string (buffer, ", ");
|
|
|
814 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
|
|
|
815 pp_string (buffer, ")");
|
|
|
816 break;
|
|
|
817
|
|
|
818 case STRING_CST:
|
|
|
819 pp_string (buffer, "\"");
|
|
|
820 pretty_print_string (buffer, TREE_STRING_POINTER (node));
|
|
|
821 pp_string (buffer, "\"");
|
|
|
822 break;
|
|
|
823
|
|
|
824 case VECTOR_CST:
|
|
|
825 {
|
|
|
826 tree elt;
|
|
|
827 pp_string (buffer, "{ ");
|
|
|
828 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
|
|
|
829 {
|
|
|
830 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
|
|
|
831 if (TREE_CHAIN (elt))
|
|
|
832 pp_string (buffer, ", ");
|
|
|
833 }
|
|
|
834 pp_string (buffer, " }");
|
|
|
835 }
|
|
|
836 break;
|
|
|
837
|
|
|
838 case FUNCTION_TYPE:
|
|
|
839 break;
|
|
|
840
|
|
|
841 case FUNCTION_DECL:
|
|
|
842 case CONST_DECL:
|
|
|
843 dump_decl_name (buffer, node, flags);
|
|
|
844 break;
|
|
|
845
|
|
|
846 case LABEL_DECL:
|
|
|
847 if (DECL_NAME (node))
|
|
|
848 dump_decl_name (buffer, node, flags);
|
|
|
849 else if (LABEL_DECL_UID (node) != -1)
|
|
|
850 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
|
|
|
851 else
|
|
|
852 pp_printf (buffer, "<D.%u>", DECL_UID (node));
|
|
|
853 break;
|
|
|
854
|
|
|
855 case TYPE_DECL:
|
|
|
856 if (DECL_IS_BUILTIN (node))
|
|
|
857 {
|
|
|
858 /* Don't print the declaration of built-in types. */
|
|
|
859 break;
|
|
|
860 }
|
|
|
861 if (DECL_NAME (node))
|
|
|
862 dump_decl_name (buffer, node, flags);
|
|
|
863 else
|
|
|
864 {
|
|
|
865 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
|
|
|
866 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
|
|
|
867 && TYPE_METHODS (TREE_TYPE (node)))
|
|
|
868 {
|
|
|
869 /* The type is a c++ class: all structures have at least
|
|
|
870 4 methods. */
|
|
|
871 pp_string (buffer, "class ");
|
|
|
872 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
|
|
|
873 }
|
|
|
874 else
|
|
|
875 {
|
|
|
876 pp_string (buffer,
|
|
|
877 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
|
|
|
878 ? "union" : "struct "));
|
|
|
879 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
|
|
|
880 }
|
|
|
881 }
|
|
|
882 break;
|
|
|
883
|
|
|
884 case SYMBOL_MEMORY_TAG:
|
|
|
885 case NAME_MEMORY_TAG:
|
|
|
886 case VAR_DECL:
|
|
|
887 case PARM_DECL:
|
|
|
888 case FIELD_DECL:
|
|
|
889 case NAMESPACE_DECL:
|
|
|
890 case MEMORY_PARTITION_TAG:
|
|
|
891 dump_decl_name (buffer, node, flags);
|
|
|
892 break;
|
|
|
893
|
|
|
894 case RESULT_DECL:
|
|
|
895 pp_string (buffer, "<retval>");
|
|
|
896 break;
|
|
|
897
|
|
|
898 case COMPONENT_REF:
|
|
|
899 op0 = TREE_OPERAND (node, 0);
|
|
|
900 str = ".";
|
|
|
901 if (TREE_CODE (op0) == INDIRECT_REF)
|
|
|
902 {
|
|
|
903 op0 = TREE_OPERAND (op0, 0);
|
|
|
904 str = "->";
|
|
|
905 }
|
|
|
906 if (op_prio (op0) < op_prio (node))
|
|
|
907 pp_character (buffer, '(');
|
|
|
908 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
909 if (op_prio (op0) < op_prio (node))
|
|
|
910 pp_character (buffer, ')');
|
|
|
911 pp_string (buffer, str);
|
|
|
912 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
913 op0 = component_ref_field_offset (node);
|
|
|
914 if (op0 && TREE_CODE (op0) != INTEGER_CST)
|
|
|
915 {
|
|
|
916 pp_string (buffer, "{off: ");
|
|
|
917 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
918 pp_character (buffer, '}');
|
|
|
919 }
|
|
|
920 break;
|
|
|
921
|
|
|
922 case BIT_FIELD_REF:
|
|
|
923 pp_string (buffer, "BIT_FIELD_REF <");
|
|
|
924 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
925 pp_string (buffer, ", ");
|
|
|
926 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
927 pp_string (buffer, ", ");
|
|
|
928 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
|
|
|
929 pp_string (buffer, ">");
|
|
|
930 break;
|
|
|
931
|
|
|
932 case ARRAY_REF:
|
|
|
933 case ARRAY_RANGE_REF:
|
|
|
934 op0 = TREE_OPERAND (node, 0);
|
|
|
935 if (op_prio (op0) < op_prio (node))
|
|
|
936 pp_character (buffer, '(');
|
|
|
937 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
938 if (op_prio (op0) < op_prio (node))
|
|
|
939 pp_character (buffer, ')');
|
|
|
940 pp_character (buffer, '[');
|
|
|
941 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
942 if (TREE_CODE (node) == ARRAY_RANGE_REF)
|
|
|
943 pp_string (buffer, " ...");
|
|
|
944 pp_character (buffer, ']');
|
|
|
945
|
|
|
946 op0 = array_ref_low_bound (node);
|
|
|
947 op1 = array_ref_element_size (node);
|
|
|
948
|
|
|
949 if (!integer_zerop (op0)
|
|
|
950 || TREE_OPERAND (node, 2)
|
|
|
951 || TREE_OPERAND (node, 3))
|
|
|
952 {
|
|
|
953 pp_string (buffer, "{lb: ");
|
|
|
954 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
955 pp_string (buffer, " sz: ");
|
|
|
956 dump_generic_node (buffer, op1, spc, flags, false);
|
|
|
957 pp_character (buffer, '}');
|
|
|
958 }
|
|
|
959 break;
|
|
|
960
|
|
|
961 case CONSTRUCTOR:
|
|
|
962 {
|
|
|
963 unsigned HOST_WIDE_INT ix;
|
|
|
964 tree field, val;
|
|
|
965 bool is_struct_init = FALSE;
|
|
|
966 pp_character (buffer, '{');
|
|
|
967 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
|
|
|
968 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
|
|
|
969 is_struct_init = TRUE;
|
|
|
970 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
|
|
|
971 {
|
|
|
972 if (field && is_struct_init)
|
|
|
973 {
|
|
|
974 pp_character (buffer, '.');
|
|
|
975 dump_generic_node (buffer, field, spc, flags, false);
|
|
|
976 pp_string (buffer, "=");
|
|
|
977 }
|
|
|
978 if (val && TREE_CODE (val) == ADDR_EXPR)
|
|
|
979 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
|
|
|
980 val = TREE_OPERAND (val, 0);
|
|
|
981 if (val && TREE_CODE (val) == FUNCTION_DECL)
|
|
|
982 dump_decl_name (buffer, val, flags);
|
|
|
983 else
|
|
|
984 dump_generic_node (buffer, val, spc, flags, false);
|
|
|
985 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
|
|
|
986 {
|
|
|
987 pp_character (buffer, ',');
|
|
|
988 pp_space (buffer);
|
|
|
989 }
|
|
|
990 }
|
|
|
991 pp_character (buffer, '}');
|
|
|
992 }
|
|
|
993 break;
|
|
|
994
|
|
|
995 case COMPOUND_EXPR:
|
|
|
996 {
|
|
|
997 tree *tp;
|
|
|
998 if (flags & TDF_SLIM)
|
|
|
999 {
|
|
|
1000 pp_string (buffer, "<COMPOUND_EXPR>");
|
|
|
1001 break;
|
|
|
1002 }
|
|
|
1003
|
|
|
1004 dump_generic_node (buffer, TREE_OPERAND (node, 0),
|
|
|
1005 spc, flags, !(flags & TDF_SLIM));
|
|
|
1006 if (flags & TDF_SLIM)
|
|
|
1007 newline_and_indent (buffer, spc);
|
|
|
1008 else
|
|
|
1009 {
|
|
|
1010 pp_character (buffer, ',');
|
|
|
1011 pp_space (buffer);
|
|
|
1012 }
|
|
|
1013
|
|
|
1014 for (tp = &TREE_OPERAND (node, 1);
|
|
|
1015 TREE_CODE (*tp) == COMPOUND_EXPR;
|
|
|
1016 tp = &TREE_OPERAND (*tp, 1))
|
|
|
1017 {
|
|
|
1018 dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
|
|
|
1019 spc, flags, !(flags & TDF_SLIM));
|
|
|
1020 if (flags & TDF_SLIM)
|
|
|
1021 newline_and_indent (buffer, spc);
|
|
|
1022 else
|
|
|
1023 {
|
|
|
1024 pp_character (buffer, ',');
|
|
|
1025 pp_space (buffer);
|
|
|
1026 }
|
|
|
1027 }
|
|
|
1028
|
|
|
1029 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
|
|
|
1030 }
|
|
|
1031 break;
|
|
|
1032
|
|
|
1033 case STATEMENT_LIST:
|
|
|
1034 {
|
|
|
1035 tree_stmt_iterator si;
|
|
|
1036 bool first = true;
|
|
|
1037
|
|
|
1038 if (flags & TDF_SLIM)
|
|
|
1039 {
|
|
|
1040 pp_string (buffer, "<STATEMENT_LIST>");
|
|
|
1041 break;
|
|
|
1042 }
|
|
|
1043
|
|
|
1044 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
|
|
|
1045 {
|
|
|
1046 if (!first)
|
|
|
1047 newline_and_indent (buffer, spc);
|
|
|
1048 else
|
|
|
1049 first = false;
|
|
|
1050 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
|
|
|
1051 }
|
|
|
1052 }
|
|
|
1053 break;
|
|
|
1054
|
|
|
1055 case MODIFY_EXPR:
|
|
|
1056 case INIT_EXPR:
|
|
|
1057 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
|
|
|
1058 false);
|
|
|
1059 pp_space (buffer);
|
|
|
1060 pp_character (buffer, '=');
|
|
|
1061 if (TREE_CODE (node) == MODIFY_EXPR
|
|
|
1062 && MOVE_NONTEMPORAL (node))
|
|
|
1063 pp_string (buffer, "{nt}");
|
|
|
1064 pp_space (buffer);
|
|
|
1065 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
|
|
|
1066 false);
|
|
|
1067 break;
|
|
|
1068
|
|
|
1069 case TARGET_EXPR:
|
|
|
1070 pp_string (buffer, "TARGET_EXPR <");
|
|
|
1071 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
|
|
|
1072 pp_character (buffer, ',');
|
|
|
1073 pp_space (buffer);
|
|
|
1074 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
|
|
|
1075 pp_character (buffer, '>');
|
|
|
1076 break;
|
|
|
1077
|
|
|
1078 case DECL_EXPR:
|
|
|
1079 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
|
|
|
1080 is_stmt = false;
|
|
|
1081 break;
|
|
|
1082
|
|
|
1083 case COND_EXPR:
|
|
|
1084 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
|
|
|
1085 {
|
|
|
1086 pp_string (buffer, "if (");
|
|
|
1087 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
|
|
|
1088 pp_character (buffer, ')');
|
|
|
1089 /* The lowered cond_exprs should always be printed in full. */
|
|
|
1090 if (COND_EXPR_THEN (node)
|
|
|
1091 && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
|
|
|
1092 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
|
|
|
1093 && COND_EXPR_ELSE (node)
|
|
|
1094 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
|
|
|
1095 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
|
|
|
1096 {
|
|
|
1097 pp_space (buffer);
|
|
|
1098 dump_generic_node (buffer, COND_EXPR_THEN (node),
|
|
|
1099 0, flags, true);
|
|
|
1100 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
|
|
|
1101 {
|
|
|
1102 pp_string (buffer, " else ");
|
|
|
1103 dump_generic_node (buffer, COND_EXPR_ELSE (node),
|
|
|
1104 0, flags, true);
|
|
|
1105 }
|
|
|
1106 }
|
|
|
1107 else if (!(flags & TDF_SLIM))
|
|
|
1108 {
|
|
|
1109 /* Output COND_EXPR_THEN. */
|
|
|
1110 if (COND_EXPR_THEN (node))
|
|
|
1111 {
|
|
|
1112 newline_and_indent (buffer, spc+2);
|
|
|
1113 pp_character (buffer, '{');
|
|
|
1114 newline_and_indent (buffer, spc+4);
|
|
|
1115 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
|
|
|
1116 flags, true);
|
|
|
1117 newline_and_indent (buffer, spc+2);
|
|
|
1118 pp_character (buffer, '}');
|
|
|
1119 }
|
|
|
1120
|
|
|
1121 /* Output COND_EXPR_ELSE. */
|
|
|
1122 if (COND_EXPR_ELSE (node)
|
|
|
1123 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
|
|
|
1124 {
|
|
|
1125 newline_and_indent (buffer, spc);
|
|
|
1126 pp_string (buffer, "else");
|
|
|
1127 newline_and_indent (buffer, spc+2);
|
|
|
1128 pp_character (buffer, '{');
|
|
|
1129 newline_and_indent (buffer, spc+4);
|
|
|
1130 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
|
|
|
1131 flags, true);
|
|
|
1132 newline_and_indent (buffer, spc+2);
|
|
|
1133 pp_character (buffer, '}');
|
|
|
1134 }
|
|
|
1135 }
|
|
|
1136 is_expr = false;
|
|
|
1137 }
|
|
|
1138 else
|
|
|
1139 {
|
|
|
1140 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1141 pp_space (buffer);
|
|
|
1142 pp_character (buffer, '?');
|
|
|
1143 pp_space (buffer);
|
|
|
1144 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1145 pp_space (buffer);
|
|
|
1146 pp_character (buffer, ':');
|
|
|
1147 pp_space (buffer);
|
|
|
1148 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
|
|
|
1149 }
|
|
|
1150 break;
|
|
|
1151
|
|
|
1152 case BIND_EXPR:
|
|
|
1153 pp_character (buffer, '{');
|
|
|
1154 if (!(flags & TDF_SLIM))
|
|
|
1155 {
|
|
|
1156 if (BIND_EXPR_VARS (node))
|
|
|
1157 {
|
|
|
1158 pp_newline (buffer);
|
|
|
1159
|
|
|
1160 for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
|
|
|
1161 {
|
|
|
1162 print_declaration (buffer, op0, spc+2, flags);
|
|
|
1163 pp_newline (buffer);
|
|
|
1164 }
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 newline_and_indent (buffer, spc+2);
|
|
|
1168 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
|
|
|
1169 newline_and_indent (buffer, spc);
|
|
|
1170 pp_character (buffer, '}');
|
|
|
1171 }
|
|
|
1172 is_expr = false;
|
|
|
1173 break;
|
|
|
1174
|
|
|
1175 case CALL_EXPR:
|
|
|
1176 print_call_name (buffer, node);
|
|
|
1177
|
|
|
1178 /* Print parameters. */
|
|
|
1179 pp_space (buffer);
|
|
|
1180 pp_character (buffer, '(');
|
|
|
1181 {
|
|
|
1182 tree arg;
|
|
|
1183 call_expr_arg_iterator iter;
|
|
|
1184 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
|
|
|
1185 {
|
|
|
1186 dump_generic_node (buffer, arg, spc, flags, false);
|
|
|
1187 if (more_call_expr_args_p (&iter))
|
|
|
1188 {
|
|
|
1189 pp_character (buffer, ',');
|
|
|
1190 pp_space (buffer);
|
|
|
1191 }
|
|
|
1192 }
|
|
|
1193 }
|
|
|
1194 if (CALL_EXPR_VA_ARG_PACK (node))
|
|
|
1195 {
|
|
|
1196 if (call_expr_nargs (node) > 0)
|
|
|
1197 {
|
|
|
1198 pp_character (buffer, ',');
|
|
|
1199 pp_space (buffer);
|
|
|
1200 }
|
|
|
1201 pp_string (buffer, "__builtin_va_arg_pack ()");
|
|
|
1202 }
|
|
|
1203 pp_character (buffer, ')');
|
|
|
1204
|
|
|
1205 op1 = CALL_EXPR_STATIC_CHAIN (node);
|
|
|
1206 if (op1)
|
|
|
1207 {
|
|
|
1208 pp_string (buffer, " [static-chain: ");
|
|
|
1209 dump_generic_node (buffer, op1, spc, flags, false);
|
|
|
1210 pp_character (buffer, ']');
|
|
|
1211 }
|
|
|
1212
|
|
|
1213 if (CALL_EXPR_RETURN_SLOT_OPT (node))
|
|
|
1214 pp_string (buffer, " [return slot optimization]");
|
|
|
1215 if (CALL_EXPR_TAILCALL (node))
|
|
|
1216 pp_string (buffer, " [tail call]");
|
|
|
1217 break;
|
|
|
1218
|
|
|
1219 case WITH_CLEANUP_EXPR:
|
|
|
1220 NIY;
|
|
|
1221 break;
|
|
|
1222
|
|
|
1223 case CLEANUP_POINT_EXPR:
|
|
|
1224 pp_string (buffer, "<<cleanup_point ");
|
|
|
1225 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1226 pp_string (buffer, ">>");
|
|
|
1227 break;
|
|
|
1228
|
|
|
1229 case PLACEHOLDER_EXPR:
|
|
|
1230 pp_string (buffer, "<PLACEHOLDER_EXPR ");
|
|
|
1231 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
|
|
|
1232 pp_character (buffer, '>');
|
|
|
1233 break;
|
|
|
1234
|
|
|
1235 /* Binary arithmetic and logic expressions. */
|
|
|
1236 case WIDEN_SUM_EXPR:
|
|
|
1237 case WIDEN_MULT_EXPR:
|
|
|
1238 case MULT_EXPR:
|
|
|
1239 case PLUS_EXPR:
|
|
|
1240 case POINTER_PLUS_EXPR:
|
|
|
1241 case MINUS_EXPR:
|
|
|
1242 case TRUNC_DIV_EXPR:
|
|
|
1243 case CEIL_DIV_EXPR:
|
|
|
1244 case FLOOR_DIV_EXPR:
|
|
|
1245 case ROUND_DIV_EXPR:
|
|
|
1246 case TRUNC_MOD_EXPR:
|
|
|
1247 case CEIL_MOD_EXPR:
|
|
|
1248 case FLOOR_MOD_EXPR:
|
|
|
1249 case ROUND_MOD_EXPR:
|
|
|
1250 case RDIV_EXPR:
|
|
|
1251 case EXACT_DIV_EXPR:
|
|
|
1252 case LSHIFT_EXPR:
|
|
|
1253 case RSHIFT_EXPR:
|
|
|
1254 case LROTATE_EXPR:
|
|
|
1255 case RROTATE_EXPR:
|
|
|
1256 case VEC_LSHIFT_EXPR:
|
|
|
1257 case VEC_RSHIFT_EXPR:
|
|
|
1258 case BIT_IOR_EXPR:
|
|
|
1259 case BIT_XOR_EXPR:
|
|
|
1260 case BIT_AND_EXPR:
|
|
|
1261 case TRUTH_ANDIF_EXPR:
|
|
|
1262 case TRUTH_ORIF_EXPR:
|
|
|
1263 case TRUTH_AND_EXPR:
|
|
|
1264 case TRUTH_OR_EXPR:
|
|
|
1265 case TRUTH_XOR_EXPR:
|
|
|
1266 case LT_EXPR:
|
|
|
1267 case LE_EXPR:
|
|
|
1268 case GT_EXPR:
|
|
|
1269 case GE_EXPR:
|
|
|
1270 case EQ_EXPR:
|
|
|
1271 case NE_EXPR:
|
|
|
1272 case UNLT_EXPR:
|
|
|
1273 case UNLE_EXPR:
|
|
|
1274 case UNGT_EXPR:
|
|
|
1275 case UNGE_EXPR:
|
|
|
1276 case UNEQ_EXPR:
|
|
|
1277 case LTGT_EXPR:
|
|
|
1278 case ORDERED_EXPR:
|
|
|
1279 case UNORDERED_EXPR:
|
|
|
1280 {
|
|
|
1281 const char *op = op_symbol (node);
|
|
|
1282 op0 = TREE_OPERAND (node, 0);
|
|
|
1283 op1 = TREE_OPERAND (node, 1);
|
|
|
1284
|
|
|
1285 /* When the operands are expressions with less priority,
|
|
|
1286 keep semantics of the tree representation. */
|
|
|
1287 if (op_prio (op0) <= op_prio (node))
|
|
|
1288 {
|
|
|
1289 pp_character (buffer, '(');
|
|
|
1290 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1291 pp_character (buffer, ')');
|
|
|
1292 }
|
|
|
1293 else
|
|
|
1294 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1295
|
|
|
1296 pp_space (buffer);
|
|
|
1297 pp_string (buffer, op);
|
|
|
1298 pp_space (buffer);
|
|
|
1299
|
|
|
1300 /* When the operands are expressions with less priority,
|
|
|
1301 keep semantics of the tree representation. */
|
|
|
1302 if (op_prio (op1) <= op_prio (node))
|
|
|
1303 {
|
|
|
1304 pp_character (buffer, '(');
|
|
|
1305 dump_generic_node (buffer, op1, spc, flags, false);
|
|
|
1306 pp_character (buffer, ')');
|
|
|
1307 }
|
|
|
1308 else
|
|
|
1309 dump_generic_node (buffer, op1, spc, flags, false);
|
|
|
1310 }
|
|
|
1311 break;
|
|
|
1312
|
|
|
1313 /* Unary arithmetic and logic expressions. */
|
|
|
1314 case NEGATE_EXPR:
|
|
|
1315 case BIT_NOT_EXPR:
|
|
|
1316 case TRUTH_NOT_EXPR:
|
|
|
1317 case ADDR_EXPR:
|
|
|
1318 case PREDECREMENT_EXPR:
|
|
|
1319 case PREINCREMENT_EXPR:
|
|
|
1320 case ALIGN_INDIRECT_REF:
|
|
|
1321 case MISALIGNED_INDIRECT_REF:
|
|
|
1322 case INDIRECT_REF:
|
|
|
1323 if (TREE_CODE (node) == ADDR_EXPR
|
|
|
1324 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
|
|
|
1325 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
|
|
|
1326 ; /* Do not output '&' for strings and function pointers. */
|
|
|
1327 else
|
|
|
1328 pp_string (buffer, op_symbol (node));
|
|
|
1329
|
|
|
1330 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
|
|
|
1331 {
|
|
|
1332 pp_character (buffer, '(');
|
|
|
1333 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1334 pp_character (buffer, ')');
|
|
|
1335 }
|
|
|
1336 else
|
|
|
1337 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1338
|
|
|
1339 if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
|
|
|
1340 {
|
|
|
1341 pp_string (buffer, "{misalignment: ");
|
|
|
1342 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1343 pp_character (buffer, '}');
|
|
|
1344 }
|
|
|
1345 break;
|
|
|
1346
|
|
|
1347 case POSTDECREMENT_EXPR:
|
|
|
1348 case POSTINCREMENT_EXPR:
|
|
|
1349 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
|
|
|
1350 {
|
|
|
1351 pp_character (buffer, '(');
|
|
|
1352 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1353 pp_character (buffer, ')');
|
|
|
1354 }
|
|
|
1355 else
|
|
|
1356 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1357 pp_string (buffer, op_symbol (node));
|
|
|
1358 break;
|
|
|
1359
|
|
|
1360 case MIN_EXPR:
|
|
|
1361 pp_string (buffer, "MIN_EXPR <");
|
|
|
1362 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1363 pp_string (buffer, ", ");
|
|
|
1364 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1365 pp_character (buffer, '>');
|
|
|
1366 break;
|
|
|
1367
|
|
|
1368 case MAX_EXPR:
|
|
|
1369 pp_string (buffer, "MAX_EXPR <");
|
|
|
1370 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1371 pp_string (buffer, ", ");
|
|
|
1372 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1373 pp_character (buffer, '>');
|
|
|
1374 break;
|
|
|
1375
|
|
|
1376 case ABS_EXPR:
|
|
|
1377 pp_string (buffer, "ABS_EXPR <");
|
|
|
1378 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1379 pp_character (buffer, '>');
|
|
|
1380 break;
|
|
|
1381
|
|
|
1382 case RANGE_EXPR:
|
|
|
1383 NIY;
|
|
|
1384 break;
|
|
|
1385
|
|
|
1386 case FIXED_CONVERT_EXPR:
|
|
|
1387 case FIX_TRUNC_EXPR:
|
|
|
1388 case FLOAT_EXPR:
|
|
|
1389 CASE_CONVERT:
|
|
|
1390 type = TREE_TYPE (node);
|
|
|
1391 op0 = TREE_OPERAND (node, 0);
|
|
|
1392 if (type != TREE_TYPE (op0))
|
|
|
1393 {
|
|
|
1394 pp_character (buffer, '(');
|
|
|
1395 dump_generic_node (buffer, type, spc, flags, false);
|
|
|
1396 pp_string (buffer, ") ");
|
|
|
1397 }
|
|
|
1398 if (op_prio (op0) < op_prio (node))
|
|
|
1399 pp_character (buffer, '(');
|
|
|
1400 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1401 if (op_prio (op0) < op_prio (node))
|
|
|
1402 pp_character (buffer, ')');
|
|
|
1403 break;
|
|
|
1404
|
|
|
1405 case VIEW_CONVERT_EXPR:
|
|
|
1406 pp_string (buffer, "VIEW_CONVERT_EXPR<");
|
|
|
1407 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
|
|
|
1408 pp_string (buffer, ">(");
|
|
|
1409 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1410 pp_character (buffer, ')');
|
|
|
1411 break;
|
|
|
1412
|
|
|
1413 case PAREN_EXPR:
|
|
|
1414 pp_string (buffer, "((");
|
|
|
1415 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1416 pp_string (buffer, "))");
|
|
|
1417 break;
|
|
|
1418
|
|
|
1419 case NON_LVALUE_EXPR:
|
|
|
1420 pp_string (buffer, "NON_LVALUE_EXPR <");
|
|
|
1421 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1422 pp_character (buffer, '>');
|
|
|
1423 break;
|
|
|
1424
|
|
|
1425 case SAVE_EXPR:
|
|
|
1426 pp_string (buffer, "SAVE_EXPR <");
|
|
|
1427 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1428 pp_character (buffer, '>');
|
|
|
1429 break;
|
|
|
1430
|
|
|
1431 case COMPLEX_EXPR:
|
|
|
1432 pp_string (buffer, "COMPLEX_EXPR <");
|
|
|
1433 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1434 pp_string (buffer, ", ");
|
|
|
1435 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1436 pp_string (buffer, ">");
|
|
|
1437 break;
|
|
|
1438
|
|
|
1439 case CONJ_EXPR:
|
|
|
1440 pp_string (buffer, "CONJ_EXPR <");
|
|
|
1441 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1442 pp_string (buffer, ">");
|
|
|
1443 break;
|
|
|
1444
|
|
|
1445 case REALPART_EXPR:
|
|
|
1446 pp_string (buffer, "REALPART_EXPR <");
|
|
|
1447 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1448 pp_string (buffer, ">");
|
|
|
1449 break;
|
|
|
1450
|
|
|
1451 case IMAGPART_EXPR:
|
|
|
1452 pp_string (buffer, "IMAGPART_EXPR <");
|
|
|
1453 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1454 pp_string (buffer, ">");
|
|
|
1455 break;
|
|
|
1456
|
|
|
1457 case VA_ARG_EXPR:
|
|
|
1458 pp_string (buffer, "VA_ARG_EXPR <");
|
|
|
1459 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1460 pp_string (buffer, ">");
|
|
|
1461 break;
|
|
|
1462
|
|
|
1463 case TRY_FINALLY_EXPR:
|
|
|
1464 case TRY_CATCH_EXPR:
|
|
|
1465 pp_string (buffer, "try");
|
|
|
1466 newline_and_indent (buffer, spc+2);
|
|
|
1467 pp_string (buffer, "{");
|
|
|
1468 newline_and_indent (buffer, spc+4);
|
|
|
1469 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
|
|
|
1470 newline_and_indent (buffer, spc+2);
|
|
|
1471 pp_string (buffer, "}");
|
|
|
1472 newline_and_indent (buffer, spc);
|
|
|
1473 pp_string (buffer,
|
|
|
1474 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
|
|
|
1475 newline_and_indent (buffer, spc+2);
|
|
|
1476 pp_string (buffer, "{");
|
|
|
1477 newline_and_indent (buffer, spc+4);
|
|
|
1478 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
|
|
|
1479 newline_and_indent (buffer, spc+2);
|
|
|
1480 pp_string (buffer, "}");
|
|
|
1481 is_expr = false;
|
|
|
1482 break;
|
|
|
1483
|
|
|
1484 case CATCH_EXPR:
|
|
|
1485 pp_string (buffer, "catch (");
|
|
|
1486 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
|
|
|
1487 pp_string (buffer, ")");
|
|
|
1488 newline_and_indent (buffer, spc+2);
|
|
|
1489 pp_string (buffer, "{");
|
|
|
1490 newline_and_indent (buffer, spc+4);
|
|
|
1491 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
|
|
|
1492 newline_and_indent (buffer, spc+2);
|
|
|
1493 pp_string (buffer, "}");
|
|
|
1494 is_expr = false;
|
|
|
1495 break;
|
|
|
1496
|
|
|
1497 case EH_FILTER_EXPR:
|
|
|
1498 pp_string (buffer, "<<<eh_filter (");
|
|
|
1499 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
|
|
|
1500 pp_string (buffer, ")>>>");
|
|
|
1501 newline_and_indent (buffer, spc+2);
|
|
|
1502 pp_string (buffer, "{");
|
|
|
1503 newline_and_indent (buffer, spc+4);
|
|
|
1504 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
|
|
|
1505 newline_and_indent (buffer, spc+2);
|
|
|
1506 pp_string (buffer, "}");
|
|
|
1507 is_expr = false;
|
|
|
1508 break;
|
|
|
1509
|
|
|
1510 case CHANGE_DYNAMIC_TYPE_EXPR:
|
|
|
1511 pp_string (buffer, "<<<change_dynamic_type (");
|
|
|
1512 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_NEW_TYPE (node), spc + 2,
|
|
|
1513 flags, false);
|
|
|
1514 pp_string (buffer, ") ");
|
|
|
1515 dump_generic_node (buffer, CHANGE_DYNAMIC_TYPE_LOCATION (node), spc + 2,
|
|
|
1516 flags, false);
|
|
|
1517 pp_string (buffer, ")>>>");
|
|
|
1518 is_expr = false;
|
|
|
1519 break;
|
|
|
1520
|
|
|
1521 case LABEL_EXPR:
|
|
|
1522 op0 = TREE_OPERAND (node, 0);
|
|
|
1523 /* If this is for break or continue, don't bother printing it. */
|
|
|
1524 if (DECL_NAME (op0))
|
|
|
1525 {
|
|
|
1526 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
|
|
|
1527 if (strcmp (name, "break") == 0
|
|
|
1528 || strcmp (name, "continue") == 0)
|
|
|
1529 break;
|
|
|
1530 }
|
|
|
1531 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1532 pp_character (buffer, ':');
|
|
|
1533 if (DECL_NONLOCAL (op0))
|
|
|
1534 pp_string (buffer, " [non-local]");
|
|
|
1535 break;
|
|
|
1536
|
|
|
1537 case EXC_PTR_EXPR:
|
|
|
1538 pp_string (buffer, "<<<exception object>>>");
|
|
|
1539 break;
|
|
|
1540
|
|
|
1541 case FILTER_EXPR:
|
|
|
1542 pp_string (buffer, "<<<filter object>>>");
|
|
|
1543 break;
|
|
|
1544
|
|
|
1545 case LOOP_EXPR:
|
|
|
1546 pp_string (buffer, "while (1)");
|
|
|
1547 if (!(flags & TDF_SLIM))
|
|
|
1548 {
|
|
|
1549 newline_and_indent (buffer, spc+2);
|
|
|
1550 pp_character (buffer, '{');
|
|
|
1551 newline_and_indent (buffer, spc+4);
|
|
|
1552 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
|
|
|
1553 newline_and_indent (buffer, spc+2);
|
|
|
1554 pp_character (buffer, '}');
|
|
|
1555 }
|
|
|
1556 is_expr = false;
|
|
|
1557 break;
|
|
|
1558
|
|
|
1559 case PREDICT_EXPR:
|
|
|
1560 pp_string (buffer, "// predicted ");
|
|
|
1561 if (PREDICT_EXPR_OUTCOME (node))
|
|
|
1562 pp_string (buffer, "likely by ");
|
|
|
1563 else
|
|
|
1564 pp_string (buffer, "unlikely by ");
|
|
|
1565 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
|
|
|
1566 pp_string (buffer, " predictor.");
|
|
|
1567 break;
|
|
|
1568
|
|
|
1569 case RETURN_EXPR:
|
|
|
1570 pp_string (buffer, "return");
|
|
|
1571 op0 = TREE_OPERAND (node, 0);
|
|
|
1572 if (op0)
|
|
|
1573 {
|
|
|
1574 pp_space (buffer);
|
|
|
1575 if (TREE_CODE (op0) == MODIFY_EXPR)
|
|
|
1576 dump_generic_node (buffer, TREE_OPERAND (op0, 1),
|
|
|
1577 spc, flags, false);
|
|
|
1578 else
|
|
|
1579 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1580 }
|
|
|
1581 break;
|
|
|
1582
|
|
|
1583 case EXIT_EXPR:
|
|
|
1584 pp_string (buffer, "if (");
|
|
|
1585 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1586 pp_string (buffer, ") break");
|
|
|
1587 break;
|
|
|
1588
|
|
|
1589 case SWITCH_EXPR:
|
|
|
1590 pp_string (buffer, "switch (");
|
|
|
1591 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
|
|
|
1592 pp_character (buffer, ')');
|
|
|
1593 if (!(flags & TDF_SLIM))
|
|
|
1594 {
|
|
|
1595 newline_and_indent (buffer, spc+2);
|
|
|
1596 pp_character (buffer, '{');
|
|
|
1597 if (SWITCH_BODY (node))
|
|
|
1598 {
|
|
|
1599 newline_and_indent (buffer, spc+4);
|
|
|
1600 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
|
|
|
1601 true);
|
|
|
1602 }
|
|
|
1603 else
|
|
|
1604 {
|
|
|
1605 tree vec = SWITCH_LABELS (node);
|
|
|
1606 size_t i, n = TREE_VEC_LENGTH (vec);
|
|
|
1607 for (i = 0; i < n; ++i)
|
|
|
1608 {
|
|
|
1609 tree elt = TREE_VEC_ELT (vec, i);
|
|
|
1610 newline_and_indent (buffer, spc+4);
|
|
|
1611 if (elt)
|
|
|
1612 {
|
|
|
1613 dump_generic_node (buffer, elt, spc+4, flags, false);
|
|
|
1614 pp_string (buffer, " goto ");
|
|
|
1615 dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
|
|
|
1616 flags, true);
|
|
|
1617 pp_semicolon (buffer);
|
|
|
1618 }
|
|
|
1619 else
|
|
|
1620 pp_string (buffer, "case ???: goto ???;");
|
|
|
1621 }
|
|
|
1622 }
|
|
|
1623 newline_and_indent (buffer, spc+2);
|
|
|
1624 pp_character (buffer, '}');
|
|
|
1625 }
|
|
|
1626 is_expr = false;
|
|
|
1627 break;
|
|
|
1628
|
|
|
1629 case GOTO_EXPR:
|
|
|
1630 op0 = GOTO_DESTINATION (node);
|
|
|
1631 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
|
|
|
1632 {
|
|
|
1633 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
|
|
|
1634 if (strcmp (name, "break") == 0
|
|
|
1635 || strcmp (name, "continue") == 0)
|
|
|
1636 {
|
|
|
1637 pp_string (buffer, name);
|
|
|
1638 break;
|
|
|
1639 }
|
|
|
1640 }
|
|
|
1641 pp_string (buffer, "goto ");
|
|
|
1642 dump_generic_node (buffer, op0, spc, flags, false);
|
|
|
1643 break;
|
|
|
1644
|
|
|
1645 case RESX_EXPR:
|
|
|
1646 pp_string (buffer, "resx ");
|
|
|
1647 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1648 break;
|
|
|
1649
|
|
|
1650 case ASM_EXPR:
|
|
|
1651 pp_string (buffer, "__asm__");
|
|
|
1652 if (ASM_VOLATILE_P (node))
|
|
|
1653 pp_string (buffer, " __volatile__");
|
|
|
1654 pp_character (buffer, '(');
|
|
|
1655 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
|
|
|
1656 pp_character (buffer, ':');
|
|
|
1657 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
|
|
|
1658 pp_character (buffer, ':');
|
|
|
1659 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
|
|
|
1660 if (ASM_CLOBBERS (node))
|
|
|
1661 {
|
|
|
1662 pp_character (buffer, ':');
|
|
|
1663 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
|
|
|
1664 }
|
|
|
1665 pp_string (buffer, ")");
|
|
|
1666 break;
|
|
|
1667
|
|
|
1668 case CASE_LABEL_EXPR:
|
|
|
1669 if (CASE_LOW (node) && CASE_HIGH (node))
|
|
|
1670 {
|
|
|
1671 pp_string (buffer, "case ");
|
|
|
1672 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
|
|
|
1673 pp_string (buffer, " ... ");
|
|
|
1674 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
|
|
|
1675 }
|
|
|
1676 else if (CASE_LOW (node))
|
|
|
1677 {
|
|
|
1678 pp_string (buffer, "case ");
|
|
|
1679 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
|
|
|
1680 }
|
|
|
1681 else
|
|
|
1682 pp_string (buffer, "default");
|
|
|
1683 pp_character (buffer, ':');
|
|
|
1684 break;
|
|
|
1685
|
|
|
1686 case OBJ_TYPE_REF:
|
|
|
1687 pp_string (buffer, "OBJ_TYPE_REF(");
|
|
|
1688 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
|
|
|
1689 pp_character (buffer, ';');
|
|
|
1690 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
|
|
|
1691 pp_character (buffer, '-');
|
|
|
1692 pp_character (buffer, '>');
|
|
|
1693 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
|
|
|
1694 pp_character (buffer, ')');
|
|
|
1695 break;
|
|
|
1696
|
|
|
1697 case SSA_NAME:
|
|
|
1698 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
|
|
|
1699 pp_string (buffer, "_");
|
|
|
1700 pp_decimal_int (buffer, SSA_NAME_VERSION (node));
|
|
|
1701 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
|
|
|
1702 pp_string (buffer, "(ab)");
|
|
|
1703 else if (SSA_NAME_IS_DEFAULT_DEF (node))
|
|
|
1704 pp_string (buffer, "(D)");
|
|
|
1705 break;
|
|
|
1706
|
|
|
1707 case WITH_SIZE_EXPR:
|
|
|
1708 pp_string (buffer, "WITH_SIZE_EXPR <");
|
|
|
1709 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1710 pp_string (buffer, ", ");
|
|
|
1711 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1712 pp_string (buffer, ">");
|
|
|
1713 break;
|
|
|
1714
|
|
|
1715 case ASSERT_EXPR:
|
|
|
1716 pp_string (buffer, "ASSERT_EXPR <");
|
|
|
1717 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
|
|
|
1718 pp_string (buffer, ", ");
|
|
|
1719 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
|
|
|
1720 pp_string (buffer, ">");
|
|
|
1721 break;
|
|
|
1722
|
|
|
1723 case SCEV_KNOWN:
|
|
|
1724 pp_string (buffer, "scev_known");
|
|
|
1725 break;
|
|
|
1726
|
|
|
1727 case SCEV_NOT_KNOWN:
|
|
|
1728 pp_string (buffer, "scev_not_known");
|
|
|
1729 break;
|
|
|
1730
|
|
|
1731 case POLYNOMIAL_CHREC:
|
|
|
1732 pp_string (buffer, "{");
|
|
|
1733 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
|
|
|
1734 pp_string (buffer, ", +, ");
|
|
|
1735 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
|
|
|
1736 pp_string (buffer, "}_");
|
|
|
1737 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
|
|
|
1738 is_stmt = false;
|
|
|
1739 break;
|
|
|
1740
|
|
|
1741 case REALIGN_LOAD_EXPR:
|
|
|
1742 pp_string (buffer, "REALIGN_LOAD <");
|
|
|
1743 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1744 pp_string (buffer, ", ");
|
|
|
1745 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1746 pp_string (buffer, ", ");
|
|
|
1747 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
|
|
|
1748 pp_string (buffer, ">");
|
|
|
1749 break;
|
|
|
1750
|
|
|
1751 case VEC_COND_EXPR:
|
|
|
1752 pp_string (buffer, " VEC_COND_EXPR < ");
|
|
|
1753 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1754 pp_string (buffer, " , ");
|
|
|
1755 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1756 pp_string (buffer, " , ");
|
|
|
1757 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
|
|
|
1758 pp_string (buffer, " > ");
|
|
|
1759 break;
|
|
|
1760
|
|
|
1761 case DOT_PROD_EXPR:
|
|
|
1762 pp_string (buffer, " DOT_PROD_EXPR < ");
|
|
|
1763 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1764 pp_string (buffer, ", ");
|
|
|
1765 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1766 pp_string (buffer, ", ");
|
|
|
1767 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
|
|
|
1768 pp_string (buffer, " > ");
|
|
|
1769 break;
|
|
|
1770
|
|
|
1771 case OMP_PARALLEL:
|
|
|
1772 pp_string (buffer, "#pragma omp parallel");
|
|
|
1773 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
|
|
|
1774
|
|
|
1775 dump_omp_body:
|
|
|
1776 if (!(flags & TDF_SLIM) && OMP_BODY (node))
|
|
|
1777 {
|
|
|
1778 newline_and_indent (buffer, spc + 2);
|
|
|
1779 pp_character (buffer, '{');
|
|
|
1780 newline_and_indent (buffer, spc + 4);
|
|
|
1781 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
|
|
|
1782 newline_and_indent (buffer, spc + 2);
|
|
|
1783 pp_character (buffer, '}');
|
|
|
1784 }
|
|
|
1785 is_expr = false;
|
|
|
1786 break;
|
|
|
1787
|
|
|
1788 case OMP_TASK:
|
|
|
1789 pp_string (buffer, "#pragma omp task");
|
|
|
1790 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
|
|
|
1791 goto dump_omp_body;
|
|
|
1792
|
|
|
1793 case OMP_FOR:
|
|
|
1794 pp_string (buffer, "#pragma omp for");
|
|
|
1795 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
|
|
|
1796
|
|
|
1797 if (!(flags & TDF_SLIM))
|
|
|
1798 {
|
|
|
1799 int i;
|
|
|
1800
|
|
|
1801 if (OMP_FOR_PRE_BODY (node))
|
|
|
1802 {
|
|
|
1803 newline_and_indent (buffer, spc + 2);
|
|
|
1804 pp_character (buffer, '{');
|
|
|
1805 spc += 4;
|
|
|
1806 newline_and_indent (buffer, spc);
|
|
|
1807 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
|
|
|
1808 spc, flags, false);
|
|
|
1809 }
|
|
|
1810 spc -= 2;
|
|
|
1811 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
|
|
|
1812 {
|
|
|
1813 spc += 2;
|
|
|
1814 newline_and_indent (buffer, spc);
|
|
|
1815 pp_string (buffer, "for (");
|
|
|
1816 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
|
|
|
1817 spc, flags, false);
|
|
|
1818 pp_string (buffer, "; ");
|
|
|
1819 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
|
|
|
1820 spc, flags, false);
|
|
|
1821 pp_string (buffer, "; ");
|
|
|
1822 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
|
|
|
1823 spc, flags, false);
|
|
|
1824 pp_string (buffer, ")");
|
|
|
1825 }
|
|
|
1826 if (OMP_FOR_BODY (node))
|
|
|
1827 {
|
|
|
1828 newline_and_indent (buffer, spc + 2);
|
|
|
1829 pp_character (buffer, '{');
|
|
|
1830 newline_and_indent (buffer, spc + 4);
|
|
|
1831 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
|
|
|
1832 false);
|
|
|
1833 newline_and_indent (buffer, spc + 2);
|
|
|
1834 pp_character (buffer, '}');
|
|
|
1835 }
|
|
|
1836 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
|
|
|
1837 if (OMP_FOR_PRE_BODY (node))
|
|
|
1838 {
|
|
|
1839 spc -= 4;
|
|
|
1840 newline_and_indent (buffer, spc + 2);
|
|
|
1841 pp_character (buffer, '}');
|
|
|
1842 }
|
|
|
1843 }
|
|
|
1844 is_expr = false;
|
|
|
1845 break;
|
|
|
1846
|
|
|
1847 case OMP_SECTIONS:
|
|
|
1848 pp_string (buffer, "#pragma omp sections");
|
|
|
1849 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
|
|
|
1850 goto dump_omp_body;
|
|
|
1851
|
|
|
1852 case OMP_SECTION:
|
|
|
1853 pp_string (buffer, "#pragma omp section");
|
|
|
1854 goto dump_omp_body;
|
|
|
1855
|
|
|
1856 case OMP_MASTER:
|
|
|
1857 pp_string (buffer, "#pragma omp master");
|
|
|
1858 goto dump_omp_body;
|
|
|
1859
|
|
|
1860 case OMP_ORDERED:
|
|
|
1861 pp_string (buffer, "#pragma omp ordered");
|
|
|
1862 goto dump_omp_body;
|
|
|
1863
|
|
|
1864 case OMP_CRITICAL:
|
|
|
1865 pp_string (buffer, "#pragma omp critical");
|
|
|
1866 if (OMP_CRITICAL_NAME (node))
|
|
|
1867 {
|
|
|
1868 pp_space (buffer);
|
|
|
1869 pp_character (buffer, '(');
|
|
|
1870 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
|
|
|
1871 flags, false);
|
|
|
1872 pp_character (buffer, ')');
|
|
|
1873 }
|
|
|
1874 goto dump_omp_body;
|
|
|
1875
|
|
|
1876 case OMP_ATOMIC:
|
|
|
1877 pp_string (buffer, "#pragma omp atomic");
|
|
|
1878 newline_and_indent (buffer, spc + 2);
|
|
|
1879 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1880 pp_space (buffer);
|
|
|
1881 pp_character (buffer, '=');
|
|
|
1882 pp_space (buffer);
|
|
|
1883 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1884 break;
|
|
|
1885
|
|
|
1886 case OMP_SINGLE:
|
|
|
1887 pp_string (buffer, "#pragma omp single");
|
|
|
1888 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
|
|
|
1889 goto dump_omp_body;
|
|
|
1890
|
|
|
1891 case OMP_CLAUSE:
|
|
|
1892 dump_omp_clause (buffer, node, spc, flags);
|
|
|
1893 is_expr = false;
|
|
|
1894 break;
|
|
|
1895
|
|
|
1896 case REDUC_MAX_EXPR:
|
|
|
1897 pp_string (buffer, " REDUC_MAX_EXPR < ");
|
|
|
1898 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1899 pp_string (buffer, " > ");
|
|
|
1900 break;
|
|
|
1901
|
|
|
1902 case REDUC_MIN_EXPR:
|
|
|
1903 pp_string (buffer, " REDUC_MIN_EXPR < ");
|
|
|
1904 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1905 pp_string (buffer, " > ");
|
|
|
1906 break;
|
|
|
1907
|
|
|
1908 case REDUC_PLUS_EXPR:
|
|
|
1909 pp_string (buffer, " REDUC_PLUS_EXPR < ");
|
|
|
1910 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1911 pp_string (buffer, " > ");
|
|
|
1912 break;
|
|
|
1913
|
|
|
1914 case VEC_WIDEN_MULT_HI_EXPR:
|
|
|
1915 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
|
|
|
1916 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1917 pp_string (buffer, ", ");
|
|
|
1918 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1919 pp_string (buffer, " > ");
|
|
|
1920 break;
|
|
|
1921
|
|
|
1922 case VEC_WIDEN_MULT_LO_EXPR:
|
|
|
1923 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
|
|
|
1924 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1925 pp_string (buffer, ", ");
|
|
|
1926 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1927 pp_string (buffer, " > ");
|
|
|
1928 break;
|
|
|
1929
|
|
|
1930 case VEC_UNPACK_HI_EXPR:
|
|
|
1931 pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
|
|
|
1932 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1933 pp_string (buffer, " > ");
|
|
|
1934 break;
|
|
|
1935
|
|
|
1936 case VEC_UNPACK_LO_EXPR:
|
|
|
1937 pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
|
|
|
1938 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1939 pp_string (buffer, " > ");
|
|
|
1940 break;
|
|
|
1941
|
|
|
1942 case VEC_UNPACK_FLOAT_HI_EXPR:
|
|
|
1943 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
|
|
|
1944 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1945 pp_string (buffer, " > ");
|
|
|
1946 break;
|
|
|
1947
|
|
|
1948 case VEC_UNPACK_FLOAT_LO_EXPR:
|
|
|
1949 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
|
|
|
1950 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1951 pp_string (buffer, " > ");
|
|
|
1952 break;
|
|
|
1953
|
|
|
1954 case VEC_PACK_TRUNC_EXPR:
|
|
|
1955 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
|
|
|
1956 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1957 pp_string (buffer, ", ");
|
|
|
1958 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1959 pp_string (buffer, " > ");
|
|
|
1960 break;
|
|
|
1961
|
|
|
1962 case VEC_PACK_SAT_EXPR:
|
|
|
1963 pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
|
|
|
1964 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1965 pp_string (buffer, ", ");
|
|
|
1966 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1967 pp_string (buffer, " > ");
|
|
|
1968 break;
|
|
|
1969
|
|
|
1970 case VEC_PACK_FIX_TRUNC_EXPR:
|
|
|
1971 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
|
|
|
1972 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
1973 pp_string (buffer, ", ");
|
|
|
1974 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
1975 pp_string (buffer, " > ");
|
|
|
1976 break;
|
|
|
1977
|
|
|
1978 case BLOCK:
|
|
|
1979 {
|
|
|
1980 tree t;
|
|
|
1981 pp_string (buffer, "BLOCK");
|
|
|
1982
|
|
|
1983 if (BLOCK_ABSTRACT (node))
|
|
|
1984 pp_string (buffer, " [abstract]");
|
|
|
1985
|
|
|
1986 if (TREE_ASM_WRITTEN (node))
|
|
|
1987 pp_string (buffer, " [written]");
|
|
|
1988
|
|
|
1989 newline_and_indent (buffer, spc + 2);
|
|
|
1990
|
|
|
1991 if (BLOCK_SUPERCONTEXT (node))
|
|
|
1992 {
|
|
|
1993 pp_string (buffer, "SUPERCONTEXT: ");
|
|
|
1994 if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
|
|
|
1995 pp_printf (buffer, "BLOCK %p",
|
|
|
1996 (void *)BLOCK_SUPERCONTEXT (node));
|
|
|
1997 else
|
|
|
1998 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
|
|
|
1999 false);
|
|
|
2000 newline_and_indent (buffer, spc + 2);
|
|
|
2001 }
|
|
|
2002
|
|
|
2003 if (BLOCK_SUBBLOCKS (node))
|
|
|
2004 {
|
|
|
2005 pp_string (buffer, "SUBBLOCKS: ");
|
|
|
2006 for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
|
|
|
2007 pp_printf (buffer, "%p ", (void *)t);
|
|
|
2008 newline_and_indent (buffer, spc + 2);
|
|
|
2009 }
|
|
|
2010
|
|
|
2011 if (BLOCK_VARS (node))
|
|
|
2012 {
|
|
|
2013 pp_string (buffer, "VARS: ");
|
|
|
2014 for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
|
|
|
2015 {
|
|
|
2016 dump_generic_node (buffer, t, 0, flags, false);
|
|
|
2017 pp_string (buffer, " ");
|
|
|
2018 }
|
|
|
2019 newline_and_indent (buffer, spc + 2);
|
|
|
2020 }
|
|
|
2021
|
|
|
2022 if (BLOCK_ABSTRACT_ORIGIN (node))
|
|
|
2023 {
|
|
|
2024 pp_string (buffer, "ABSTRACT_ORIGIN: ");
|
|
|
2025 if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
|
|
|
2026 pp_printf (buffer, "BLOCK %p",
|
|
|
2027 (void *)BLOCK_ABSTRACT_ORIGIN (node));
|
|
|
2028 else
|
|
|
2029 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
|
|
|
2030 false);
|
|
|
2031 newline_and_indent (buffer, spc + 2);
|
|
|
2032 }
|
|
|
2033 }
|
|
|
2034 break;
|
|
|
2035
|
|
|
2036 case VEC_EXTRACT_EVEN_EXPR:
|
|
|
2037 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
|
|
|
2038 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
2039 pp_string (buffer, ", ");
|
|
|
2040 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
2041 pp_string (buffer, " > ");
|
|
|
2042 break;
|
|
|
2043
|
|
|
2044 case VEC_EXTRACT_ODD_EXPR:
|
|
|
2045 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
|
|
|
2046 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
2047 pp_string (buffer, ", ");
|
|
|
2048 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
2049 pp_string (buffer, " > ");
|
|
|
2050 break;
|
|
|
2051
|
|
|
2052 case VEC_INTERLEAVE_HIGH_EXPR:
|
|
|
2053 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
|
|
|
2054 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
2055 pp_string (buffer, ", ");
|
|
|
2056 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
2057 pp_string (buffer, " > ");
|
|
|
2058 break;
|
|
|
2059
|
|
|
2060 case VEC_INTERLEAVE_LOW_EXPR:
|
|
|
2061 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
|
|
|
2062 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
|
|
|
2063 pp_string (buffer, ", ");
|
|
|
2064 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
|
|
|
2065 pp_string (buffer, " > ");
|
|
|
2066 break;
|
|
|
2067
|
|
|
2068 default:
|
|
|
2069 NIY;
|
|
|
2070 }
|
|
|
2071
|
|
|
2072 if (is_stmt && is_expr)
|
|
|
2073 pp_semicolon (buffer);
|
|
|
2074
|
|
|
2075 /* If we're building a diagnostic, the formatted text will be written
|
|
|
2076 into BUFFER's stream by the caller; otherwise, write it now. */
|
|
|
2077 if (!(flags & TDF_DIAGNOSTIC))
|
|
|
2078 pp_write_text_to_stream (buffer);
|
|
|
2079
|
|
|
2080 return spc;
|
|
|
2081 }
|
|
|
2082
|
|
|
2083 /* Print the declaration of a variable. */
|
|
|
2084
|
|
|
2085 void
|
|
|
2086 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
|
|
|
2087 {
|
|
|
2088 INDENT (spc);
|
|
|
2089
|
|
|
2090 if (TREE_CODE (t) == TYPE_DECL)
|
|
|
2091 pp_string (buffer, "typedef ");
|
|
|
2092
|
|
|
2093 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
|
|
|
2094 pp_string (buffer, "register ");
|
|
|
2095
|
|
|
2096 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
|
|
|
2097 pp_string (buffer, "extern ");
|
|
|
2098 else if (TREE_STATIC (t))
|
|
|
2099 pp_string (buffer, "static ");
|
|
|
2100
|
|
|
2101 /* Print the type and name. */
|
|
|
2102 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
|
|
|
2103 {
|
|
|
2104 tree tmp;
|
|
|
2105
|
|
|
2106 /* Print array's type. */
|
|
|
2107 tmp = TREE_TYPE (t);
|
|
|
2108 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
|
|
|
2109 tmp = TREE_TYPE (tmp);
|
|
|
2110 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
|
|
|
2111
|
|
|
2112 /* Print variable's name. */
|
|
|
2113 pp_space (buffer);
|
|
|
2114 dump_generic_node (buffer, t, spc, flags, false);
|
|
|
2115
|
|
|
2116 /* Print the dimensions. */
|
|
|
2117 tmp = TREE_TYPE (t);
|
|
|
2118 while (TREE_CODE (tmp) == ARRAY_TYPE)
|
|
|
2119 {
|
|
|
2120 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
|
|
|
2121 tmp = TREE_TYPE (tmp);
|
|
|
2122 }
|
|
|
2123 }
|
|
|
2124 else if (TREE_CODE (t) == FUNCTION_DECL)
|
|
|
2125 {
|
|
|
2126 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
|
|
|
2127 pp_space (buffer);
|
|
|
2128 dump_decl_name (buffer, t, flags);
|
|
|
2129 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
|
|
|
2130 }
|
|
|
2131 else
|
|
|
2132 {
|
|
|
2133 /* Print type declaration. */
|
|
|
2134 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
|
|
|
2135
|
|
|
2136 /* Print variable's name. */
|
|
|
2137 pp_space (buffer);
|
|
|
2138 dump_generic_node (buffer, t, spc, flags, false);
|
|
|
2139 }
|
|
|
2140
|
|
|
2141 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
|
|
|
2142 {
|
|
|
2143 pp_string (buffer, " __asm__ ");
|
|
|
2144 pp_character (buffer, '(');
|
|
|
2145 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
|
|
|
2146 pp_character (buffer, ')');
|
|
|
2147 }
|
|
|
2148
|
|
|
2149 /* The initial value of a function serves to determine whether the function
|
|
|
2150 is declared or defined. So the following does not apply to function
|
|
|
2151 nodes. */
|
|
|
2152 if (TREE_CODE (t) != FUNCTION_DECL)
|
|
|
2153 {
|
|
|
2154 /* Print the initial value. */
|
|
|
2155 if (DECL_INITIAL (t))
|
|
|
2156 {
|
|
|
2157 pp_space (buffer);
|
|
|
2158 pp_character (buffer, '=');
|
|
|
2159 pp_space (buffer);
|
|
|
2160 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
|
|
|
2161 }
|
|
|
2162 }
|
|
|
2163
|
|
|
2164 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
|
|
|
2165 {
|
|
|
2166 pp_string (buffer, " [value-expr: ");
|
|
|
2167 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
|
|
|
2168 pp_character (buffer, ']');
|
|
|
2169 }
|
|
|
2170
|
|
|
2171 pp_character (buffer, ';');
|
|
|
2172 }
|
|
|
2173
|
|
|
2174
|
|
|
2175 /* Prints a structure: name, fields, and methods.
|
|
|
2176 FIXME: Still incomplete. */
|
|
|
2177
|
|
|
2178 static void
|
|
|
2179 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
|
|
|
2180 {
|
|
|
2181 /* Print the name of the structure. */
|
|
|
2182 if (TYPE_NAME (node))
|
|
|
2183 {
|
|
|
2184 INDENT (spc);
|
|
|
2185 if (TREE_CODE (node) == RECORD_TYPE)
|
|
|
2186 pp_string (buffer, "struct ");
|
|
|
2187 else if ((TREE_CODE (node) == UNION_TYPE
|
|
|
2188 || TREE_CODE (node) == QUAL_UNION_TYPE))
|
|
|
2189 pp_string (buffer, "union ");
|
|
|
2190
|
|
|
2191 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
|
|
|
2192 }
|
|
|
2193
|
|
|
2194 /* Print the contents of the structure. */
|
|
|
2195 pp_newline (buffer);
|
|
|
2196 INDENT (spc);
|
|
|
2197 pp_character (buffer, '{');
|
|
|
2198 pp_newline (buffer);
|
|
|
2199
|
|
|
2200 /* Print the fields of the structure. */
|
|
|
2201 {
|
|
|
2202 tree tmp;
|
|
|
2203 tmp = TYPE_FIELDS (node);
|
|
|
2204 while (tmp)
|
|
|
2205 {
|
|
|
2206 /* Avoid to print recursively the structure. */
|
|
|
2207 /* FIXME : Not implemented correctly...,
|
|
|
2208 what about the case when we have a cycle in the contain graph? ...
|
|
|
2209 Maybe this could be solved by looking at the scope in which the
|
|
|
2210 structure was declared. */
|
|
|
2211 if (TREE_TYPE (tmp) != node
|
|
|
2212 || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
|
|
|
2213 && TREE_TYPE (TREE_TYPE (tmp)) != node))
|
|
|
2214 {
|
|
|
2215 print_declaration (buffer, tmp, spc+2, flags);
|
|
|
2216 pp_newline (buffer);
|
|
|
2217 }
|
|
|
2218 tmp = TREE_CHAIN (tmp);
|
|
|
2219 }
|
|
|
2220 }
|
|
|
2221 INDENT (spc);
|
|
|
2222 pp_character (buffer, '}');
|
|
|
2223 }
|
|
|
2224
|
|
|
2225 /* Return the priority of the operator CODE.
|
|
|
2226
|
|
|
2227 From lowest to highest precedence with either left-to-right (L-R)
|
|
|
2228 or right-to-left (R-L) associativity]:
|
|
|
2229
|
|
|
2230 1 [L-R] ,
|
|
|
2231 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
|
|
|
2232 3 [R-L] ?:
|
|
|
2233 4 [L-R] ||
|
|
|
2234 5 [L-R] &&
|
|
|
2235 6 [L-R] |
|
|
|
2236 7 [L-R] ^
|
|
|
2237 8 [L-R] &
|
|
|
2238 9 [L-R] == !=
|
|
|
2239 10 [L-R] < <= > >=
|
|
|
2240 11 [L-R] << >>
|
|
|
2241 12 [L-R] + -
|
|
|
2242 13 [L-R] * / %
|
|
|
2243 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
|
|
|
2244 15 [L-R] fn() [] -> .
|
|
|
2245
|
|
|
2246 unary +, - and * have higher precedence than the corresponding binary
|
|
|
2247 operators. */
|
|
|
2248
|
|
|
2249 int
|
|
|
2250 op_code_prio (enum tree_code code)
|
|
|
2251 {
|
|
|
2252 switch (code)
|
|
|
2253 {
|
|
|
2254 case TREE_LIST:
|
|
|
2255 case COMPOUND_EXPR:
|
|
|
2256 case BIND_EXPR:
|
|
|
2257 return 1;
|
|
|
2258
|
|
|
2259 case MODIFY_EXPR:
|
|
|
2260 case INIT_EXPR:
|
|
|
2261 return 2;
|
|
|
2262
|
|
|
2263 case COND_EXPR:
|
|
|
2264 return 3;
|
|
|
2265
|
|
|
2266 case TRUTH_OR_EXPR:
|
|
|
2267 case TRUTH_ORIF_EXPR:
|
|
|
2268 return 4;
|
|
|
2269
|
|
|
2270 case TRUTH_AND_EXPR:
|
|
|
2271 case TRUTH_ANDIF_EXPR:
|
|
|
2272 return 5;
|
|
|
2273
|
|
|
2274 case BIT_IOR_EXPR:
|
|
|
2275 return 6;
|
|
|
2276
|
|
|
2277 case BIT_XOR_EXPR:
|
|
|
2278 case TRUTH_XOR_EXPR:
|
|
|
2279 return 7;
|
|
|
2280
|
|
|
2281 case BIT_AND_EXPR:
|
|
|
2282 return 8;
|
|
|
2283
|
|
|
2284 case EQ_EXPR:
|
|
|
2285 case NE_EXPR:
|
|
|
2286 return 9;
|
|
|
2287
|
|
|
2288 case UNLT_EXPR:
|
|
|
2289 case UNLE_EXPR:
|
|
|
2290 case UNGT_EXPR:
|
|
|
2291 case UNGE_EXPR:
|
|
|
2292 case UNEQ_EXPR:
|
|
|
2293 case LTGT_EXPR:
|
|
|
2294 case ORDERED_EXPR:
|
|
|
2295 case UNORDERED_EXPR:
|
|
|
2296 case LT_EXPR:
|
|
|
2297 case LE_EXPR:
|
|
|
2298 case GT_EXPR:
|
|
|
2299 case GE_EXPR:
|
|
|
2300 return 10;
|
|
|
2301
|
|
|
2302 case LSHIFT_EXPR:
|
|
|
2303 case RSHIFT_EXPR:
|
|
|
2304 case LROTATE_EXPR:
|
|
|
2305 case RROTATE_EXPR:
|
|
|
2306 return 11;
|
|
|
2307
|
|
|
2308 case WIDEN_SUM_EXPR:
|
|
|
2309 case PLUS_EXPR:
|
|
|
2310 case POINTER_PLUS_EXPR:
|
|
|
2311 case MINUS_EXPR:
|
|
|
2312 return 12;
|
|
|
2313
|
|
|
2314 case VEC_WIDEN_MULT_HI_EXPR:
|
|
|
2315 case VEC_WIDEN_MULT_LO_EXPR:
|
|
|
2316 case WIDEN_MULT_EXPR:
|
|
|
2317 case DOT_PROD_EXPR:
|
|
|
2318 case MULT_EXPR:
|
|
|
2319 case TRUNC_DIV_EXPR:
|
|
|
2320 case CEIL_DIV_EXPR:
|
|
|
2321 case FLOOR_DIV_EXPR:
|
|
|
2322 case ROUND_DIV_EXPR:
|
|
|
2323 case RDIV_EXPR:
|
|
|
2324 case EXACT_DIV_EXPR:
|
|
|
2325 case TRUNC_MOD_EXPR:
|
|
|
2326 case CEIL_MOD_EXPR:
|
|
|
2327 case FLOOR_MOD_EXPR:
|
|
|
2328 case ROUND_MOD_EXPR:
|
|
|
2329 return 13;
|
|
|
2330
|
|
|
2331 case TRUTH_NOT_EXPR:
|
|
|
2332 case BIT_NOT_EXPR:
|
|
|
2333 case POSTINCREMENT_EXPR:
|
|
|
2334 case POSTDECREMENT_EXPR:
|
|
|
2335 case PREINCREMENT_EXPR:
|
|
|
2336 case PREDECREMENT_EXPR:
|
|
|
2337 case NEGATE_EXPR:
|
|
|
2338 case ALIGN_INDIRECT_REF:
|
|
|
2339 case MISALIGNED_INDIRECT_REF:
|
|
|
2340 case INDIRECT_REF:
|
|
|
2341 case ADDR_EXPR:
|
|
|
2342 case FLOAT_EXPR:
|
|
|
2343 CASE_CONVERT:
|
|
|
2344 case FIX_TRUNC_EXPR:
|
|
|
2345 case TARGET_EXPR:
|
|
|
2346 return 14;
|
|
|
2347
|
|
|
2348 case CALL_EXPR:
|
|
|
2349 case ARRAY_REF:
|
|
|
2350 case ARRAY_RANGE_REF:
|
|
|
2351 case COMPONENT_REF:
|
|
|
2352 return 15;
|
|
|
2353
|
|
|
2354 /* Special expressions. */
|
|
|
2355 case MIN_EXPR:
|
|
|
2356 case MAX_EXPR:
|
|
|
2357 case ABS_EXPR:
|
|
|
2358 case REALPART_EXPR:
|
|
|
2359 case IMAGPART_EXPR:
|
|
|
2360 case REDUC_MAX_EXPR:
|
|
|
2361 case REDUC_MIN_EXPR:
|
|
|
2362 case REDUC_PLUS_EXPR:
|
|
|
2363 case VEC_LSHIFT_EXPR:
|
|
|
2364 case VEC_RSHIFT_EXPR:
|
|
|
2365 case VEC_UNPACK_HI_EXPR:
|
|
|
2366 case VEC_UNPACK_LO_EXPR:
|
|
|
2367 case VEC_UNPACK_FLOAT_HI_EXPR:
|
|
|
2368 case VEC_UNPACK_FLOAT_LO_EXPR:
|
|
|
2369 case VEC_PACK_TRUNC_EXPR:
|
|
|
2370 case VEC_PACK_SAT_EXPR:
|
|
|
2371 return 16;
|
|
|
2372
|
|
|
2373 default:
|
|
|
2374 /* Return an arbitrarily high precedence to avoid surrounding single
|
|
|
2375 VAR_DECLs in ()s. */
|
|
|
2376 return 9999;
|
|
|
2377 }
|
|
|
2378 }
|
|
|
2379
|
|
|
2380 /* Return the priority of the operator OP. */
|
|
|
2381
|
|
|
2382 int
|
|
|
2383 op_prio (const_tree op)
|
|
|
2384 {
|
|
|
2385 enum tree_code code;
|
|
|
2386
|
|
|
2387 if (op == NULL)
|
|
|
2388 return 9999;
|
|
|
2389
|
|
|
2390 code = TREE_CODE (op);
|
|
|
2391 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
|
|
|
2392 return op_prio (TREE_OPERAND (op, 0));
|
|
|
2393
|
|
|
2394 return op_code_prio (code);
|
|
|
2395 }
|
|
|
2396
|
|
|
2397 /* Return the symbol associated with operator CODE. */
|
|
|
2398
|
|
|
2399 const char *
|
|
|
2400 op_symbol_code (enum tree_code code)
|
|
|
2401 {
|
|
|
2402 switch (code)
|
|
|
2403 {
|
|
|
2404 case MODIFY_EXPR:
|
|
|
2405 return "=";
|
|
|
2406
|
|
|
2407 case TRUTH_OR_EXPR:
|
|
|
2408 case TRUTH_ORIF_EXPR:
|
|
|
2409 return "||";
|
|
|
2410
|
|
|
2411 case TRUTH_AND_EXPR:
|
|
|
2412 case TRUTH_ANDIF_EXPR:
|
|
|
2413 return "&&";
|
|
|
2414
|
|
|
2415 case BIT_IOR_EXPR:
|
|
|
2416 return "|";
|
|
|
2417
|
|
|
2418 case TRUTH_XOR_EXPR:
|
|
|
2419 case BIT_XOR_EXPR:
|
|
|
2420 return "^";
|
|
|
2421
|
|
|
2422 case ADDR_EXPR:
|
|
|
2423 case BIT_AND_EXPR:
|
|
|
2424 return "&";
|
|
|
2425
|
|
|
2426 case ORDERED_EXPR:
|
|
|
2427 return "ord";
|
|
|
2428 case UNORDERED_EXPR:
|
|
|
2429 return "unord";
|
|
|
2430
|
|
|
2431 case EQ_EXPR:
|
|
|
2432 return "==";
|
|
|
2433 case UNEQ_EXPR:
|
|
|
2434 return "u==";
|
|
|
2435
|
|
|
2436 case NE_EXPR:
|
|
|
2437 return "!=";
|
|
|
2438
|
|
|
2439 case LT_EXPR:
|
|
|
2440 return "<";
|
|
|
2441 case UNLT_EXPR:
|
|
|
2442 return "u<";
|
|
|
2443
|
|
|
2444 case LE_EXPR:
|
|
|
2445 return "<=";
|
|
|
2446 case UNLE_EXPR:
|
|
|
2447 return "u<=";
|
|
|
2448
|
|
|
2449 case GT_EXPR:
|
|
|
2450 return ">";
|
|
|
2451 case UNGT_EXPR:
|
|
|
2452 return "u>";
|
|
|
2453
|
|
|
2454 case GE_EXPR:
|
|
|
2455 return ">=";
|
|
|
2456 case UNGE_EXPR:
|
|
|
2457 return "u>=";
|
|
|
2458
|
|
|
2459 case LTGT_EXPR:
|
|
|
2460 return "<>";
|
|
|
2461
|
|
|
2462 case LSHIFT_EXPR:
|
|
|
2463 return "<<";
|
|
|
2464
|
|
|
2465 case RSHIFT_EXPR:
|
|
|
2466 return ">>";
|
|
|
2467
|
|
|
2468 case LROTATE_EXPR:
|
|
|
2469 return "r<<";
|
|
|
2470
|
|
|
2471 case RROTATE_EXPR:
|
|
|
2472 return "r>>";
|
|
|
2473
|
|
|
2474 case VEC_LSHIFT_EXPR:
|
|
|
2475 return "v<<";
|
|
|
2476
|
|
|
2477 case VEC_RSHIFT_EXPR:
|
|
|
2478 return "v>>";
|
|
|
2479
|
|
|
2480 case POINTER_PLUS_EXPR:
|
|
|
2481 return "+";
|
|
|
2482
|
|
|
2483 case PLUS_EXPR:
|
|
|
2484 return "+";
|
|
|
2485
|
|
|
2486 case REDUC_PLUS_EXPR:
|
|
|
2487 return "r+";
|
|
|
2488
|
|
|
2489 case WIDEN_SUM_EXPR:
|
|
|
2490 return "w+";
|
|
|
2491
|
|
|
2492 case WIDEN_MULT_EXPR:
|
|
|
2493 return "w*";
|
|
|
2494
|
|
|
2495 case NEGATE_EXPR:
|
|
|
2496 case MINUS_EXPR:
|
|
|
2497 return "-";
|
|
|
2498
|
|
|
2499 case BIT_NOT_EXPR:
|
|
|
2500 return "~";
|
|
|
2501
|
|
|
2502 case TRUTH_NOT_EXPR:
|
|
|
2503 return "!";
|
|
|
2504
|
|
|
2505 case MULT_EXPR:
|
|
|
2506 case INDIRECT_REF:
|
|
|
2507 return "*";
|
|
|
2508
|
|
|
2509 case ALIGN_INDIRECT_REF:
|
|
|
2510 return "A*";
|
|
|
2511
|
|
|
2512 case MISALIGNED_INDIRECT_REF:
|
|
|
2513 return "M*";
|
|
|
2514
|
|
|
2515 case TRUNC_DIV_EXPR:
|
|
|
2516 case RDIV_EXPR:
|
|
|
2517 return "/";
|
|
|
2518
|
|
|
2519 case CEIL_DIV_EXPR:
|
|
|
2520 return "/[cl]";
|
|
|
2521
|
|
|
2522 case FLOOR_DIV_EXPR:
|
|
|
2523 return "/[fl]";
|
|
|
2524
|
|
|
2525 case ROUND_DIV_EXPR:
|
|
|
2526 return "/[rd]";
|
|
|
2527
|
|
|
2528 case EXACT_DIV_EXPR:
|
|
|
2529 return "/[ex]";
|
|
|
2530
|
|
|
2531 case TRUNC_MOD_EXPR:
|
|
|
2532 return "%";
|
|
|
2533
|
|
|
2534 case CEIL_MOD_EXPR:
|
|
|
2535 return "%[cl]";
|
|
|
2536
|
|
|
2537 case FLOOR_MOD_EXPR:
|
|
|
2538 return "%[fl]";
|
|
|
2539
|
|
|
2540 case ROUND_MOD_EXPR:
|
|
|
2541 return "%[rd]";
|
|
|
2542
|
|
|
2543 case PREDECREMENT_EXPR:
|
|
|
2544 return " --";
|
|
|
2545
|
|
|
2546 case PREINCREMENT_EXPR:
|
|
|
2547 return " ++";
|
|
|
2548
|
|
|
2549 case POSTDECREMENT_EXPR:
|
|
|
2550 return "-- ";
|
|
|
2551
|
|
|
2552 case POSTINCREMENT_EXPR:
|
|
|
2553 return "++ ";
|
|
|
2554
|
|
|
2555 case MAX_EXPR:
|
|
|
2556 return "max";
|
|
|
2557
|
|
|
2558 case MIN_EXPR:
|
|
|
2559 return "min";
|
|
|
2560
|
|
|
2561 default:
|
|
|
2562 return "<<< ??? >>>";
|
|
|
2563 }
|
|
|
2564 }
|
|
|
2565
|
|
|
2566 /* Return the symbol associated with operator OP. */
|
|
|
2567
|
|
|
2568 static const char *
|
|
|
2569 op_symbol (const_tree op)
|
|
|
2570 {
|
|
|
2571 return op_symbol_code (TREE_CODE (op));
|
|
|
2572 }
|
|
|
2573
|
|
|
2574 /* Prints the name of a CALL_EXPR. */
|
|
|
2575
|
|
|
2576 static void
|
|
|
2577 print_call_name (pretty_printer *buffer, const_tree node)
|
|
|
2578 {
|
|
|
2579 tree op0;
|
|
|
2580
|
|
|
2581 gcc_assert (TREE_CODE (node) == CALL_EXPR);
|
|
|
2582
|
|
|
2583 op0 = CALL_EXPR_FN (node);
|
|
|
2584
|
|
|
2585 if (TREE_CODE (op0) == NON_LVALUE_EXPR)
|
|
|
2586 op0 = TREE_OPERAND (op0, 0);
|
|
|
2587
|
|
|
2588 switch (TREE_CODE (op0))
|
|
|
2589 {
|
|
|
2590 case VAR_DECL:
|
|
|
2591 case PARM_DECL:
|
|
|
2592 dump_function_name (buffer, op0);
|
|
|
2593 break;
|
|
|
2594
|
|
|
2595 case ADDR_EXPR:
|
|
|
2596 case INDIRECT_REF:
|
|
|
2597 case NOP_EXPR:
|
|
|
2598 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
|
|
|
2599 break;
|
|
|
2600
|
|
|
2601 case COND_EXPR:
|
|
|
2602 pp_string (buffer, "(");
|
|
|
2603 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
|
|
|
2604 pp_string (buffer, ") ? ");
|
|
|
2605 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
|
|
|
2606 pp_string (buffer, " : ");
|
|
|
2607 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
|
|
|
2608 break;
|
|
|
2609
|
|
|
2610 case COMPONENT_REF:
|
|
|
2611 /* The function is a pointer contained in a structure. */
|
|
|
2612 if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
|
|
|
2613 TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
|
|
|
2614 dump_function_name (buffer, TREE_OPERAND (op0, 1));
|
|
|
2615 else
|
|
|
2616 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
|
|
|
2617 /* else
|
|
|
2618 We can have several levels of structures and a function
|
|
|
2619 pointer inside. This is not implemented yet... */
|
|
|
2620 /* NIY;*/
|
|
|
2621 break;
|
|
|
2622
|
|
|
2623 case ARRAY_REF:
|
|
|
2624 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
|
|
|
2625 dump_function_name (buffer, TREE_OPERAND (op0, 0));
|
|
|
2626 else
|
|
|
2627 dump_generic_node (buffer, op0, 0, 0, false);
|
|
|
2628 break;
|
|
|
2629
|
|
|
2630 case SSA_NAME:
|
|
|
2631 case OBJ_TYPE_REF:
|
|
|
2632 dump_generic_node (buffer, op0, 0, 0, false);
|
|
|
2633 break;
|
|
|
2634
|
|
|
2635 default:
|
|
|
2636 NIY;
|
|
|
2637 }
|
|
|
2638 }
|
|
|
2639
|
|
|
2640 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */
|
|
|
2641
|
|
|
2642 static void
|
|
|
2643 pretty_print_string (pretty_printer *buffer, const char *str)
|
|
|
2644 {
|
|
|
2645 if (str == NULL)
|
|
|
2646 return;
|
|
|
2647
|
|
|
2648 while (*str)
|
|
|
2649 {
|
|
|
2650 switch (str[0])
|
|
|
2651 {
|
|
|
2652 case '\b':
|
|
|
2653 pp_string (buffer, "\\b");
|
|
|
2654 break;
|
|
|
2655
|
|
|
2656 case '\f':
|
|
|
2657 pp_string (buffer, "\\f");
|
|
|
2658 break;
|
|
|
2659
|
|
|
2660 case '\n':
|
|
|
2661 pp_string (buffer, "\\n");
|
|
|
2662 break;
|
|
|
2663
|
|
|
2664 case '\r':
|
|
|
2665 pp_string (buffer, "\\r");
|
|
|
2666 break;
|
|
|
2667
|
|
|
2668 case '\t':
|
|
|
2669 pp_string (buffer, "\\t");
|
|
|
2670 break;
|
|
|
2671
|
|
|
2672 case '\v':
|
|
|
2673 pp_string (buffer, "\\v");
|
|
|
2674 break;
|
|
|
2675
|
|
|
2676 case '\\':
|
|
|
2677 pp_string (buffer, "\\\\");
|
|
|
2678 break;
|
|
|
2679
|
|
|
2680 case '\"':
|
|
|
2681 pp_string (buffer, "\\\"");
|
|
|
2682 break;
|
|
|
2683
|
|
|
2684 case '\'':
|
|
|
2685 pp_string (buffer, "\\'");
|
|
|
2686 break;
|
|
|
2687
|
|
|
2688 /* No need to handle \0; the loop terminates on \0. */
|
|
|
2689
|
|
|
2690 case '\1':
|
|
|
2691 pp_string (buffer, "\\1");
|
|
|
2692 break;
|
|
|
2693
|
|
|
2694 case '\2':
|
|
|
2695 pp_string (buffer, "\\2");
|
|
|
2696 break;
|
|
|
2697
|
|
|
2698 case '\3':
|
|
|
2699 pp_string (buffer, "\\3");
|
|
|
2700 break;
|
|
|
2701
|
|
|
2702 case '\4':
|
|
|
2703 pp_string (buffer, "\\4");
|
|
|
2704 break;
|
|
|
2705
|
|
|
2706 case '\5':
|
|
|
2707 pp_string (buffer, "\\5");
|
|
|
2708 break;
|
|
|
2709
|
|
|
2710 case '\6':
|
|
|
2711 pp_string (buffer, "\\6");
|
|
|
2712 break;
|
|
|
2713
|
|
|
2714 case '\7':
|
|
|
2715 pp_string (buffer, "\\7");
|
|
|
2716 break;
|
|
|
2717
|
|
|
2718 default:
|
|
|
2719 pp_character (buffer, str[0]);
|
|
|
2720 break;
|
|
|
2721 }
|
|
|
2722 str++;
|
|
|
2723 }
|
|
|
2724 }
|
|
|
2725
|
|
|
2726 static void
|
|
|
2727 maybe_init_pretty_print (FILE *file)
|
|
|
2728 {
|
|
|
2729 if (!initialized)
|
|
|
2730 {
|
|
|
2731 pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
|
|
|
2732 pp_needs_newline (&buffer) = true;
|
|
|
2733 initialized = 1;
|
|
|
2734 }
|
|
|
2735
|
|
|
2736 buffer.buffer->stream = file;
|
|
|
2737 }
|
|
|
2738
|
|
|
2739 static void
|
|
|
2740 newline_and_indent (pretty_printer *buffer, int spc)
|
|
|
2741 {
|
|
|
2742 pp_newline (buffer);
|
|
|
2743 INDENT (spc);
|
|
|
2744 }
|
