1 | /* Pretty formatting of GENERIC trees in C syntax. |
2 | Copyright (C) 2001-2024 Free Software Foundation, Inc. |
3 | Adapted from c-pretty-print.cc by Diego Novillo <dnovillo@redhat.com> |
4 | |
5 | This file is part of GCC. |
6 | |
7 | GCC is free software; you can redistribute it and/or modify it under |
8 | the terms of the GNU General Public License as published by the Free |
9 | Software Foundation; either version 3, or (at your option) any later |
10 | version. |
11 | |
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
15 | for more details. |
16 | |
17 | You should have received a copy of the GNU General Public License |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ |
20 | |
21 | #include "config.h" |
22 | #include "system.h" |
23 | #include "coretypes.h" |
24 | #include "backend.h" |
25 | #include "rtl.h" |
26 | #include "tree.h" |
27 | #include "predict.h" |
28 | #include "cgraph.h" |
29 | #include "tree-pretty-print.h" |
30 | #include "stor-layout.h" |
31 | #include "langhooks.h" |
32 | #include "tree-iterator.h" |
33 | #include "dumpfile.h" |
34 | #include "internal-fn.h" |
35 | #include "gomp-constants.h" |
36 | #include "gimple.h" |
37 | #include "fold-const.h" |
38 | #include "omp-general.h" |
39 | |
40 | /* Routines in this file get invoked via the default tree printer |
41 | used by diagnostics and thus they are called from pp_printf which |
42 | isn't reentrant. Avoid using pp_printf in this file. */ |
43 | #pragma GCC poison pp_printf |
44 | |
45 | /* Disable warnings about quoting issues in the pp_xxx calls below |
46 | that (intentionally) don't follow GCC diagnostic conventions. */ |
47 | #if __GNUC__ >= 10 |
48 | # pragma GCC diagnostic push |
49 | # pragma GCC diagnostic ignored "-Wformat-diag" |
50 | #endif |
51 | |
52 | /* Local functions, macros and variables. */ |
53 | static const char *op_symbol (const_tree, dump_flags_t = TDF_NONE); |
54 | static void newline_and_indent (pretty_printer *, int); |
55 | static void maybe_init_pretty_print (FILE *); |
56 | static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t); |
57 | static void do_niy (pretty_printer *, const_tree, int, dump_flags_t); |
58 | |
59 | #define INDENT(SPACE) do { \ |
60 | int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0) |
61 | |
62 | #define NIY do_niy (pp, node, spc, flags) |
63 | |
64 | static pretty_printer *tree_pp; |
65 | |
66 | /* Try to print something for an unknown tree code. */ |
67 | |
68 | static void |
69 | do_niy (pretty_printer *pp, const_tree node, int spc, dump_flags_t flags) |
70 | { |
71 | int i, len; |
72 | |
73 | pp_string (pp, "<<< Unknown tree: " ); |
74 | pp_string (pp, get_tree_code_name (TREE_CODE (node))); |
75 | |
76 | if (EXPR_P (node)) |
77 | { |
78 | len = TREE_OPERAND_LENGTH (node); |
79 | for (i = 0; i < len; ++i) |
80 | { |
81 | newline_and_indent (pp, spc+2); |
82 | dump_generic_node (pp, TREE_OPERAND (node, i), spc+2, flags, false); |
83 | } |
84 | } |
85 | |
86 | pp_string (pp, " >>>" ); |
87 | } |
88 | |
89 | /* Debugging function to print out a generic expression. */ |
90 | |
91 | DEBUG_FUNCTION void |
92 | debug_generic_expr (tree t) |
93 | { |
94 | print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); |
95 | fprintf (stderr, format: "\n" ); |
96 | } |
97 | |
98 | /* Debugging function to print out a generic statement. */ |
99 | |
100 | DEBUG_FUNCTION void |
101 | debug_generic_stmt (tree t) |
102 | { |
103 | print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); |
104 | fprintf (stderr, format: "\n" ); |
105 | } |
106 | |
107 | /* Debugging function to print out a chain of trees . */ |
108 | |
109 | DEBUG_FUNCTION void |
110 | debug_tree_chain (tree t) |
111 | { |
112 | hash_set<tree> seen; |
113 | |
114 | while (t) |
115 | { |
116 | print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
117 | fprintf (stderr, format: " " ); |
118 | t = TREE_CHAIN (t); |
119 | if (seen.add (k: t)) |
120 | { |
121 | fprintf (stderr, format: "... [cycled back to " ); |
122 | print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
123 | fprintf (stderr, format: "]" ); |
124 | break; |
125 | } |
126 | } |
127 | fprintf (stderr, format: "\n" ); |
128 | } |
129 | |
130 | /* Prints declaration DECL to the FILE with details specified by FLAGS. */ |
131 | void |
132 | print_generic_decl (FILE *file, tree decl, dump_flags_t flags) |
133 | { |
134 | maybe_init_pretty_print (file); |
135 | print_declaration (tree_pp, decl, 2, flags); |
136 | pp_write_text_to_stream (tree_pp); |
137 | } |
138 | |
139 | /* Print tree T, and its successors, on file FILE. FLAGS specifies details |
140 | to show in the dump. See TDF_* in dumpfile.h. */ |
141 | |
142 | void |
143 | print_generic_stmt (FILE *file, tree t, dump_flags_t flags) |
144 | { |
145 | maybe_init_pretty_print (file); |
146 | dump_generic_node (tree_pp, t, 0, flags, true); |
147 | pp_newline_and_flush (tree_pp); |
148 | } |
149 | |
150 | /* Print tree T, and its successors, on file FILE. FLAGS specifies details |
151 | to show in the dump. See TDF_* in dumpfile.h. The output is indented by |
152 | INDENT spaces. */ |
153 | |
154 | void |
155 | print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent) |
156 | { |
157 | int i; |
158 | |
159 | maybe_init_pretty_print (file); |
160 | |
161 | for (i = 0; i < indent; i++) |
162 | pp_space (tree_pp); |
163 | dump_generic_node (tree_pp, t, indent, flags, true); |
164 | pp_newline_and_flush (tree_pp); |
165 | } |
166 | |
167 | /* Print a single expression T on file FILE. FLAGS specifies details to show |
168 | in the dump. See TDF_* in dumpfile.h. */ |
169 | |
170 | void |
171 | print_generic_expr (FILE *file, tree t, dump_flags_t flags) |
172 | { |
173 | maybe_init_pretty_print (file); |
174 | dump_generic_node (tree_pp, t, 0, flags, false); |
175 | pp_flush (tree_pp); |
176 | } |
177 | |
178 | /* Print a single expression T to string, and return it. The caller |
179 | must free the returned memory. */ |
180 | |
181 | char * |
182 | print_generic_expr_to_str (tree t) |
183 | { |
184 | pretty_printer pp; |
185 | dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false); |
186 | return xstrdup (pp_formatted_text (&pp)); |
187 | } |
188 | |
189 | /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences |
190 | in it are replaced with Dxxxx, as long as they are at the start or |
191 | preceded by $ and at the end or followed by $. See make_fancy_name |
192 | in tree-sra.cc. */ |
193 | |
194 | static void |
195 | dump_fancy_name (pretty_printer *pp, tree name) |
196 | { |
197 | int cnt = 0; |
198 | int length = IDENTIFIER_LENGTH (name); |
199 | const char *n = IDENTIFIER_POINTER (name); |
200 | do |
201 | { |
202 | n = strchr (s: n, c: 'D'); |
203 | if (n == NULL) |
204 | break; |
205 | if (ISDIGIT (n[1]) |
206 | && (n == IDENTIFIER_POINTER (name) || n[-1] == '$')) |
207 | { |
208 | int l = 2; |
209 | while (ISDIGIT (n[l])) |
210 | l++; |
211 | if (n[l] == '\0' || n[l] == '$') |
212 | { |
213 | cnt++; |
214 | length += 5 - l; |
215 | } |
216 | n += l; |
217 | } |
218 | else |
219 | n++; |
220 | } |
221 | while (1); |
222 | if (cnt == 0) |
223 | { |
224 | pp_tree_identifier (pp, name); |
225 | return; |
226 | } |
227 | |
228 | char *str = XNEWVEC (char, length + 1); |
229 | char *p = str; |
230 | const char *q; |
231 | q = n = IDENTIFIER_POINTER (name); |
232 | do |
233 | { |
234 | q = strchr (s: q, c: 'D'); |
235 | if (q == NULL) |
236 | break; |
237 | if (ISDIGIT (q[1]) |
238 | && (q == IDENTIFIER_POINTER (name) || q[-1] == '$')) |
239 | { |
240 | int l = 2; |
241 | while (ISDIGIT (q[l])) |
242 | l++; |
243 | if (q[l] == '\0' || q[l] == '$') |
244 | { |
245 | memcpy (dest: p, src: n, n: q - n); |
246 | memcpy (dest: p + (q - n), src: "Dxxxx" , n: 5); |
247 | p += (q - n) + 5; |
248 | n = q + l; |
249 | } |
250 | q += l; |
251 | } |
252 | else |
253 | q++; |
254 | } |
255 | while (1); |
256 | memcpy (dest: p, src: n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name))); |
257 | str[length] = '\0'; |
258 | if (pp_translate_identifiers (pp)) |
259 | { |
260 | const char *text = identifier_to_locale (str); |
261 | pp_append_text (pp, text, text + strlen (s: text)); |
262 | } |
263 | else |
264 | pp_append_text (pp, str, str + length); |
265 | XDELETEVEC (str); |
266 | } |
267 | |
268 | /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set |
269 | in FLAGS. */ |
270 | |
271 | static void |
272 | dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags) |
273 | { |
274 | tree name = DECL_NAME (node); |
275 | if (name) |
276 | { |
277 | if ((flags & TDF_ASMNAME) |
278 | && HAS_DECL_ASSEMBLER_NAME_P (node) |
279 | && DECL_ASSEMBLER_NAME_SET_P (node)) |
280 | pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node)); |
281 | /* For -fcompare-debug don't dump DECL_NAMELESS names at all, |
282 | -g might have created more fancy names and their indexes |
283 | could get out of sync. Usually those should be DECL_IGNORED_P |
284 | too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy |
285 | names, let's hope those never get out of sync after doing the |
286 | dump_fancy_name sanitization. */ |
287 | else if ((flags & TDF_COMPARE_DEBUG) |
288 | && DECL_NAMELESS (node) |
289 | && DECL_IGNORED_P (node)) |
290 | name = NULL_TREE; |
291 | /* For DECL_NAMELESS names look for embedded uids in the |
292 | names and sanitize them for TDF_NOUID. */ |
293 | else if ((flags & TDF_NOUID) && DECL_NAMELESS (node)) |
294 | dump_fancy_name (pp, name); |
295 | else |
296 | pp_tree_identifier (pp, name); |
297 | } |
298 | char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.'; |
299 | if ((flags & TDF_UID) || name == NULL_TREE) |
300 | { |
301 | if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) |
302 | { |
303 | pp_character (pp, 'L'); |
304 | pp_character (pp, uid_sep); |
305 | pp_decimal_int (pp, (int) LABEL_DECL_UID (node)); |
306 | } |
307 | else if (TREE_CODE (node) == DEBUG_EXPR_DECL) |
308 | { |
309 | if (flags & TDF_NOUID) |
310 | pp_string (pp, "D#xxxx" ); |
311 | else |
312 | { |
313 | pp_string (pp, "D#" ); |
314 | pp_decimal_int (pp, (int) DEBUG_TEMP_UID (node)); |
315 | } |
316 | } |
317 | else |
318 | { |
319 | char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D'; |
320 | pp_character (pp, c); |
321 | pp_character (pp, uid_sep); |
322 | if (flags & TDF_NOUID) |
323 | pp_string (pp, "xxxx" ); |
324 | else |
325 | pp_scalar (pp, "%u" , DECL_UID (node)); |
326 | } |
327 | } |
328 | if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node)) |
329 | { |
330 | if (flags & TDF_NOUID) |
331 | pp_string (pp, "ptD.xxxx" ); |
332 | else |
333 | { |
334 | pp_string (pp, "ptD." ); |
335 | pp_scalar (pp, "%u" , DECL_PT_UID (node)); |
336 | } |
337 | } |
338 | } |
339 | |
340 | /* Like the above, but used for pretty printing function calls. */ |
341 | |
342 | static void |
343 | dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags) |
344 | { |
345 | if (CONVERT_EXPR_P (node)) |
346 | node = TREE_OPERAND (node, 0); |
347 | if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0) |
348 | { |
349 | pp_string (pp, lang_hooks.decl_printable_name (node, 1)); |
350 | if (flags & TDF_UID) |
351 | { |
352 | char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.'; |
353 | pp_character (pp, 'D'); |
354 | pp_character (pp, uid_sep); |
355 | pp_scalar (pp, "%u" , DECL_UID (node)); |
356 | } |
357 | } |
358 | else |
359 | dump_decl_name (pp, node, flags); |
360 | } |
361 | |
362 | /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and |
363 | FLAGS are as in dump_generic_node. */ |
364 | |
365 | static void |
366 | dump_function_declaration (pretty_printer *pp, tree node, |
367 | int spc, dump_flags_t flags) |
368 | { |
369 | bool wrote_arg = false; |
370 | tree arg; |
371 | |
372 | pp_space (pp); |
373 | pp_left_paren (pp); |
374 | |
375 | /* Print the argument types. */ |
376 | arg = TYPE_ARG_TYPES (node); |
377 | while (arg && arg != void_list_node && arg != error_mark_node) |
378 | { |
379 | if (wrote_arg) |
380 | { |
381 | pp_comma (pp); |
382 | pp_space (pp); |
383 | } |
384 | wrote_arg = true; |
385 | dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false); |
386 | arg = TREE_CHAIN (arg); |
387 | } |
388 | |
389 | /* Drop the trailing void_type_node if we had any previous argument. */ |
390 | if (arg == void_list_node && !wrote_arg) |
391 | pp_string (pp, "void" ); |
392 | /* Properly dump vararg function types. */ |
393 | else if (!arg && wrote_arg) |
394 | pp_string (pp, ", ..." ); |
395 | /* Avoid printing any arg for unprototyped functions. */ |
396 | |
397 | pp_right_paren (pp); |
398 | } |
399 | |
400 | /* Dump the domain associated with an array. */ |
401 | |
402 | static void |
403 | dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags) |
404 | { |
405 | pp_left_bracket (pp); |
406 | if (domain) |
407 | { |
408 | tree min = TYPE_MIN_VALUE (domain); |
409 | tree max = TYPE_MAX_VALUE (domain); |
410 | |
411 | if (min && max |
412 | && integer_zerop (min) |
413 | && tree_fits_shwi_p (max)) |
414 | pp_wide_integer (pp, i: tree_to_shwi (max) + 1); |
415 | else |
416 | { |
417 | if (min) |
418 | dump_generic_node (pp, min, spc, flags, false); |
419 | pp_colon (pp); |
420 | if (max) |
421 | dump_generic_node (pp, max, spc, flags, false); |
422 | } |
423 | } |
424 | else |
425 | pp_string (pp, "<unknown>" ); |
426 | pp_right_bracket (pp); |
427 | } |
428 | |
429 | |
430 | /* Dump OpenMP iterators ITER. */ |
431 | |
432 | static void |
433 | dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags) |
434 | { |
435 | pp_string (pp, "iterator(" ); |
436 | for (tree it = iter; it; it = TREE_CHAIN (it)) |
437 | { |
438 | if (it != iter) |
439 | pp_string (pp, ", " ); |
440 | dump_generic_node (pp, TREE_TYPE (TREE_VEC_ELT (it, 0)), spc, flags, |
441 | false); |
442 | pp_space (pp); |
443 | dump_generic_node (pp, TREE_VEC_ELT (it, 0), spc, flags, false); |
444 | pp_equal (pp); |
445 | dump_generic_node (pp, TREE_VEC_ELT (it, 1), spc, flags, false); |
446 | pp_colon (pp); |
447 | dump_generic_node (pp, TREE_VEC_ELT (it, 2), spc, flags, false); |
448 | pp_colon (pp); |
449 | dump_generic_node (pp, TREE_VEC_ELT (it, 3), spc, flags, false); |
450 | } |
451 | pp_right_paren (pp); |
452 | } |
453 | |
454 | |
455 | /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN. |
456 | |
457 | PP, CLAUSE, SPC and FLAGS are as in dump_generic_node. */ |
458 | |
459 | static void |
460 | dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags) |
461 | { |
462 | const char *name; |
463 | const char *modifier = NULL; |
464 | switch (OMP_CLAUSE_CODE (clause)) |
465 | { |
466 | case OMP_CLAUSE_PRIVATE: |
467 | name = "private" ; |
468 | goto print_remap; |
469 | case OMP_CLAUSE_SHARED: |
470 | name = "shared" ; |
471 | goto print_remap; |
472 | case OMP_CLAUSE_FIRSTPRIVATE: |
473 | name = "firstprivate" ; |
474 | goto print_remap; |
475 | case OMP_CLAUSE_LASTPRIVATE: |
476 | name = "lastprivate" ; |
477 | if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause)) |
478 | modifier = "conditional:" ; |
479 | goto print_remap; |
480 | case OMP_CLAUSE_COPYIN: |
481 | name = "copyin" ; |
482 | goto print_remap; |
483 | case OMP_CLAUSE_COPYPRIVATE: |
484 | name = "copyprivate" ; |
485 | goto print_remap; |
486 | case OMP_CLAUSE_UNIFORM: |
487 | name = "uniform" ; |
488 | goto print_remap; |
489 | case OMP_CLAUSE_USE_DEVICE_PTR: |
490 | name = "use_device_ptr" ; |
491 | if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause)) |
492 | modifier = "if_present:" ; |
493 | goto print_remap; |
494 | case OMP_CLAUSE_USE_DEVICE_ADDR: |
495 | name = "use_device_addr" ; |
496 | goto print_remap; |
497 | case OMP_CLAUSE_HAS_DEVICE_ADDR: |
498 | name = "has_device_addr" ; |
499 | goto print_remap; |
500 | case OMP_CLAUSE_IS_DEVICE_PTR: |
501 | name = "is_device_ptr" ; |
502 | goto print_remap; |
503 | case OMP_CLAUSE_INCLUSIVE: |
504 | name = "inclusive" ; |
505 | goto print_remap; |
506 | case OMP_CLAUSE_EXCLUSIVE: |
507 | name = "exclusive" ; |
508 | goto print_remap; |
509 | case OMP_CLAUSE__LOOPTEMP_: |
510 | name = "_looptemp_" ; |
511 | goto print_remap; |
512 | case OMP_CLAUSE__REDUCTEMP_: |
513 | name = "_reductemp_" ; |
514 | goto print_remap; |
515 | case OMP_CLAUSE__CONDTEMP_: |
516 | name = "_condtemp_" ; |
517 | goto print_remap; |
518 | case OMP_CLAUSE__SCANTEMP_: |
519 | name = "_scantemp_" ; |
520 | goto print_remap; |
521 | case OMP_CLAUSE_ENTER: |
522 | if (OMP_CLAUSE_ENTER_TO (clause)) |
523 | name = "to" ; |
524 | else |
525 | name = "enter" ; |
526 | goto print_remap; |
527 | case OMP_CLAUSE_LINK: |
528 | name = "link" ; |
529 | goto print_remap; |
530 | case OMP_CLAUSE_NONTEMPORAL: |
531 | name = "nontemporal" ; |
532 | goto print_remap; |
533 | print_remap: |
534 | pp_string (pp, name); |
535 | pp_left_paren (pp); |
536 | if (modifier) |
537 | pp_string (pp, modifier); |
538 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
539 | spc, flags, false); |
540 | pp_right_paren (pp); |
541 | break; |
542 | |
543 | case OMP_CLAUSE_TASK_REDUCTION: |
544 | case OMP_CLAUSE_IN_REDUCTION: |
545 | pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION |
546 | ? "in_" : "task_" ); |
547 | /* FALLTHRU */ |
548 | case OMP_CLAUSE_REDUCTION: |
549 | pp_string (pp, "reduction(" ); |
550 | if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION) |
551 | { |
552 | if (OMP_CLAUSE_REDUCTION_TASK (clause)) |
553 | pp_string (pp, "task," ); |
554 | else if (OMP_CLAUSE_REDUCTION_INSCAN (clause)) |
555 | pp_string (pp, "inscan," ); |
556 | } |
557 | if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK) |
558 | { |
559 | pp_string (pp, |
560 | op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); |
561 | pp_colon (pp); |
562 | } |
563 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
564 | spc, flags, false); |
565 | pp_right_paren (pp); |
566 | break; |
567 | |
568 | case OMP_CLAUSE_IF: |
569 | pp_string (pp, "if(" ); |
570 | switch (OMP_CLAUSE_IF_MODIFIER (clause)) |
571 | { |
572 | case ERROR_MARK: break; |
573 | case VOID_CST: pp_string (pp, "cancel:" ); break; |
574 | case OMP_PARALLEL: pp_string (pp, "parallel:" ); break; |
575 | case OMP_SIMD: pp_string (pp, "simd:" ); break; |
576 | case OMP_TASK: pp_string (pp, "task:" ); break; |
577 | case OMP_TASKLOOP: pp_string (pp, "taskloop:" ); break; |
578 | case OMP_TARGET_DATA: pp_string (pp, "target data:" ); break; |
579 | case OMP_TARGET: pp_string (pp, "target:" ); break; |
580 | case OMP_TARGET_UPDATE: pp_string (pp, "target update:" ); break; |
581 | case OMP_TARGET_ENTER_DATA: |
582 | pp_string (pp, "target enter data:" ); break; |
583 | case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:" ); break; |
584 | default: gcc_unreachable (); |
585 | } |
586 | dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause), |
587 | spc, flags, false); |
588 | pp_right_paren (pp); |
589 | break; |
590 | |
591 | case OMP_CLAUSE_SELF: |
592 | pp_string (pp, "self(" ); |
593 | dump_generic_node (pp, OMP_CLAUSE_SELF_EXPR (clause), |
594 | spc, flags, false); |
595 | pp_right_paren (pp); |
596 | break; |
597 | |
598 | case OMP_CLAUSE_NUM_THREADS: |
599 | pp_string (pp, "num_threads(" ); |
600 | dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause), |
601 | spc, flags, false); |
602 | pp_right_paren (pp); |
603 | break; |
604 | |
605 | case OMP_CLAUSE_NOWAIT: |
606 | pp_string (pp, "nowait" ); |
607 | break; |
608 | case OMP_CLAUSE_ORDERED: |
609 | pp_string (pp, "ordered" ); |
610 | if (OMP_CLAUSE_ORDERED_EXPR (clause)) |
611 | { |
612 | pp_left_paren (pp); |
613 | dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause), |
614 | spc, flags, false); |
615 | pp_right_paren (pp); |
616 | } |
617 | break; |
618 | |
619 | case OMP_CLAUSE_DEFAULT: |
620 | pp_string (pp, "default(" ); |
621 | switch (OMP_CLAUSE_DEFAULT_KIND (clause)) |
622 | { |
623 | case OMP_CLAUSE_DEFAULT_UNSPECIFIED: |
624 | break; |
625 | case OMP_CLAUSE_DEFAULT_SHARED: |
626 | pp_string (pp, "shared" ); |
627 | break; |
628 | case OMP_CLAUSE_DEFAULT_NONE: |
629 | pp_string (pp, "none" ); |
630 | break; |
631 | case OMP_CLAUSE_DEFAULT_PRIVATE: |
632 | pp_string (pp, "private" ); |
633 | break; |
634 | case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE: |
635 | pp_string (pp, "firstprivate" ); |
636 | break; |
637 | case OMP_CLAUSE_DEFAULT_PRESENT: |
638 | pp_string (pp, "present" ); |
639 | break; |
640 | default: |
641 | gcc_unreachable (); |
642 | } |
643 | pp_right_paren (pp); |
644 | break; |
645 | |
646 | case OMP_CLAUSE_SCHEDULE: |
647 | pp_string (pp, "schedule(" ); |
648 | if (OMP_CLAUSE_SCHEDULE_KIND (clause) |
649 | & (OMP_CLAUSE_SCHEDULE_MONOTONIC |
650 | | OMP_CLAUSE_SCHEDULE_NONMONOTONIC)) |
651 | { |
652 | if (OMP_CLAUSE_SCHEDULE_KIND (clause) |
653 | & OMP_CLAUSE_SCHEDULE_MONOTONIC) |
654 | pp_string (pp, "monotonic" ); |
655 | else |
656 | pp_string (pp, "nonmonotonic" ); |
657 | if (OMP_CLAUSE_SCHEDULE_SIMD (clause)) |
658 | pp_comma (pp); |
659 | else |
660 | pp_colon (pp); |
661 | } |
662 | if (OMP_CLAUSE_SCHEDULE_SIMD (clause)) |
663 | pp_string (pp, "simd:" ); |
664 | |
665 | switch (OMP_CLAUSE_SCHEDULE_KIND (clause) & OMP_CLAUSE_SCHEDULE_MASK) |
666 | { |
667 | case OMP_CLAUSE_SCHEDULE_STATIC: |
668 | pp_string (pp, "static" ); |
669 | break; |
670 | case OMP_CLAUSE_SCHEDULE_DYNAMIC: |
671 | pp_string (pp, "dynamic" ); |
672 | break; |
673 | case OMP_CLAUSE_SCHEDULE_GUIDED: |
674 | pp_string (pp, "guided" ); |
675 | break; |
676 | case OMP_CLAUSE_SCHEDULE_RUNTIME: |
677 | pp_string (pp, "runtime" ); |
678 | break; |
679 | case OMP_CLAUSE_SCHEDULE_AUTO: |
680 | pp_string (pp, "auto" ); |
681 | break; |
682 | default: |
683 | gcc_unreachable (); |
684 | } |
685 | if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) |
686 | { |
687 | pp_comma (pp); |
688 | dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause), |
689 | spc, flags, false); |
690 | } |
691 | pp_right_paren (pp); |
692 | break; |
693 | |
694 | case OMP_CLAUSE_UNTIED: |
695 | pp_string (pp, "untied" ); |
696 | break; |
697 | |
698 | case OMP_CLAUSE_COLLAPSE: |
699 | pp_string (pp, "collapse(" ); |
700 | dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause), |
701 | spc, flags, false); |
702 | pp_right_paren (pp); |
703 | break; |
704 | |
705 | case OMP_CLAUSE_FINAL: |
706 | pp_string (pp, "final(" ); |
707 | dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause), |
708 | spc, flags, false); |
709 | pp_right_paren (pp); |
710 | break; |
711 | |
712 | case OMP_CLAUSE_MERGEABLE: |
713 | pp_string (pp, "mergeable" ); |
714 | break; |
715 | |
716 | case OMP_CLAUSE_LINEAR: |
717 | pp_string (pp, "linear(" ); |
718 | if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)) |
719 | switch (OMP_CLAUSE_LINEAR_KIND (clause)) |
720 | { |
721 | case OMP_CLAUSE_LINEAR_DEFAULT: |
722 | break; |
723 | case OMP_CLAUSE_LINEAR_REF: |
724 | pp_string (pp, "ref(" ); |
725 | break; |
726 | case OMP_CLAUSE_LINEAR_VAL: |
727 | pp_string (pp, "val(" ); |
728 | break; |
729 | case OMP_CLAUSE_LINEAR_UVAL: |
730 | pp_string (pp, "uval(" ); |
731 | break; |
732 | default: |
733 | gcc_unreachable (); |
734 | } |
735 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
736 | spc, flags, false); |
737 | if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause) |
738 | && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT) |
739 | pp_right_paren (pp); |
740 | pp_colon (pp); |
741 | if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause) |
742 | && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT) |
743 | switch (OMP_CLAUSE_LINEAR_KIND (clause)) |
744 | { |
745 | case OMP_CLAUSE_LINEAR_REF: |
746 | pp_string (pp, "ref,step(" ); |
747 | break; |
748 | case OMP_CLAUSE_LINEAR_VAL: |
749 | pp_string (pp, "val,step(" ); |
750 | break; |
751 | case OMP_CLAUSE_LINEAR_UVAL: |
752 | pp_string (pp, "uval,step(" ); |
753 | break; |
754 | default: |
755 | gcc_unreachable (); |
756 | } |
757 | dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause), |
758 | spc, flags, false); |
759 | if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause) |
760 | && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT) |
761 | pp_right_paren (pp); |
762 | pp_right_paren (pp); |
763 | break; |
764 | |
765 | case OMP_CLAUSE_ALIGNED: |
766 | pp_string (pp, "aligned(" ); |
767 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
768 | spc, flags, false); |
769 | if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause)) |
770 | { |
771 | pp_colon (pp); |
772 | dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), |
773 | spc, flags, false); |
774 | } |
775 | pp_right_paren (pp); |
776 | break; |
777 | |
778 | case OMP_CLAUSE_ALLOCATE: |
779 | pp_string (pp, "allocate(" ); |
780 | if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause)) |
781 | { |
782 | pp_string (pp, "allocator(" ); |
783 | dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause), |
784 | spc, flags, false); |
785 | pp_right_paren (pp); |
786 | } |
787 | if (OMP_CLAUSE_ALLOCATE_ALIGN (clause)) |
788 | { |
789 | if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause)) |
790 | pp_comma (pp); |
791 | pp_string (pp, "align(" ); |
792 | dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALIGN (clause), |
793 | spc, flags, false); |
794 | pp_right_paren (pp); |
795 | } |
796 | if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause) |
797 | || OMP_CLAUSE_ALLOCATE_ALIGN (clause)) |
798 | pp_colon (pp); |
799 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
800 | spc, flags, false); |
801 | pp_right_paren (pp); |
802 | break; |
803 | |
804 | case OMP_CLAUSE_AFFINITY: |
805 | pp_string (pp, "affinity(" ); |
806 | { |
807 | tree t = OMP_CLAUSE_DECL (clause); |
808 | if (TREE_CODE (t) == TREE_LIST |
809 | && TREE_PURPOSE (t) |
810 | && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC) |
811 | { |
812 | dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags); |
813 | pp_colon (pp); |
814 | t = TREE_VALUE (t); |
815 | } |
816 | dump_generic_node (pp, t, spc, flags, false); |
817 | } |
818 | pp_right_paren (pp); |
819 | break; |
820 | case OMP_CLAUSE_DEPEND: |
821 | pp_string (pp, "depend(" ); |
822 | switch (OMP_CLAUSE_DEPEND_KIND (clause)) |
823 | { |
824 | case OMP_CLAUSE_DEPEND_DEPOBJ: |
825 | name = "depobj" ; |
826 | break; |
827 | case OMP_CLAUSE_DEPEND_IN: |
828 | name = "in" ; |
829 | break; |
830 | case OMP_CLAUSE_DEPEND_OUT: |
831 | name = "out" ; |
832 | break; |
833 | case OMP_CLAUSE_DEPEND_INOUT: |
834 | name = "inout" ; |
835 | break; |
836 | case OMP_CLAUSE_DEPEND_MUTEXINOUTSET: |
837 | name = "mutexinoutset" ; |
838 | break; |
839 | case OMP_CLAUSE_DEPEND_INOUTSET: |
840 | name = "inoutset" ; |
841 | break; |
842 | case OMP_CLAUSE_DEPEND_LAST: |
843 | name = "__internal__" ; |
844 | break; |
845 | default: |
846 | gcc_unreachable (); |
847 | } |
848 | { |
849 | tree t = OMP_CLAUSE_DECL (clause); |
850 | if (TREE_CODE (t) == TREE_LIST |
851 | && TREE_PURPOSE (t) |
852 | && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC) |
853 | { |
854 | dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags); |
855 | pp_colon (pp); |
856 | t = TREE_VALUE (t); |
857 | } |
858 | if (name[0]) |
859 | { |
860 | pp_string (pp, name); |
861 | pp_colon (pp); |
862 | } |
863 | if (t == null_pointer_node) |
864 | pp_string (pp, "omp_all_memory" ); |
865 | else |
866 | dump_generic_node (pp, t, spc, flags, false); |
867 | pp_right_paren (pp); |
868 | } |
869 | break; |
870 | |
871 | case OMP_CLAUSE_DOACROSS: |
872 | pp_string (pp, OMP_CLAUSE_DOACROSS_DEPEND (clause) |
873 | ? "depend(" : "doacross(" ); |
874 | switch (OMP_CLAUSE_DOACROSS_KIND (clause)) |
875 | { |
876 | case OMP_CLAUSE_DOACROSS_SOURCE: |
877 | if (OMP_CLAUSE_DOACROSS_DEPEND (clause)) |
878 | pp_string (pp, "source)" ); |
879 | else |
880 | pp_string (pp, "source:)" ); |
881 | break; |
882 | case OMP_CLAUSE_DOACROSS_SINK: |
883 | pp_string (pp, "sink:" ); |
884 | if (OMP_CLAUSE_DECL (clause) == NULL_TREE) |
885 | { |
886 | pp_string (pp, "omp_cur_iteration-1)" ); |
887 | break; |
888 | } |
889 | for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t)) |
890 | if (TREE_CODE (t) == TREE_LIST) |
891 | { |
892 | dump_generic_node (pp, TREE_VALUE (t), spc, flags, false); |
893 | if (TREE_PURPOSE (t) != integer_zero_node) |
894 | { |
895 | if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (t)) |
896 | pp_minus (pp); |
897 | else |
898 | pp_plus (pp); |
899 | dump_generic_node (pp, TREE_PURPOSE (t), spc, flags, |
900 | false); |
901 | } |
902 | if (TREE_CHAIN (t)) |
903 | pp_comma (pp); |
904 | } |
905 | else |
906 | gcc_unreachable (); |
907 | pp_right_paren (pp); |
908 | break; |
909 | default: |
910 | gcc_unreachable (); |
911 | } |
912 | break; |
913 | |
914 | case OMP_CLAUSE_MAP: |
915 | pp_string (pp, "map(" ); |
916 | if (OMP_CLAUSE_MAP_READONLY (clause)) |
917 | pp_string (pp, "readonly," ); |
918 | switch (OMP_CLAUSE_MAP_KIND (clause)) |
919 | { |
920 | case GOMP_MAP_ALLOC: |
921 | case GOMP_MAP_POINTER: |
922 | case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION: |
923 | pp_string (pp, "alloc" ); |
924 | break; |
925 | case GOMP_MAP_IF_PRESENT: |
926 | pp_string (pp, "no_alloc" ); |
927 | break; |
928 | case GOMP_MAP_TO: |
929 | case GOMP_MAP_TO_PSET: |
930 | pp_string (pp, "to" ); |
931 | break; |
932 | case GOMP_MAP_FROM: |
933 | pp_string (pp, "from" ); |
934 | break; |
935 | case GOMP_MAP_TOFROM: |
936 | pp_string (pp, "tofrom" ); |
937 | break; |
938 | case GOMP_MAP_FORCE_ALLOC: |
939 | pp_string (pp, "force_alloc" ); |
940 | break; |
941 | case GOMP_MAP_FORCE_TO: |
942 | pp_string (pp, "force_to" ); |
943 | break; |
944 | case GOMP_MAP_FORCE_FROM: |
945 | pp_string (pp, "force_from" ); |
946 | break; |
947 | case GOMP_MAP_FORCE_TOFROM: |
948 | pp_string (pp, "force_tofrom" ); |
949 | break; |
950 | case GOMP_MAP_FORCE_PRESENT: |
951 | pp_string (pp, "force_present" ); |
952 | break; |
953 | case GOMP_MAP_DELETE: |
954 | pp_string (pp, "delete" ); |
955 | break; |
956 | case GOMP_MAP_FORCE_DEVICEPTR: |
957 | pp_string (pp, "force_deviceptr" ); |
958 | break; |
959 | case GOMP_MAP_ALWAYS_TO: |
960 | pp_string (pp, "always,to" ); |
961 | break; |
962 | case GOMP_MAP_ALWAYS_FROM: |
963 | pp_string (pp, "always,from" ); |
964 | break; |
965 | case GOMP_MAP_ALWAYS_TOFROM: |
966 | pp_string (pp, "always,tofrom" ); |
967 | break; |
968 | case GOMP_MAP_RELEASE: |
969 | pp_string (pp, "release" ); |
970 | break; |
971 | case GOMP_MAP_FIRSTPRIVATE_POINTER: |
972 | pp_string (pp, "firstprivate" ); |
973 | break; |
974 | case GOMP_MAP_FIRSTPRIVATE_REFERENCE: |
975 | pp_string (pp, "firstprivate ref" ); |
976 | break; |
977 | case GOMP_MAP_STRUCT: |
978 | pp_string (pp, "struct" ); |
979 | break; |
980 | case GOMP_MAP_STRUCT_UNORD: |
981 | pp_string (pp, "struct_unord" ); |
982 | break; |
983 | case GOMP_MAP_ALWAYS_POINTER: |
984 | pp_string (pp, "always_pointer" ); |
985 | break; |
986 | case GOMP_MAP_DEVICE_RESIDENT: |
987 | pp_string (pp, "device_resident" ); |
988 | break; |
989 | case GOMP_MAP_LINK: |
990 | pp_string (pp, "link" ); |
991 | break; |
992 | case GOMP_MAP_ATTACH: |
993 | pp_string (pp, "attach" ); |
994 | break; |
995 | case GOMP_MAP_DETACH: |
996 | pp_string (pp, "detach" ); |
997 | break; |
998 | case GOMP_MAP_FORCE_DETACH: |
999 | pp_string (pp, "force_detach" ); |
1000 | break; |
1001 | case GOMP_MAP_ATTACH_DETACH: |
1002 | pp_string (pp, "attach_detach" ); |
1003 | break; |
1004 | case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION: |
1005 | pp_string (pp, "attach_zero_length_array_section" ); |
1006 | break; |
1007 | case GOMP_MAP_PRESENT_ALLOC: |
1008 | pp_string (pp, "present,alloc" ); |
1009 | break; |
1010 | case GOMP_MAP_PRESENT_TO: |
1011 | pp_string (pp, "present,to" ); |
1012 | break; |
1013 | case GOMP_MAP_PRESENT_FROM: |
1014 | pp_string (pp, "present,from" ); |
1015 | break; |
1016 | case GOMP_MAP_PRESENT_TOFROM: |
1017 | pp_string (pp, "present,tofrom" ); |
1018 | break; |
1019 | case GOMP_MAP_ALWAYS_PRESENT_TO: |
1020 | pp_string (pp, "always,present,to" ); |
1021 | break; |
1022 | case GOMP_MAP_ALWAYS_PRESENT_FROM: |
1023 | pp_string (pp, "always,present,from" ); |
1024 | break; |
1025 | case GOMP_MAP_ALWAYS_PRESENT_TOFROM: |
1026 | pp_string (pp, "always,present,tofrom" ); |
1027 | break; |
1028 | default: |
1029 | gcc_unreachable (); |
1030 | } |
1031 | pp_colon (pp); |
1032 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
1033 | spc, flags, false); |
1034 | print_clause_size: |
1035 | if (OMP_CLAUSE_SIZE (clause)) |
1036 | { |
1037 | switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP |
1038 | ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO) |
1039 | { |
1040 | case GOMP_MAP_POINTER: |
1041 | case GOMP_MAP_FIRSTPRIVATE_POINTER: |
1042 | case GOMP_MAP_FIRSTPRIVATE_REFERENCE: |
1043 | case GOMP_MAP_ALWAYS_POINTER: |
1044 | pp_string (pp, " [pointer assign, bias: " ); |
1045 | break; |
1046 | case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION: |
1047 | pp_string (pp, " [pointer assign, zero-length array section, bias: " ); |
1048 | break; |
1049 | case GOMP_MAP_TO_PSET: |
1050 | pp_string (pp, " [pointer set, len: " ); |
1051 | break; |
1052 | case GOMP_MAP_ATTACH: |
1053 | case GOMP_MAP_DETACH: |
1054 | case GOMP_MAP_FORCE_DETACH: |
1055 | case GOMP_MAP_ATTACH_DETACH: |
1056 | case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION: |
1057 | pp_string (pp, " [bias: " ); |
1058 | break; |
1059 | case GOMP_MAP_RELEASE: |
1060 | case GOMP_MAP_DELETE: |
1061 | if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP |
1062 | && OMP_CLAUSE_RELEASE_DESCRIPTOR (clause)) |
1063 | { |
1064 | pp_string (pp, " [pointer set, len: " ); |
1065 | break; |
1066 | } |
1067 | /* Fallthrough. */ |
1068 | default: |
1069 | pp_string (pp, " [len: " ); |
1070 | break; |
1071 | } |
1072 | dump_generic_node (pp, OMP_CLAUSE_SIZE (clause), |
1073 | spc, flags, false); |
1074 | pp_right_bracket (pp); |
1075 | } |
1076 | if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP |
1077 | && OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause)) |
1078 | pp_string (pp, "[implicit]" ); |
1079 | pp_right_paren (pp); |
1080 | break; |
1081 | |
1082 | case OMP_CLAUSE_FROM: |
1083 | pp_string (pp, "from(" ); |
1084 | if (OMP_CLAUSE_MOTION_PRESENT (clause)) |
1085 | pp_string (pp, "present:" ); |
1086 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
1087 | spc, flags, false); |
1088 | goto print_clause_size; |
1089 | |
1090 | case OMP_CLAUSE_TO: |
1091 | pp_string (pp, "to(" ); |
1092 | if (OMP_CLAUSE_MOTION_PRESENT (clause)) |
1093 | pp_string (pp, "present:" ); |
1094 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
1095 | spc, flags, false); |
1096 | goto print_clause_size; |
1097 | |
1098 | case OMP_CLAUSE__CACHE_: |
1099 | pp_string (pp, "(" ); |
1100 | if (OMP_CLAUSE__CACHE__READONLY (clause)) |
1101 | pp_string (pp, "readonly:" ); |
1102 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
1103 | spc, flags, false); |
1104 | goto print_clause_size; |
1105 | |
1106 | case OMP_CLAUSE_NUM_TEAMS: |
1107 | pp_string (pp, "num_teams(" ); |
1108 | if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause)) |
1109 | { |
1110 | dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause), |
1111 | spc, flags, false); |
1112 | pp_colon (pp); |
1113 | } |
1114 | dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause), |
1115 | spc, flags, false); |
1116 | pp_right_paren (pp); |
1117 | break; |
1118 | |
1119 | case OMP_CLAUSE_THREAD_LIMIT: |
1120 | pp_string (pp, "thread_limit(" ); |
1121 | dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause), |
1122 | spc, flags, false); |
1123 | pp_right_paren (pp); |
1124 | break; |
1125 | |
1126 | case OMP_CLAUSE_DEVICE: |
1127 | pp_string (pp, "device(" ); |
1128 | if (OMP_CLAUSE_DEVICE_ANCESTOR (clause)) |
1129 | pp_string (pp, "ancestor:" ); |
1130 | dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause), |
1131 | spc, flags, false); |
1132 | pp_right_paren (pp); |
1133 | break; |
1134 | |
1135 | case OMP_CLAUSE_DIST_SCHEDULE: |
1136 | pp_string (pp, "dist_schedule(static" ); |
1137 | if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause)) |
1138 | { |
1139 | pp_comma (pp); |
1140 | dump_generic_node (pp, |
1141 | OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause), |
1142 | spc, flags, false); |
1143 | } |
1144 | pp_right_paren (pp); |
1145 | break; |
1146 | |
1147 | case OMP_CLAUSE_PROC_BIND: |
1148 | pp_string (pp, "proc_bind(" ); |
1149 | switch (OMP_CLAUSE_PROC_BIND_KIND (clause)) |
1150 | { |
1151 | case OMP_CLAUSE_PROC_BIND_MASTER: |
1152 | /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */ |
1153 | /* TODO: Change to 'primary' for OpenMP 5.1. */ |
1154 | pp_string (pp, "master" ); |
1155 | break; |
1156 | case OMP_CLAUSE_PROC_BIND_CLOSE: |
1157 | pp_string (pp, "close" ); |
1158 | break; |
1159 | case OMP_CLAUSE_PROC_BIND_SPREAD: |
1160 | pp_string (pp, "spread" ); |
1161 | break; |
1162 | default: |
1163 | gcc_unreachable (); |
1164 | } |
1165 | pp_right_paren (pp); |
1166 | break; |
1167 | |
1168 | case OMP_CLAUSE_DEVICE_TYPE: |
1169 | pp_string (pp, "device_type(" ); |
1170 | switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause)) |
1171 | { |
1172 | case OMP_CLAUSE_DEVICE_TYPE_HOST: |
1173 | pp_string (pp, "host" ); |
1174 | break; |
1175 | case OMP_CLAUSE_DEVICE_TYPE_NOHOST: |
1176 | pp_string (pp, "nohost" ); |
1177 | break; |
1178 | case OMP_CLAUSE_DEVICE_TYPE_ANY: |
1179 | pp_string (pp, "any" ); |
1180 | break; |
1181 | default: |
1182 | gcc_unreachable (); |
1183 | } |
1184 | pp_right_paren (pp); |
1185 | break; |
1186 | |
1187 | case OMP_CLAUSE_SAFELEN: |
1188 | pp_string (pp, "safelen(" ); |
1189 | dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause), |
1190 | spc, flags, false); |
1191 | pp_right_paren (pp); |
1192 | break; |
1193 | |
1194 | case OMP_CLAUSE_SIMDLEN: |
1195 | pp_string (pp, "simdlen(" ); |
1196 | dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause), |
1197 | spc, flags, false); |
1198 | pp_right_paren (pp); |
1199 | break; |
1200 | |
1201 | case OMP_CLAUSE_PRIORITY: |
1202 | pp_string (pp, "priority(" ); |
1203 | dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause), |
1204 | spc, flags, false); |
1205 | pp_right_paren (pp); |
1206 | break; |
1207 | |
1208 | case OMP_CLAUSE_GRAINSIZE: |
1209 | pp_string (pp, "grainsize(" ); |
1210 | if (OMP_CLAUSE_GRAINSIZE_STRICT (clause)) |
1211 | pp_string (pp, "strict:" ); |
1212 | dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause), |
1213 | spc, flags, false); |
1214 | pp_right_paren (pp); |
1215 | break; |
1216 | |
1217 | case OMP_CLAUSE_NUM_TASKS: |
1218 | pp_string (pp, "num_tasks(" ); |
1219 | if (OMP_CLAUSE_NUM_TASKS_STRICT (clause)) |
1220 | pp_string (pp, "strict:" ); |
1221 | dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause), |
1222 | spc, flags, false); |
1223 | pp_right_paren (pp); |
1224 | break; |
1225 | |
1226 | case OMP_CLAUSE_HINT: |
1227 | pp_string (pp, "hint(" ); |
1228 | dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause), |
1229 | spc, flags, false); |
1230 | pp_right_paren (pp); |
1231 | break; |
1232 | |
1233 | case OMP_CLAUSE_FILTER: |
1234 | pp_string (pp, "filter(" ); |
1235 | dump_generic_node (pp, OMP_CLAUSE_FILTER_EXPR (clause), |
1236 | spc, flags, false); |
1237 | pp_right_paren (pp); |
1238 | break; |
1239 | |
1240 | case OMP_CLAUSE_DEFAULTMAP: |
1241 | pp_string (pp, "defaultmap(" ); |
1242 | switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause)) |
1243 | { |
1244 | case OMP_CLAUSE_DEFAULTMAP_ALLOC: |
1245 | pp_string (pp, "alloc" ); |
1246 | break; |
1247 | case OMP_CLAUSE_DEFAULTMAP_TO: |
1248 | pp_string (pp, "to" ); |
1249 | break; |
1250 | case OMP_CLAUSE_DEFAULTMAP_FROM: |
1251 | pp_string (pp, "from" ); |
1252 | break; |
1253 | case OMP_CLAUSE_DEFAULTMAP_TOFROM: |
1254 | pp_string (pp, "tofrom" ); |
1255 | break; |
1256 | case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE: |
1257 | pp_string (pp, "firstprivate" ); |
1258 | break; |
1259 | case OMP_CLAUSE_DEFAULTMAP_NONE: |
1260 | pp_string (pp, "none" ); |
1261 | break; |
1262 | case OMP_CLAUSE_DEFAULTMAP_PRESENT: |
1263 | pp_string (pp, "present" ); |
1264 | break; |
1265 | case OMP_CLAUSE_DEFAULTMAP_DEFAULT: |
1266 | pp_string (pp, "default" ); |
1267 | break; |
1268 | default: |
1269 | gcc_unreachable (); |
1270 | } |
1271 | switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause)) |
1272 | { |
1273 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED: |
1274 | break; |
1275 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL: |
1276 | pp_string (pp, ":all" ); |
1277 | break; |
1278 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR: |
1279 | pp_string (pp, ":scalar" ); |
1280 | break; |
1281 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE: |
1282 | pp_string (pp, ":aggregate" ); |
1283 | break; |
1284 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE: |
1285 | pp_string (pp, ":allocatable" ); |
1286 | break; |
1287 | case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER: |
1288 | pp_string (pp, ":pointer" ); |
1289 | break; |
1290 | default: |
1291 | gcc_unreachable (); |
1292 | } |
1293 | pp_right_paren (pp); |
1294 | break; |
1295 | |
1296 | case OMP_CLAUSE_ORDER: |
1297 | pp_string (pp, "order(" ); |
1298 | if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause)) |
1299 | pp_string (pp, "unconstrained:" ); |
1300 | else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause)) |
1301 | pp_string (pp, "reproducible:" ); |
1302 | pp_string (pp, "concurrent)" ); |
1303 | break; |
1304 | |
1305 | case OMP_CLAUSE_BIND: |
1306 | pp_string (pp, "bind(" ); |
1307 | switch (OMP_CLAUSE_BIND_KIND (clause)) |
1308 | { |
1309 | case OMP_CLAUSE_BIND_TEAMS: |
1310 | pp_string (pp, "teams" ); |
1311 | break; |
1312 | case OMP_CLAUSE_BIND_PARALLEL: |
1313 | pp_string (pp, "parallel" ); |
1314 | break; |
1315 | case OMP_CLAUSE_BIND_THREAD: |
1316 | pp_string (pp, "thread" ); |
1317 | break; |
1318 | default: |
1319 | gcc_unreachable (); |
1320 | } |
1321 | pp_right_paren (pp); |
1322 | break; |
1323 | |
1324 | case OMP_CLAUSE__SIMDUID_: |
1325 | pp_string (pp, "_simduid_(" ); |
1326 | dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause), |
1327 | spc, flags, false); |
1328 | pp_right_paren (pp); |
1329 | break; |
1330 | |
1331 | case OMP_CLAUSE__SIMT_: |
1332 | pp_string (pp, "_simt_" ); |
1333 | break; |
1334 | |
1335 | case OMP_CLAUSE_GANG: |
1336 | pp_string (pp, "gang" ); |
1337 | if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE) |
1338 | { |
1339 | pp_string (pp, "(num: " ); |
1340 | dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause), |
1341 | spc, flags, false); |
1342 | } |
1343 | if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE) |
1344 | { |
1345 | if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE) |
1346 | pp_left_paren (pp); |
1347 | else |
1348 | pp_space (pp); |
1349 | pp_string (pp, "static:" ); |
1350 | if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) |
1351 | == integer_minus_one_node) |
1352 | pp_character (pp, '*'); |
1353 | else |
1354 | dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause), |
1355 | spc, flags, false); |
1356 | } |
1357 | if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE |
1358 | || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE) |
1359 | pp_right_paren (pp); |
1360 | break; |
1361 | |
1362 | case OMP_CLAUSE_ASYNC: |
1363 | pp_string (pp, "async" ); |
1364 | if (OMP_CLAUSE_ASYNC_EXPR (clause)) |
1365 | { |
1366 | pp_character(pp, '('); |
1367 | dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause), |
1368 | spc, flags, false); |
1369 | pp_character(pp, ')'); |
1370 | } |
1371 | break; |
1372 | |
1373 | case OMP_CLAUSE_AUTO: |
1374 | case OMP_CLAUSE_SEQ: |
1375 | pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]); |
1376 | break; |
1377 | |
1378 | case OMP_CLAUSE_WAIT: |
1379 | pp_string (pp, "wait(" ); |
1380 | dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause), |
1381 | spc, flags, false); |
1382 | pp_character(pp, ')'); |
1383 | break; |
1384 | |
1385 | case OMP_CLAUSE_WORKER: |
1386 | pp_string (pp, "worker" ); |
1387 | if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE) |
1388 | { |
1389 | pp_left_paren (pp); |
1390 | dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause), |
1391 | spc, flags, false); |
1392 | pp_right_paren (pp); |
1393 | } |
1394 | break; |
1395 | |
1396 | case OMP_CLAUSE_VECTOR: |
1397 | pp_string (pp, "vector" ); |
1398 | if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE) |
1399 | { |
1400 | pp_left_paren (pp); |
1401 | dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause), |
1402 | spc, flags, false); |
1403 | pp_right_paren (pp); |
1404 | } |
1405 | break; |
1406 | |
1407 | case OMP_CLAUSE_NUM_GANGS: |
1408 | pp_string (pp, "num_gangs(" ); |
1409 | dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause), |
1410 | spc, flags, false); |
1411 | pp_character (pp, ')'); |
1412 | break; |
1413 | |
1414 | case OMP_CLAUSE_NUM_WORKERS: |
1415 | pp_string (pp, "num_workers(" ); |
1416 | dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause), |
1417 | spc, flags, false); |
1418 | pp_character (pp, ')'); |
1419 | break; |
1420 | |
1421 | case OMP_CLAUSE_VECTOR_LENGTH: |
1422 | pp_string (pp, "vector_length(" ); |
1423 | dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause), |
1424 | spc, flags, false); |
1425 | pp_character (pp, ')'); |
1426 | break; |
1427 | |
1428 | case OMP_CLAUSE_INBRANCH: |
1429 | pp_string (pp, "inbranch" ); |
1430 | break; |
1431 | case OMP_CLAUSE_NOTINBRANCH: |
1432 | pp_string (pp, "notinbranch" ); |
1433 | break; |
1434 | case OMP_CLAUSE_FOR: |
1435 | pp_string (pp, "for" ); |
1436 | break; |
1437 | case OMP_CLAUSE_PARALLEL: |
1438 | pp_string (pp, "parallel" ); |
1439 | break; |
1440 | case OMP_CLAUSE_SECTIONS: |
1441 | pp_string (pp, "sections" ); |
1442 | break; |
1443 | case OMP_CLAUSE_TASKGROUP: |
1444 | pp_string (pp, "taskgroup" ); |
1445 | break; |
1446 | case OMP_CLAUSE_NOGROUP: |
1447 | pp_string (pp, "nogroup" ); |
1448 | break; |
1449 | case OMP_CLAUSE_THREADS: |
1450 | pp_string (pp, "threads" ); |
1451 | break; |
1452 | case OMP_CLAUSE_SIMD: |
1453 | pp_string (pp, "simd" ); |
1454 | break; |
1455 | case OMP_CLAUSE_INDEPENDENT: |
1456 | pp_string (pp, "independent" ); |
1457 | break; |
1458 | case OMP_CLAUSE_TILE: |
1459 | pp_string (pp, "tile(" ); |
1460 | dump_generic_node (pp, OMP_CLAUSE_TILE_LIST (clause), |
1461 | spc, flags, false); |
1462 | pp_right_paren (pp); |
1463 | break; |
1464 | |
1465 | case OMP_CLAUSE_IF_PRESENT: |
1466 | pp_string (pp, "if_present" ); |
1467 | break; |
1468 | case OMP_CLAUSE_FINALIZE: |
1469 | pp_string (pp, "finalize" ); |
1470 | break; |
1471 | case OMP_CLAUSE_NOHOST: |
1472 | pp_string (pp, "nohost" ); |
1473 | break; |
1474 | case OMP_CLAUSE_DETACH: |
1475 | pp_string (pp, "detach(" ); |
1476 | dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags, |
1477 | false); |
1478 | pp_right_paren (pp); |
1479 | break; |
1480 | default: |
1481 | gcc_unreachable (); |
1482 | } |
1483 | } |
1484 | |
1485 | |
1486 | /* Dump chain of OMP clauses. |
1487 | |
1488 | PP, SPC and FLAGS are as in dump_generic_node. */ |
1489 | |
1490 | void |
1491 | dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags, |
1492 | bool leading_space) |
1493 | { |
1494 | while (clause) |
1495 | { |
1496 | if (leading_space) |
1497 | pp_space (pp); |
1498 | dump_omp_clause (pp, clause, spc, flags); |
1499 | leading_space = true; |
1500 | |
1501 | clause = OMP_CLAUSE_CHAIN (clause); |
1502 | } |
1503 | } |
1504 | |
1505 | /* Dump an OpenMP context selector CTX to PP. */ |
1506 | static void |
1507 | dump_omp_context_selector (pretty_printer *pp, tree ctx, int spc, |
1508 | dump_flags_t flags) |
1509 | { |
1510 | for (tree set = ctx; set && set != error_mark_node; set = TREE_CHAIN (set)) |
1511 | { |
1512 | pp_string (pp, OMP_TSS_NAME (set)); |
1513 | pp_string (pp, " = {" ); |
1514 | for (tree sel = OMP_TSS_TRAIT_SELECTORS (set); |
1515 | sel && sel != error_mark_node; sel = TREE_CHAIN (sel)) |
1516 | { |
1517 | if (OMP_TS_CODE (sel) == OMP_TRAIT_INVALID) |
1518 | pp_string (pp, "<unknown selector>" ); |
1519 | else |
1520 | pp_string (pp, OMP_TS_NAME (sel)); |
1521 | tree score = OMP_TS_SCORE (sel); |
1522 | tree props = OMP_TS_PROPERTIES (sel); |
1523 | if (props) |
1524 | { |
1525 | pp_string (pp, " (" ); |
1526 | if (score) |
1527 | { |
1528 | pp_string (pp, "score(" ); |
1529 | dump_generic_node (pp, score, spc + 4, flags, false); |
1530 | pp_string (pp, "): " ); |
1531 | } |
1532 | for (tree prop = props; prop; prop = TREE_CHAIN (prop)) |
1533 | { |
1534 | if (OMP_TP_NAME (prop) == OMP_TP_NAMELIST_NODE) |
1535 | { |
1536 | const char *str = omp_context_name_list_prop (prop); |
1537 | pp_string (pp, "\"" ); |
1538 | pretty_print_string (pp, str, strlen (s: str) + 1); |
1539 | pp_string (pp, "\"" ); |
1540 | } |
1541 | else if (OMP_TP_NAME (prop)) |
1542 | dump_generic_node (pp, OMP_TP_NAME (prop), spc + 4, |
1543 | flags, false); |
1544 | else if (OMP_TP_VALUE (prop)) |
1545 | dump_generic_node (pp, OMP_TP_VALUE (prop), spc + 4, |
1546 | flags, false); |
1547 | if (TREE_CHAIN (prop)) |
1548 | { |
1549 | pp_comma (pp); |
1550 | pp_space (pp); |
1551 | } |
1552 | } |
1553 | pp_string (pp, ")" ); |
1554 | } |
1555 | if (TREE_CHAIN (sel)) |
1556 | { |
1557 | pp_comma (pp); |
1558 | pp_space (pp); |
1559 | } |
1560 | } |
1561 | pp_string (pp, "}" ); |
1562 | if (TREE_CHAIN (set)) |
1563 | { |
1564 | pp_comma (pp); |
1565 | newline_and_indent (pp, spc); |
1566 | } |
1567 | } |
1568 | } |
1569 | |
1570 | /* Wrapper for above, used for "declare variant". Compare to |
1571 | print_generic_expr. */ |
1572 | void |
1573 | print_omp_context_selector (FILE *file, tree t, dump_flags_t flags) |
1574 | { |
1575 | maybe_init_pretty_print (file); |
1576 | dump_omp_context_selector (pp: tree_pp, ctx: t, spc: 0, flags); |
1577 | pp_flush (tree_pp); |
1578 | } |
1579 | |
1580 | /* Dump location LOC to PP. */ |
1581 | |
1582 | void |
1583 | dump_location (pretty_printer *pp, location_t loc) |
1584 | { |
1585 | expanded_location xloc = expand_location (loc); |
1586 | int discriminator = get_discriminator_from_loc (loc); |
1587 | |
1588 | pp_left_bracket (pp); |
1589 | if (xloc.file) |
1590 | { |
1591 | pp_string (pp, xloc.file); |
1592 | pp_string (pp, ":" ); |
1593 | } |
1594 | pp_decimal_int (pp, xloc.line); |
1595 | pp_colon (pp); |
1596 | pp_decimal_int (pp, xloc.column); |
1597 | if (discriminator) |
1598 | { |
1599 | pp_string (pp, " discrim " ); |
1600 | pp_decimal_int (pp, discriminator); |
1601 | } |
1602 | pp_string (pp, "] " ); |
1603 | } |
1604 | |
1605 | |
1606 | /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in |
1607 | dump_generic_node. */ |
1608 | |
1609 | static void |
1610 | dump_block_node (pretty_printer *pp, tree block, int spc, dump_flags_t flags) |
1611 | { |
1612 | tree t; |
1613 | |
1614 | pp_string (pp, "BLOCK #" ); |
1615 | pp_decimal_int (pp, BLOCK_NUMBER (block)); |
1616 | pp_character (pp, ' '); |
1617 | |
1618 | if (flags & TDF_ADDRESS) |
1619 | { |
1620 | pp_character (pp, '['); |
1621 | pp_scalar (pp, "%p" , (void *) block); |
1622 | pp_string (pp, "] " ); |
1623 | } |
1624 | |
1625 | if (TREE_ASM_WRITTEN (block)) |
1626 | pp_string (pp, "[written] " ); |
1627 | |
1628 | if (flags & TDF_SLIM) |
1629 | return; |
1630 | |
1631 | if (BLOCK_SOURCE_LOCATION (block)) |
1632 | dump_location (pp, BLOCK_SOURCE_LOCATION (block)); |
1633 | |
1634 | newline_and_indent (pp, spc + 2); |
1635 | |
1636 | if (BLOCK_SUPERCONTEXT (block)) |
1637 | { |
1638 | pp_string (pp, "SUPERCONTEXT: " ); |
1639 | dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0, |
1640 | flags | TDF_SLIM, false); |
1641 | newline_and_indent (pp, spc + 2); |
1642 | } |
1643 | |
1644 | if (BLOCK_SUBBLOCKS (block)) |
1645 | { |
1646 | pp_string (pp, "SUBBLOCKS: " ); |
1647 | for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) |
1648 | { |
1649 | dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
1650 | pp_space (pp); |
1651 | } |
1652 | newline_and_indent (pp, spc + 2); |
1653 | } |
1654 | |
1655 | if (BLOCK_CHAIN (block)) |
1656 | { |
1657 | pp_string (pp, "SIBLINGS: " ); |
1658 | for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t)) |
1659 | { |
1660 | dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
1661 | pp_space (pp); |
1662 | } |
1663 | newline_and_indent (pp, spc + 2); |
1664 | } |
1665 | |
1666 | if (BLOCK_VARS (block)) |
1667 | { |
1668 | pp_string (pp, "VARS: " ); |
1669 | for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) |
1670 | { |
1671 | dump_generic_node (pp, t, 0, flags, false); |
1672 | pp_space (pp); |
1673 | } |
1674 | newline_and_indent (pp, spc + 2); |
1675 | } |
1676 | |
1677 | if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0) |
1678 | { |
1679 | unsigned i; |
1680 | vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block); |
1681 | |
1682 | pp_string (pp, "NONLOCALIZED_VARS: " ); |
1683 | FOR_EACH_VEC_ELT (*nlv, i, t) |
1684 | { |
1685 | dump_generic_node (pp, t, 0, flags, false); |
1686 | pp_space (pp); |
1687 | } |
1688 | newline_and_indent (pp, spc + 2); |
1689 | } |
1690 | |
1691 | if (BLOCK_ABSTRACT_ORIGIN (block)) |
1692 | { |
1693 | pp_string (pp, "ABSTRACT_ORIGIN: " ); |
1694 | dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0, |
1695 | flags | TDF_SLIM, false); |
1696 | newline_and_indent (pp, spc + 2); |
1697 | } |
1698 | |
1699 | if (BLOCK_FRAGMENT_ORIGIN (block)) |
1700 | { |
1701 | pp_string (pp, "FRAGMENT_ORIGIN: " ); |
1702 | dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0, |
1703 | flags | TDF_SLIM, false); |
1704 | newline_and_indent (pp, spc + 2); |
1705 | } |
1706 | |
1707 | if (BLOCK_FRAGMENT_CHAIN (block)) |
1708 | { |
1709 | pp_string (pp, "FRAGMENT_CHAIN: " ); |
1710 | for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t)) |
1711 | { |
1712 | dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
1713 | pp_space (pp); |
1714 | } |
1715 | newline_and_indent (pp, spc + 2); |
1716 | } |
1717 | } |
1718 | |
1719 | /* Dump #pragma omp atomic memory order clause. */ |
1720 | |
1721 | void |
1722 | dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo) |
1723 | { |
1724 | switch (mo & OMP_MEMORY_ORDER_MASK) |
1725 | { |
1726 | case OMP_MEMORY_ORDER_RELAXED: |
1727 | pp_string (pp, " relaxed" ); |
1728 | break; |
1729 | case OMP_MEMORY_ORDER_SEQ_CST: |
1730 | pp_string (pp, " seq_cst" ); |
1731 | break; |
1732 | case OMP_MEMORY_ORDER_ACQ_REL: |
1733 | pp_string (pp, " acq_rel" ); |
1734 | break; |
1735 | case OMP_MEMORY_ORDER_ACQUIRE: |
1736 | pp_string (pp, " acquire" ); |
1737 | break; |
1738 | case OMP_MEMORY_ORDER_RELEASE: |
1739 | pp_string (pp, " release" ); |
1740 | break; |
1741 | case OMP_MEMORY_ORDER_UNSPECIFIED: |
1742 | break; |
1743 | default: |
1744 | gcc_unreachable (); |
1745 | } |
1746 | switch (mo & OMP_FAIL_MEMORY_ORDER_MASK) |
1747 | { |
1748 | case OMP_FAIL_MEMORY_ORDER_RELAXED: |
1749 | pp_string (pp, " fail(relaxed)" ); |
1750 | break; |
1751 | case OMP_FAIL_MEMORY_ORDER_SEQ_CST: |
1752 | pp_string (pp, " fail(seq_cst)" ); |
1753 | break; |
1754 | case OMP_FAIL_MEMORY_ORDER_ACQUIRE: |
1755 | pp_string (pp, " fail(acquire)" ); |
1756 | break; |
1757 | case OMP_FAIL_MEMORY_ORDER_UNSPECIFIED: |
1758 | break; |
1759 | default: |
1760 | gcc_unreachable (); |
1761 | } |
1762 | } |
1763 | |
1764 | /* Helper to dump a MEM_REF node. */ |
1765 | |
1766 | static void |
1767 | dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags) |
1768 | { |
1769 | if ((TREE_CODE (node) == MEM_REF |
1770 | || TREE_CODE (node) == TARGET_MEM_REF) |
1771 | && (flags & TDF_GIMPLE)) |
1772 | { |
1773 | pp_string (pp, "__MEM <" ); |
1774 | dump_generic_node (pp, TREE_TYPE (node), |
1775 | spc, flags | TDF_SLIM, false); |
1776 | if (TYPE_ALIGN (TREE_TYPE (node)) |
1777 | != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node)))) |
1778 | { |
1779 | pp_string (pp, ", " ); |
1780 | pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node))); |
1781 | } |
1782 | pp_greater (pp); |
1783 | pp_string (pp, " (" ); |
1784 | if (TREE_TYPE (TREE_OPERAND (node, 0)) |
1785 | != TREE_TYPE (TREE_OPERAND (node, 1))) |
1786 | { |
1787 | pp_left_paren (pp); |
1788 | dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)), |
1789 | spc, flags | TDF_SLIM, false); |
1790 | pp_right_paren (pp); |
1791 | } |
1792 | dump_generic_node (pp, TREE_OPERAND (node, 0), |
1793 | spc, flags | TDF_SLIM, false); |
1794 | if (! integer_zerop (TREE_OPERAND (node, 1))) |
1795 | { |
1796 | pp_string (pp, " + " ); |
1797 | dump_generic_node (pp, TREE_OPERAND (node, 1), |
1798 | spc, flags | TDF_SLIM, false); |
1799 | } |
1800 | if (TREE_CODE (node) == TARGET_MEM_REF) |
1801 | { |
1802 | if (TREE_OPERAND (node, 2)) |
1803 | { |
1804 | /* INDEX * STEP */ |
1805 | pp_string (pp, " + " ); |
1806 | dump_generic_node (pp, TREE_OPERAND (node, 2), |
1807 | spc, flags | TDF_SLIM, false); |
1808 | pp_string (pp, " * " ); |
1809 | dump_generic_node (pp, TREE_OPERAND (node, 3), |
1810 | spc, flags | TDF_SLIM, false); |
1811 | } |
1812 | if (TREE_OPERAND (node, 4)) |
1813 | { |
1814 | /* INDEX2 */ |
1815 | pp_string (pp, " + " ); |
1816 | dump_generic_node (pp, TREE_OPERAND (node, 4), |
1817 | spc, flags | TDF_SLIM, false); |
1818 | } |
1819 | } |
1820 | pp_right_paren (pp); |
1821 | } |
1822 | else if (TREE_CODE (node) == MEM_REF |
1823 | && integer_zerop (TREE_OPERAND (node, 1)) |
1824 | /* Dump the types of INTEGER_CSTs explicitly, for we can't |
1825 | infer them and MEM_ATTR caching will share MEM_REFs |
1826 | with differently-typed op0s. */ |
1827 | && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST |
1828 | /* Released SSA_NAMES have no TREE_TYPE. */ |
1829 | && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE |
1830 | /* Same pointer types, but ignoring POINTER_TYPE vs. |
1831 | REFERENCE_TYPE. */ |
1832 | && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0))) |
1833 | == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
1834 | && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0))) |
1835 | == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
1836 | && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0))) |
1837 | == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1)))) |
1838 | /* Same value types ignoring qualifiers. */ |
1839 | && (TYPE_MAIN_VARIANT (TREE_TYPE (node)) |
1840 | == TYPE_MAIN_VARIANT |
1841 | (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))) |
1842 | && (!(flags & TDF_ALIAS) |
1843 | || MR_DEPENDENCE_CLIQUE (node) == 0)) |
1844 | { |
1845 | if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR) |
1846 | { |
1847 | /* Enclose pointers to arrays in parentheses. */ |
1848 | tree op0 = TREE_OPERAND (node, 0); |
1849 | tree op0type = TREE_TYPE (op0); |
1850 | if (POINTER_TYPE_P (op0type) |
1851 | && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE) |
1852 | pp_left_paren (pp); |
1853 | pp_star (pp); |
1854 | dump_generic_node (pp, op0, spc, flags, false); |
1855 | if (POINTER_TYPE_P (op0type) |
1856 | && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE) |
1857 | pp_right_paren (pp); |
1858 | } |
1859 | else |
1860 | dump_generic_node (pp, |
1861 | TREE_OPERAND (TREE_OPERAND (node, 0), 0), |
1862 | spc, flags, false); |
1863 | } |
1864 | else |
1865 | { |
1866 | pp_string (pp, "MEM" ); |
1867 | |
1868 | tree nodetype = TREE_TYPE (node); |
1869 | tree op0 = TREE_OPERAND (node, 0); |
1870 | tree op1 = TREE_OPERAND (node, 1); |
1871 | tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1)); |
1872 | |
1873 | tree op0size = TYPE_SIZE (nodetype); |
1874 | tree op1size = TYPE_SIZE (TREE_TYPE (op1type)); |
1875 | |
1876 | if (!op0size || !op1size |
1877 | || !operand_equal_p (op0size, op1size, flags: 0)) |
1878 | { |
1879 | pp_string (pp, " <" ); |
1880 | /* If the size of the type of the operand is not the same |
1881 | as the size of the MEM_REF expression include the type |
1882 | of the latter similar to the TDF_GIMPLE output to make |
1883 | it clear how many bytes of memory are being accessed. */ |
1884 | dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false); |
1885 | pp_string (pp, "> " ); |
1886 | } |
1887 | |
1888 | pp_string (pp, "[(" ); |
1889 | dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false); |
1890 | pp_right_paren (pp); |
1891 | dump_generic_node (pp, op0, spc, flags, false); |
1892 | if (!integer_zerop (op1)) |
1893 | { |
1894 | pp_string (pp, " + " ); |
1895 | dump_generic_node (pp, op1, spc, flags, false); |
1896 | } |
1897 | if (TREE_CODE (node) == TARGET_MEM_REF) |
1898 | { |
1899 | tree tmp = TMR_INDEX2 (node); |
1900 | if (tmp) |
1901 | { |
1902 | pp_string (pp, " + " ); |
1903 | dump_generic_node (pp, tmp, spc, flags, false); |
1904 | } |
1905 | tmp = TMR_INDEX (node); |
1906 | if (tmp) |
1907 | { |
1908 | pp_string (pp, " + " ); |
1909 | dump_generic_node (pp, tmp, spc, flags, false); |
1910 | tmp = TMR_STEP (node); |
1911 | pp_string (pp, " * " ); |
1912 | if (tmp) |
1913 | dump_generic_node (pp, tmp, spc, flags, false); |
1914 | else |
1915 | pp_string (pp, "1" ); |
1916 | } |
1917 | } |
1918 | if ((flags & TDF_ALIAS) |
1919 | && MR_DEPENDENCE_CLIQUE (node) != 0) |
1920 | { |
1921 | pp_string (pp, " clique " ); |
1922 | pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node)); |
1923 | pp_string (pp, " base " ); |
1924 | pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node)); |
1925 | } |
1926 | pp_right_bracket (pp); |
1927 | } |
1928 | } |
1929 | |
1930 | /* Helper function for dump_generic_node. Dump INIT or COND expression for |
1931 | OpenMP loop non-rectangular iterators. */ |
1932 | |
1933 | void |
1934 | dump_omp_loop_non_rect_expr (pretty_printer *pp, tree node, int spc, |
1935 | dump_flags_t flags) |
1936 | { |
1937 | gcc_assert (TREE_CODE (node) == TREE_VEC); |
1938 | dump_generic_node (pp, TREE_VEC_ELT (node, 0), spc, flags, false); |
1939 | pp_string (pp, " * " ); |
1940 | if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (MULT_EXPR)) |
1941 | { |
1942 | pp_left_paren (pp); |
1943 | dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false); |
1944 | pp_right_paren (pp); |
1945 | } |
1946 | else |
1947 | dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false); |
1948 | pp_string (pp, " + " ); |
1949 | if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (PLUS_EXPR)) |
1950 | { |
1951 | pp_left_paren (pp); |
1952 | dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false); |
1953 | pp_right_paren (pp); |
1954 | } |
1955 | else |
1956 | dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false); |
1957 | } |
1958 | |
1959 | /* Dump the node NODE on the pretty_printer PP, SPC spaces of |
1960 | indent. FLAGS specifies details to show in the dump (see TDF_* in |
1961 | dumpfile.h). If IS_STMT is true, the object printed is considered |
1962 | to be a statement and it is terminated by ';' if appropriate. */ |
1963 | |
1964 | int |
1965 | dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags, |
1966 | bool is_stmt) |
1967 | { |
1968 | tree type; |
1969 | tree op0, op1; |
1970 | const char *str; |
1971 | bool is_expr; |
1972 | enum tree_code code; |
1973 | |
1974 | if (node == NULL_TREE) |
1975 | return spc; |
1976 | |
1977 | is_expr = EXPR_P (node); |
1978 | |
1979 | if (is_stmt && (flags & TDF_STMTADDR)) |
1980 | { |
1981 | pp_string (pp, "<&" ); |
1982 | pp_scalar (pp, "%p" , (void *)node); |
1983 | pp_string (pp, "> " ); |
1984 | } |
1985 | |
1986 | if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) |
1987 | dump_location (pp, EXPR_LOCATION (node)); |
1988 | |
1989 | code = TREE_CODE (node); |
1990 | switch (code) |
1991 | { |
1992 | case ERROR_MARK: |
1993 | pp_string (pp, "<<< error >>>" ); |
1994 | break; |
1995 | |
1996 | case IDENTIFIER_NODE: |
1997 | pp_tree_identifier (pp, node); |
1998 | break; |
1999 | |
2000 | case TREE_LIST: |
2001 | while (node && node != error_mark_node) |
2002 | { |
2003 | if (TREE_PURPOSE (node)) |
2004 | { |
2005 | dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, is_stmt: false); |
2006 | pp_space (pp); |
2007 | } |
2008 | dump_generic_node (pp, TREE_VALUE (node), spc, flags, is_stmt: false); |
2009 | node = TREE_CHAIN (node); |
2010 | if (node && TREE_CODE (node) == TREE_LIST) |
2011 | { |
2012 | pp_comma (pp); |
2013 | pp_space (pp); |
2014 | } |
2015 | } |
2016 | break; |
2017 | |
2018 | case TREE_BINFO: |
2019 | dump_generic_node (pp, BINFO_TYPE (node), spc, flags, is_stmt: false); |
2020 | break; |
2021 | |
2022 | case TREE_VEC: |
2023 | { |
2024 | size_t i; |
2025 | pp_left_brace (pp); |
2026 | if (TREE_VEC_LENGTH (node) > 0) |
2027 | { |
2028 | size_t len = TREE_VEC_LENGTH (node); |
2029 | for (i = 0; i < len - 1; i++) |
2030 | { |
2031 | dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags, |
2032 | is_stmt: false); |
2033 | pp_comma (pp); |
2034 | pp_space (pp); |
2035 | } |
2036 | dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc, |
2037 | flags, is_stmt: false); |
2038 | } |
2039 | pp_right_brace (pp); |
2040 | } |
2041 | break; |
2042 | |
2043 | case VOID_TYPE: |
2044 | case INTEGER_TYPE: |
2045 | case REAL_TYPE: |
2046 | case FIXED_POINT_TYPE: |
2047 | case COMPLEX_TYPE: |
2048 | case VECTOR_TYPE: |
2049 | case ENUMERAL_TYPE: |
2050 | case BOOLEAN_TYPE: |
2051 | case BITINT_TYPE: |
2052 | case OPAQUE_TYPE: |
2053 | { |
2054 | unsigned int quals = TYPE_QUALS (node); |
2055 | enum tree_code_class tclass; |
2056 | |
2057 | if (quals & TYPE_QUAL_ATOMIC) |
2058 | pp_string (pp, "atomic " ); |
2059 | if (quals & TYPE_QUAL_CONST) |
2060 | pp_string (pp, "const " ); |
2061 | if (quals & TYPE_QUAL_VOLATILE) |
2062 | pp_string (pp, "volatile " ); |
2063 | if (quals & TYPE_QUAL_RESTRICT) |
2064 | pp_string (pp, "restrict " ); |
2065 | |
2066 | if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
2067 | { |
2068 | pp_string (pp, "<address-space-" ); |
2069 | pp_decimal_int (pp, TYPE_ADDR_SPACE (node)); |
2070 | pp_string (pp, "> " ); |
2071 | } |
2072 | |
2073 | tclass = TREE_CODE_CLASS (TREE_CODE (node)); |
2074 | |
2075 | if (tclass == tcc_declaration) |
2076 | { |
2077 | if (DECL_NAME (node)) |
2078 | dump_decl_name (pp, node, flags); |
2079 | else |
2080 | pp_string (pp, "<unnamed type decl>" ); |
2081 | } |
2082 | else if (tclass == tcc_type) |
2083 | { |
2084 | if ((flags & TDF_GIMPLE) && node == sizetype) |
2085 | pp_string (pp, "__SIZETYPE__" ); |
2086 | else if (TYPE_NAME (node)) |
2087 | { |
2088 | if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) |
2089 | pp_tree_identifier (pp, TYPE_NAME (node)); |
2090 | else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL |
2091 | && DECL_NAME (TYPE_NAME (node))) |
2092 | dump_decl_name (pp, TYPE_NAME (node), flags); |
2093 | else |
2094 | pp_string (pp, "<unnamed type>" ); |
2095 | } |
2096 | else if (TREE_CODE (node) == VECTOR_TYPE) |
2097 | { |
2098 | if (flags & TDF_GIMPLE) |
2099 | { |
2100 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2101 | pp_string (pp, " [[gnu::vector_size(" ); |
2102 | pp_wide_integer |
2103 | (pp, tree_to_poly_uint64 (TYPE_SIZE_UNIT (node))); |
2104 | pp_string (pp, ")]]" ); |
2105 | } |
2106 | else |
2107 | { |
2108 | pp_string (pp, "vector" ); |
2109 | pp_left_paren (pp); |
2110 | pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node)); |
2111 | pp_string (pp, ") " ); |
2112 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2113 | } |
2114 | } |
2115 | else if (TREE_CODE (node) == INTEGER_TYPE) |
2116 | { |
2117 | if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE) |
2118 | pp_string (pp, (TYPE_UNSIGNED (node) |
2119 | ? "unsigned char" |
2120 | : "signed char" )); |
2121 | else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE) |
2122 | pp_string (pp, (TYPE_UNSIGNED (node) |
2123 | ? "unsigned short" |
2124 | : "signed short" )); |
2125 | else if (TYPE_PRECISION (node) == INT_TYPE_SIZE) |
2126 | pp_string (pp, (TYPE_UNSIGNED (node) |
2127 | ? "unsigned int" |
2128 | : "signed int" )); |
2129 | else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE) |
2130 | pp_string (pp, (TYPE_UNSIGNED (node) |
2131 | ? "unsigned long" |
2132 | : "signed long" )); |
2133 | else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE) |
2134 | pp_string (pp, (TYPE_UNSIGNED (node) |
2135 | ? "unsigned long long" |
2136 | : "signed long long" )); |
2137 | else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE |
2138 | && pow2p_hwi (TYPE_PRECISION (node))) |
2139 | { |
2140 | pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int" )); |
2141 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2142 | pp_string (pp, "_t" ); |
2143 | } |
2144 | else |
2145 | { |
2146 | pp_string (pp, (TYPE_UNSIGNED (node) |
2147 | ? "<unnamed-unsigned:" |
2148 | : "<unnamed-signed:" )); |
2149 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2150 | pp_greater (pp); |
2151 | } |
2152 | } |
2153 | else if (TREE_CODE (node) == COMPLEX_TYPE) |
2154 | { |
2155 | pp_string (pp, "__complex__ " ); |
2156 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2157 | } |
2158 | else if (TREE_CODE (node) == REAL_TYPE) |
2159 | { |
2160 | pp_string (pp, "<float:" ); |
2161 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2162 | pp_greater (pp); |
2163 | } |
2164 | else if (TREE_CODE (node) == FIXED_POINT_TYPE) |
2165 | { |
2166 | pp_string (pp, "<fixed-point-" ); |
2167 | pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:" ); |
2168 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2169 | pp_greater (pp); |
2170 | } |
2171 | else if (TREE_CODE (node) == BOOLEAN_TYPE) |
2172 | { |
2173 | pp_string (pp, (TYPE_UNSIGNED (node) |
2174 | ? "<unsigned-boolean:" |
2175 | : "<signed-boolean:" )); |
2176 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2177 | pp_greater (pp); |
2178 | } |
2179 | else if (TREE_CODE (node) == BITINT_TYPE) |
2180 | { |
2181 | if (TYPE_UNSIGNED (node)) |
2182 | pp_string (pp, "unsigned " ); |
2183 | pp_string (pp, "_BitInt(" ); |
2184 | pp_decimal_int (pp, TYPE_PRECISION (node)); |
2185 | pp_right_paren (pp); |
2186 | } |
2187 | else if (TREE_CODE (node) == VOID_TYPE) |
2188 | pp_string (pp, "void" ); |
2189 | else |
2190 | pp_string (pp, "<unnamed type>" ); |
2191 | } |
2192 | break; |
2193 | } |
2194 | |
2195 | case POINTER_TYPE: |
2196 | case REFERENCE_TYPE: |
2197 | str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&" ); |
2198 | |
2199 | if (TREE_TYPE (node) == NULL) |
2200 | { |
2201 | pp_string (pp, str); |
2202 | pp_string (pp, "<null type>" ); |
2203 | } |
2204 | else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) |
2205 | { |
2206 | tree fnode = TREE_TYPE (node); |
2207 | |
2208 | dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, is_stmt: false); |
2209 | pp_space (pp); |
2210 | pp_left_paren (pp); |
2211 | pp_string (pp, str); |
2212 | if (TYPE_IDENTIFIER (node)) |
2213 | dump_generic_node (pp, TYPE_NAME (node), spc, flags, is_stmt: false); |
2214 | else if (flags & TDF_NOUID) |
2215 | pp_string (pp, "<Txxxx>" ); |
2216 | else |
2217 | { |
2218 | pp_string (pp, "<T" ); |
2219 | pp_scalar (pp, "%x" , TYPE_UID (node)); |
2220 | pp_character (pp, '>'); |
2221 | } |
2222 | |
2223 | pp_right_paren (pp); |
2224 | dump_function_declaration (pp, node: fnode, spc, flags); |
2225 | } |
2226 | else |
2227 | { |
2228 | unsigned int quals = TYPE_QUALS (node); |
2229 | |
2230 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2231 | pp_space (pp); |
2232 | pp_string (pp, str); |
2233 | |
2234 | if (quals & TYPE_QUAL_CONST) |
2235 | pp_string (pp, " const" ); |
2236 | if (quals & TYPE_QUAL_VOLATILE) |
2237 | pp_string (pp, " volatile" ); |
2238 | if (quals & TYPE_QUAL_RESTRICT) |
2239 | pp_string (pp, " restrict" ); |
2240 | |
2241 | if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
2242 | { |
2243 | pp_string (pp, " <address-space-" ); |
2244 | pp_decimal_int (pp, TYPE_ADDR_SPACE (node)); |
2245 | pp_greater (pp); |
2246 | } |
2247 | |
2248 | if (TYPE_REF_CAN_ALIAS_ALL (node)) |
2249 | pp_string (pp, " {ref-all}" ); |
2250 | } |
2251 | break; |
2252 | |
2253 | case OFFSET_TYPE: |
2254 | NIY; |
2255 | break; |
2256 | |
2257 | case MEM_REF: |
2258 | case TARGET_MEM_REF: |
2259 | dump_mem_ref (pp, node, spc, flags); |
2260 | break; |
2261 | |
2262 | case ARRAY_TYPE: |
2263 | { |
2264 | unsigned int quals = TYPE_QUALS (node); |
2265 | tree tmp; |
2266 | |
2267 | if (quals & TYPE_QUAL_ATOMIC) |
2268 | pp_string (pp, "atomic " ); |
2269 | if (quals & TYPE_QUAL_CONST) |
2270 | pp_string (pp, "const " ); |
2271 | if (quals & TYPE_QUAL_VOLATILE) |
2272 | pp_string (pp, "volatile " ); |
2273 | |
2274 | /* Print the innermost component type. */ |
2275 | for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE; |
2276 | tmp = TREE_TYPE (tmp)) |
2277 | ; |
2278 | |
2279 | /* Avoid to print recursively the array. */ |
2280 | /* FIXME : Not implemented correctly, see print_struct_decl. */ |
2281 | if (TREE_CODE (tmp) != POINTER_TYPE || TREE_TYPE (tmp) != node) |
2282 | dump_generic_node (pp, node: tmp, spc, flags, is_stmt: false); |
2283 | |
2284 | /* Print the dimensions. */ |
2285 | for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp)) |
2286 | dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags); |
2287 | break; |
2288 | } |
2289 | |
2290 | case RECORD_TYPE: |
2291 | case UNION_TYPE: |
2292 | case QUAL_UNION_TYPE: |
2293 | { |
2294 | unsigned int quals = TYPE_QUALS (node); |
2295 | |
2296 | if (quals & TYPE_QUAL_ATOMIC) |
2297 | pp_string (pp, "atomic " ); |
2298 | if (quals & TYPE_QUAL_CONST) |
2299 | pp_string (pp, "const " ); |
2300 | if (quals & TYPE_QUAL_VOLATILE) |
2301 | pp_string (pp, "volatile " ); |
2302 | |
2303 | if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
2304 | { |
2305 | pp_string (pp, "<address-space-" ); |
2306 | pp_decimal_int (pp, TYPE_ADDR_SPACE (node)); |
2307 | pp_string (pp, "> " ); |
2308 | } |
2309 | |
2310 | /* Print the name of the structure. */ |
2311 | if (TREE_CODE (node) == RECORD_TYPE) |
2312 | pp_string (pp, "struct " ); |
2313 | else if (TREE_CODE (node) == UNION_TYPE) |
2314 | pp_string (pp, "union " ); |
2315 | |
2316 | if (TYPE_NAME (node)) |
2317 | dump_generic_node (pp, TYPE_NAME (node), spc, flags, is_stmt: false); |
2318 | else if (!(flags & TDF_SLIM)) |
2319 | /* FIXME: If we eliminate the 'else' above and attempt |
2320 | to show the fields for named types, we may get stuck |
2321 | following a cycle of pointers to structs. The alleged |
2322 | self-reference check in print_struct_decl will not detect |
2323 | cycles involving more than one pointer or struct type. */ |
2324 | print_struct_decl (pp, node, spc, flags); |
2325 | break; |
2326 | } |
2327 | |
2328 | case LANG_TYPE: |
2329 | NIY; |
2330 | break; |
2331 | |
2332 | case INTEGER_CST: |
2333 | if (flags & TDF_GIMPLE |
2334 | && (POINTER_TYPE_P (TREE_TYPE (node)) |
2335 | || (TYPE_PRECISION (TREE_TYPE (node)) |
2336 | < TYPE_PRECISION (integer_type_node)) |
2337 | || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1 |
2338 | || tree_int_cst_sgn (node) < 0)) |
2339 | { |
2340 | pp_string (pp, "_Literal (" ); |
2341 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2342 | pp_string (pp, ") " ); |
2343 | } |
2344 | if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE |
2345 | && ! (flags & TDF_GIMPLE)) |
2346 | { |
2347 | /* In the case of a pointer, one may want to divide by the |
2348 | size of the pointed-to type. Unfortunately, this not |
2349 | straightforward. The C front-end maps expressions |
2350 | |
2351 | (int *) 5 |
2352 | int *p; (p + 5) |
2353 | |
2354 | in such a way that the two INTEGER_CST nodes for "5" have |
2355 | different values but identical types. In the latter |
2356 | case, the 5 is multiplied by sizeof (int) in c-common.cc |
2357 | (pointer_int_sum) to convert it to a byte address, and |
2358 | yet the type of the node is left unchanged. Argh. What |
2359 | is consistent though is that the number value corresponds |
2360 | to bytes (UNITS) offset. |
2361 | |
2362 | NB: Neither of the following divisors can be trivially |
2363 | used to recover the original literal: |
2364 | |
2365 | TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node))) |
2366 | TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */ |
2367 | pp_wide_integer (pp, TREE_INT_CST_LOW (node)); |
2368 | pp_string (pp, "B" ); /* pseudo-unit */ |
2369 | } |
2370 | else if (tree_fits_shwi_p (node)) |
2371 | pp_wide_integer (pp, i: tree_to_shwi (node)); |
2372 | else if (tree_fits_uhwi_p (node)) |
2373 | pp_unsigned_wide_integer (pp, tree_to_uhwi (node)); |
2374 | else |
2375 | { |
2376 | wide_int val = wi::to_wide (t: node); |
2377 | |
2378 | if (wi::neg_p (x: val, TYPE_SIGN (TREE_TYPE (node)))) |
2379 | { |
2380 | pp_minus (pp); |
2381 | val = -val; |
2382 | } |
2383 | unsigned int len; |
2384 | print_hex_buf_size (wi: val, len: &len); |
2385 | if (UNLIKELY (len > sizeof (pp_buffer (pp)->digit_buffer))) |
2386 | { |
2387 | char *buf = XALLOCAVEC (char, len); |
2388 | print_hex (wi: val, buf); |
2389 | pp_string (pp, buf); |
2390 | } |
2391 | else |
2392 | { |
2393 | print_hex (wi: val, pp_buffer (pp)->digit_buffer); |
2394 | pp_string (pp, pp_buffer (pp)->digit_buffer); |
2395 | } |
2396 | } |
2397 | if ((flags & TDF_GIMPLE) |
2398 | && ! (POINTER_TYPE_P (TREE_TYPE (node)) |
2399 | || (TYPE_PRECISION (TREE_TYPE (node)) |
2400 | < TYPE_PRECISION (integer_type_node)) |
2401 | || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1)) |
2402 | { |
2403 | if (TYPE_UNSIGNED (TREE_TYPE (node))) |
2404 | pp_character (pp, 'u'); |
2405 | if (TYPE_PRECISION (TREE_TYPE (node)) |
2406 | == TYPE_PRECISION (unsigned_type_node)) |
2407 | ; |
2408 | else if (TYPE_PRECISION (TREE_TYPE (node)) |
2409 | == TYPE_PRECISION (long_unsigned_type_node)) |
2410 | pp_character (pp, 'l'); |
2411 | else if (TYPE_PRECISION (TREE_TYPE (node)) |
2412 | == TYPE_PRECISION (long_long_unsigned_type_node)) |
2413 | pp_string (pp, "ll" ); |
2414 | } |
2415 | if (TREE_OVERFLOW (node)) |
2416 | pp_string (pp, "(OVF)" ); |
2417 | break; |
2418 | |
2419 | case POLY_INT_CST: |
2420 | pp_string (pp, "POLY_INT_CST [" ); |
2421 | dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, is_stmt: false); |
2422 | for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i) |
2423 | { |
2424 | pp_string (pp, ", " ); |
2425 | dump_generic_node (pp, POLY_INT_CST_COEFF (node, i), |
2426 | spc, flags, is_stmt: false); |
2427 | } |
2428 | pp_string (pp, "]" ); |
2429 | break; |
2430 | |
2431 | case REAL_CST: |
2432 | /* Code copied from print_node. */ |
2433 | { |
2434 | REAL_VALUE_TYPE d; |
2435 | if (TREE_OVERFLOW (node)) |
2436 | pp_string (pp, " overflow" ); |
2437 | |
2438 | d = TREE_REAL_CST (node); |
2439 | if (REAL_VALUE_ISINF (d)) |
2440 | pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf" ); |
2441 | else if (REAL_VALUE_ISNAN (d)) |
2442 | pp_string (pp, " Nan" ); |
2443 | else |
2444 | { |
2445 | char string[100]; |
2446 | real_to_decimal (string, &d, sizeof (string), 0, 1); |
2447 | pp_string (pp, string); |
2448 | } |
2449 | break; |
2450 | } |
2451 | |
2452 | case FIXED_CST: |
2453 | { |
2454 | char string[100]; |
2455 | fixed_to_decimal (str: string, TREE_FIXED_CST_PTR (node), sizeof (string)); |
2456 | pp_string (pp, string); |
2457 | break; |
2458 | } |
2459 | |
2460 | case COMPLEX_CST: |
2461 | pp_string (pp, "__complex__ (" ); |
2462 | dump_generic_node (pp, TREE_REALPART (node), spc, flags, is_stmt: false); |
2463 | pp_string (pp, ", " ); |
2464 | dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, is_stmt: false); |
2465 | pp_right_paren (pp); |
2466 | break; |
2467 | |
2468 | case STRING_CST: |
2469 | { |
2470 | pp_string (pp, "\"" ); |
2471 | if (unsigned nbytes = TREE_STRING_LENGTH (node)) |
2472 | pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes); |
2473 | pp_string (pp, "\"" ); |
2474 | break; |
2475 | } |
2476 | |
2477 | case VECTOR_CST: |
2478 | { |
2479 | unsigned i; |
2480 | if (flags & TDF_GIMPLE) |
2481 | { |
2482 | pp_string (pp, "_Literal (" ); |
2483 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2484 | pp_string (pp, ") " ); |
2485 | } |
2486 | pp_string (pp, "{ " ); |
2487 | unsigned HOST_WIDE_INT nunits; |
2488 | if (!VECTOR_CST_NELTS (node).is_constant (const_value: &nunits)) |
2489 | nunits = vector_cst_encoded_nelts (t: node); |
2490 | for (i = 0; i < nunits; ++i) |
2491 | { |
2492 | if (i != 0) |
2493 | pp_string (pp, ", " ); |
2494 | dump_generic_node (pp, VECTOR_CST_ELT (node, i), |
2495 | spc, flags, is_stmt: false); |
2496 | } |
2497 | if (!VECTOR_CST_NELTS (node).is_constant ()) |
2498 | pp_string (pp, ", ..." ); |
2499 | pp_string (pp, " }" ); |
2500 | } |
2501 | break; |
2502 | |
2503 | case FUNCTION_TYPE: |
2504 | case METHOD_TYPE: |
2505 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2506 | pp_space (pp); |
2507 | if (TREE_CODE (node) == METHOD_TYPE) |
2508 | { |
2509 | if (TYPE_METHOD_BASETYPE (node)) |
2510 | dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), |
2511 | spc, flags, is_stmt: false); |
2512 | else |
2513 | pp_string (pp, "<null method basetype>" ); |
2514 | pp_colon_colon (pp); |
2515 | } |
2516 | if (TYPE_IDENTIFIER (node)) |
2517 | dump_generic_node (pp, TYPE_NAME (node), spc, flags, is_stmt: false); |
2518 | else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) |
2519 | dump_decl_name (pp, TYPE_NAME (node), flags); |
2520 | else if (flags & TDF_NOUID) |
2521 | pp_string (pp, "<Txxxx>" ); |
2522 | else |
2523 | { |
2524 | pp_string (pp, "<T" ); |
2525 | pp_scalar (pp, "%x" , TYPE_UID (node)); |
2526 | pp_character (pp, '>'); |
2527 | } |
2528 | dump_function_declaration (pp, node, spc, flags); |
2529 | break; |
2530 | |
2531 | case FUNCTION_DECL: |
2532 | case CONST_DECL: |
2533 | dump_decl_name (pp, node, flags); |
2534 | break; |
2535 | |
2536 | case LABEL_DECL: |
2537 | if (DECL_NAME (node)) |
2538 | dump_decl_name (pp, node, flags); |
2539 | else if (LABEL_DECL_UID (node) != -1) |
2540 | { |
2541 | if (flags & TDF_GIMPLE) |
2542 | { |
2543 | pp_character (pp, 'L'); |
2544 | pp_decimal_int (pp, (int) LABEL_DECL_UID (node)); |
2545 | } |
2546 | else |
2547 | { |
2548 | pp_string (pp, "<L" ); |
2549 | pp_decimal_int (pp, (int) LABEL_DECL_UID (node)); |
2550 | pp_character (pp, '>'); |
2551 | } |
2552 | } |
2553 | else |
2554 | { |
2555 | if (flags & TDF_NOUID) |
2556 | pp_string (pp, "<D.xxxx>" ); |
2557 | else |
2558 | { |
2559 | if (flags & TDF_GIMPLE) |
2560 | { |
2561 | pp_character (pp, 'D'); |
2562 | pp_scalar (pp, "%u" , DECL_UID (node)); |
2563 | } |
2564 | else |
2565 | { |
2566 | pp_string (pp, "<D." ); |
2567 | pp_scalar (pp, "%u" , DECL_UID (node)); |
2568 | pp_character (pp, '>'); |
2569 | } |
2570 | } |
2571 | } |
2572 | break; |
2573 | |
2574 | case TYPE_DECL: |
2575 | if (DECL_IS_UNDECLARED_BUILTIN (node)) |
2576 | { |
2577 | /* Don't print the declaration of built-in types. */ |
2578 | break; |
2579 | } |
2580 | if (DECL_NAME (node)) |
2581 | dump_decl_name (pp, node, flags); |
2582 | else if (TYPE_NAME (TREE_TYPE (node)) != node) |
2583 | { |
2584 | pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE |
2585 | ? "union" : "struct " )); |
2586 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2587 | } |
2588 | else |
2589 | pp_string (pp, "<anon>" ); |
2590 | break; |
2591 | |
2592 | case VAR_DECL: |
2593 | case PARM_DECL: |
2594 | case FIELD_DECL: |
2595 | case DEBUG_EXPR_DECL: |
2596 | case NAMESPACE_DECL: |
2597 | case NAMELIST_DECL: |
2598 | dump_decl_name (pp, node, flags); |
2599 | break; |
2600 | |
2601 | case RESULT_DECL: |
2602 | pp_string (pp, "<retval>" ); |
2603 | break; |
2604 | |
2605 | case COMPONENT_REF: |
2606 | op0 = TREE_OPERAND (node, 0); |
2607 | str = "." ; |
2608 | if (op0 |
2609 | && (TREE_CODE (op0) == INDIRECT_REF |
2610 | || (TREE_CODE (op0) == MEM_REF |
2611 | && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR |
2612 | && integer_zerop (TREE_OPERAND (op0, 1)) |
2613 | /* Dump the types of INTEGER_CSTs explicitly, for we |
2614 | can't infer them and MEM_ATTR caching will share |
2615 | MEM_REFs with differently-typed op0s. */ |
2616 | && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST |
2617 | /* Released SSA_NAMES have no TREE_TYPE. */ |
2618 | && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE |
2619 | /* Same pointer types, but ignoring POINTER_TYPE vs. |
2620 | REFERENCE_TYPE. */ |
2621 | && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
2622 | == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
2623 | && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
2624 | == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
2625 | && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0))) |
2626 | == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
2627 | /* Same value types ignoring qualifiers. */ |
2628 | && (TYPE_MAIN_VARIANT (TREE_TYPE (op0)) |
2629 | == TYPE_MAIN_VARIANT |
2630 | (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))) |
2631 | && MR_DEPENDENCE_CLIQUE (op0) == 0))) |
2632 | { |
2633 | op0 = TREE_OPERAND (op0, 0); |
2634 | str = "->" ; |
2635 | } |
2636 | if (op_prio (op0) < op_prio (node)) |
2637 | pp_left_paren (pp); |
2638 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
2639 | if (op_prio (op0) < op_prio (node)) |
2640 | pp_right_paren (pp); |
2641 | pp_string (pp, str); |
2642 | op1 = TREE_OPERAND (node, 1); |
2643 | dump_generic_node (pp, node: op1, spc, flags, is_stmt: false); |
2644 | if (DECL_P (op1)) /* Not always a decl in the C++ FE. */ |
2645 | if (tree off = component_ref_field_offset (node)) |
2646 | if (TREE_CODE (off) != INTEGER_CST) |
2647 | { |
2648 | pp_string (pp, "{off: " ); |
2649 | dump_generic_node (pp, node: off, spc, flags, is_stmt: false); |
2650 | pp_right_brace (pp); |
2651 | } |
2652 | break; |
2653 | |
2654 | case BIT_FIELD_REF: |
2655 | if (flags & TDF_GIMPLE) |
2656 | { |
2657 | pp_string (pp, "__BIT_FIELD_REF <" ); |
2658 | dump_generic_node (pp, TREE_TYPE (node), |
2659 | spc, flags: flags | TDF_SLIM, is_stmt: false); |
2660 | if (TYPE_ALIGN (TREE_TYPE (node)) |
2661 | != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node)))) |
2662 | { |
2663 | pp_string (pp, ", " ); |
2664 | pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node))); |
2665 | } |
2666 | pp_greater (pp); |
2667 | pp_string (pp, " (" ); |
2668 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, |
2669 | flags: flags | TDF_SLIM, is_stmt: false); |
2670 | pp_string (pp, ", " ); |
2671 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, |
2672 | flags: flags | TDF_SLIM, is_stmt: false); |
2673 | pp_string (pp, ", " ); |
2674 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, |
2675 | flags: flags | TDF_SLIM, is_stmt: false); |
2676 | pp_right_paren (pp); |
2677 | } |
2678 | else |
2679 | { |
2680 | pp_string (pp, "BIT_FIELD_REF <" ); |
2681 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
2682 | pp_string (pp, ", " ); |
2683 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
2684 | pp_string (pp, ", " ); |
2685 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
2686 | pp_greater (pp); |
2687 | } |
2688 | break; |
2689 | |
2690 | case BIT_INSERT_EXPR: |
2691 | pp_string (pp, "BIT_INSERT_EXPR <" ); |
2692 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
2693 | pp_string (pp, ", " ); |
2694 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
2695 | pp_string (pp, ", " ); |
2696 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
2697 | pp_string (pp, " (" ); |
2698 | if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1)))) |
2699 | pp_decimal_int (pp, |
2700 | TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1)))); |
2701 | else |
2702 | dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))), |
2703 | spc, flags, is_stmt: false); |
2704 | pp_string (pp, " bits)>" ); |
2705 | break; |
2706 | |
2707 | case ARRAY_REF: |
2708 | case ARRAY_RANGE_REF: |
2709 | op0 = TREE_OPERAND (node, 0); |
2710 | if (op_prio (op0) < op_prio (node)) |
2711 | pp_left_paren (pp); |
2712 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
2713 | if (op_prio (op0) < op_prio (node)) |
2714 | pp_right_paren (pp); |
2715 | pp_left_bracket (pp); |
2716 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
2717 | if (TREE_CODE (node) == ARRAY_RANGE_REF) |
2718 | pp_string (pp, " ..." ); |
2719 | pp_right_bracket (pp); |
2720 | |
2721 | op0 = array_ref_low_bound (node); |
2722 | op1 = array_ref_element_size (node); |
2723 | |
2724 | if (!integer_zerop (op0) |
2725 | || TREE_OPERAND (node, 2) |
2726 | || TREE_OPERAND (node, 3)) |
2727 | { |
2728 | pp_string (pp, "{lb: " ); |
2729 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
2730 | pp_string (pp, " sz: " ); |
2731 | dump_generic_node (pp, node: op1, spc, flags, is_stmt: false); |
2732 | pp_right_brace (pp); |
2733 | } |
2734 | break; |
2735 | |
2736 | case OMP_ARRAY_SECTION: |
2737 | op0 = TREE_OPERAND (node, 0); |
2738 | if (op_prio (op0) < op_prio (node)) |
2739 | pp_left_paren (pp); |
2740 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
2741 | if (op_prio (op0) < op_prio (node)) |
2742 | pp_right_paren (pp); |
2743 | pp_left_bracket (pp); |
2744 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
2745 | pp_colon (pp); |
2746 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
2747 | pp_right_bracket (pp); |
2748 | break; |
2749 | |
2750 | case CONSTRUCTOR: |
2751 | { |
2752 | unsigned HOST_WIDE_INT ix; |
2753 | tree field, val; |
2754 | bool is_struct_init = false; |
2755 | bool is_array_init = false; |
2756 | widest_int curidx; |
2757 | if (flags & TDF_GIMPLE) |
2758 | { |
2759 | pp_string (pp, "_Literal (" ); |
2760 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
2761 | pp_string (pp, ") " ); |
2762 | } |
2763 | pp_left_brace (pp); |
2764 | if (TREE_CLOBBER_P (node)) |
2765 | { |
2766 | pp_string (pp, "CLOBBER" ); |
2767 | switch (CLOBBER_KIND (node)) |
2768 | { |
2769 | case CLOBBER_STORAGE_BEGIN: |
2770 | pp_string (pp, "(bos)" ); |
2771 | break; |
2772 | case CLOBBER_STORAGE_END: |
2773 | pp_string (pp, "(eos)" ); |
2774 | break; |
2775 | case CLOBBER_OBJECT_BEGIN: |
2776 | pp_string (pp, "(bob)" ); |
2777 | break; |
2778 | case CLOBBER_OBJECT_END: |
2779 | pp_string (pp, "(eob)" ); |
2780 | break; |
2781 | default: |
2782 | break; |
2783 | } |
2784 | } |
2785 | else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE |
2786 | || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) |
2787 | is_struct_init = true; |
2788 | else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE |
2789 | && TYPE_DOMAIN (TREE_TYPE (node)) |
2790 | && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))) |
2791 | && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))) |
2792 | == INTEGER_CST) |
2793 | { |
2794 | tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))); |
2795 | is_array_init = true; |
2796 | curidx = wi::to_widest (t: minv); |
2797 | } |
2798 | FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) |
2799 | { |
2800 | if (field) |
2801 | { |
2802 | if (is_struct_init) |
2803 | { |
2804 | pp_dot (pp); |
2805 | dump_generic_node (pp, node: field, spc, flags, is_stmt: false); |
2806 | pp_equal (pp); |
2807 | } |
2808 | else if (is_array_init |
2809 | && (TREE_CODE (field) != INTEGER_CST |
2810 | || curidx != wi::to_widest (t: field))) |
2811 | { |
2812 | pp_left_bracket (pp); |
2813 | if (TREE_CODE (field) == RANGE_EXPR) |
2814 | { |
2815 | dump_generic_node (pp, TREE_OPERAND (field, 0), spc, |
2816 | flags, is_stmt: false); |
2817 | pp_string (pp, " ... " ); |
2818 | dump_generic_node (pp, TREE_OPERAND (field, 1), spc, |
2819 | flags, is_stmt: false); |
2820 | if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST) |
2821 | curidx = wi::to_widest (TREE_OPERAND (field, 1)); |
2822 | } |
2823 | else |
2824 | dump_generic_node (pp, node: field, spc, flags, is_stmt: false); |
2825 | if (TREE_CODE (field) == INTEGER_CST) |
2826 | curidx = wi::to_widest (t: field); |
2827 | pp_string (pp, "]=" ); |
2828 | } |
2829 | } |
2830 | if (is_array_init) |
2831 | curidx += 1; |
2832 | if (val && TREE_CODE (val) == ADDR_EXPR) |
2833 | if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) |
2834 | val = TREE_OPERAND (val, 0); |
2835 | if (val && TREE_CODE (val) == FUNCTION_DECL) |
2836 | dump_decl_name (pp, node: val, flags); |
2837 | else |
2838 | dump_generic_node (pp, node: val, spc, flags, is_stmt: false); |
2839 | if (ix != CONSTRUCTOR_NELTS (node) - 1) |
2840 | { |
2841 | pp_comma (pp); |
2842 | pp_space (pp); |
2843 | } |
2844 | } |
2845 | pp_right_brace (pp); |
2846 | } |
2847 | break; |
2848 | |
2849 | case COMPOUND_EXPR: |
2850 | { |
2851 | tree *tp; |
2852 | if (flags & TDF_SLIM) |
2853 | { |
2854 | pp_string (pp, "<COMPOUND_EXPR>" ); |
2855 | break; |
2856 | } |
2857 | |
2858 | dump_generic_node (pp, TREE_OPERAND (node, 0), |
2859 | spc, flags, is_stmt: !(flags & TDF_SLIM)); |
2860 | if (flags & TDF_SLIM) |
2861 | newline_and_indent (pp, spc); |
2862 | else |
2863 | { |
2864 | pp_comma (pp); |
2865 | pp_space (pp); |
2866 | } |
2867 | |
2868 | for (tp = &TREE_OPERAND (node, 1); |
2869 | TREE_CODE (*tp) == COMPOUND_EXPR; |
2870 | tp = &TREE_OPERAND (*tp, 1)) |
2871 | { |
2872 | dump_generic_node (pp, TREE_OPERAND (*tp, 0), |
2873 | spc, flags, is_stmt: !(flags & TDF_SLIM)); |
2874 | if (flags & TDF_SLIM) |
2875 | newline_and_indent (pp, spc); |
2876 | else |
2877 | { |
2878 | pp_comma (pp); |
2879 | pp_space (pp); |
2880 | } |
2881 | } |
2882 | |
2883 | dump_generic_node (pp, node: *tp, spc, flags, is_stmt: !(flags & TDF_SLIM)); |
2884 | } |
2885 | break; |
2886 | |
2887 | case STATEMENT_LIST: |
2888 | { |
2889 | tree_stmt_iterator si; |
2890 | bool first = true; |
2891 | |
2892 | if (flags & TDF_SLIM) |
2893 | { |
2894 | pp_string (pp, "<STATEMENT_LIST>" ); |
2895 | break; |
2896 | } |
2897 | |
2898 | for (si = tsi_start (t: node); !tsi_end_p (i: si); tsi_next (i: &si)) |
2899 | { |
2900 | if (!first) |
2901 | newline_and_indent (pp, spc); |
2902 | else |
2903 | first = false; |
2904 | dump_generic_node (pp, node: tsi_stmt (i: si), spc, flags, is_stmt: true); |
2905 | } |
2906 | } |
2907 | break; |
2908 | |
2909 | case MODIFY_EXPR: |
2910 | case INIT_EXPR: |
2911 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, |
2912 | is_stmt: false); |
2913 | pp_space (pp); |
2914 | pp_equal (pp); |
2915 | pp_space (pp); |
2916 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, |
2917 | is_stmt: false); |
2918 | break; |
2919 | |
2920 | case TARGET_EXPR: |
2921 | pp_string (pp, "TARGET_EXPR <" ); |
2922 | dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, is_stmt: false); |
2923 | pp_comma (pp); |
2924 | pp_space (pp); |
2925 | dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, is_stmt: false); |
2926 | pp_greater (pp); |
2927 | break; |
2928 | |
2929 | case DECL_EXPR: |
2930 | print_declaration (pp, DECL_EXPR_DECL (node), spc, flags); |
2931 | is_stmt = false; |
2932 | break; |
2933 | |
2934 | case COND_EXPR: |
2935 | if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node) |
2936 | { |
2937 | pp_string (pp, "if (" ); |
2938 | dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, is_stmt: false); |
2939 | pp_right_paren (pp); |
2940 | /* The lowered cond_exprs should always be printed in full. */ |
2941 | if (COND_EXPR_THEN (node) |
2942 | && (IS_EMPTY_STMT (COND_EXPR_THEN (node)) |
2943 | || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR) |
2944 | && COND_EXPR_ELSE (node) |
2945 | && (IS_EMPTY_STMT (COND_EXPR_ELSE (node)) |
2946 | || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) |
2947 | { |
2948 | pp_space (pp); |
2949 | dump_generic_node (pp, COND_EXPR_THEN (node), |
2950 | spc: 0, flags, is_stmt: true); |
2951 | if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node))) |
2952 | { |
2953 | pp_string (pp, " else " ); |
2954 | dump_generic_node (pp, COND_EXPR_ELSE (node), |
2955 | spc: 0, flags, is_stmt: true); |
2956 | } |
2957 | } |
2958 | else if (!(flags & TDF_SLIM)) |
2959 | { |
2960 | /* Output COND_EXPR_THEN. */ |
2961 | if (COND_EXPR_THEN (node)) |
2962 | { |
2963 | newline_and_indent (pp, spc+2); |
2964 | pp_left_brace (pp); |
2965 | newline_and_indent (pp, spc+4); |
2966 | dump_generic_node (pp, COND_EXPR_THEN (node), spc: spc+4, |
2967 | flags, is_stmt: true); |
2968 | newline_and_indent (pp, spc+2); |
2969 | pp_right_brace (pp); |
2970 | } |
2971 | |
2972 | /* Output COND_EXPR_ELSE. */ |
2973 | if (COND_EXPR_ELSE (node) |
2974 | && !IS_EMPTY_STMT (COND_EXPR_ELSE (node))) |
2975 | { |
2976 | newline_and_indent (pp, spc); |
2977 | pp_string (pp, "else" ); |
2978 | newline_and_indent (pp, spc+2); |
2979 | pp_left_brace (pp); |
2980 | newline_and_indent (pp, spc+4); |
2981 | dump_generic_node (pp, COND_EXPR_ELSE (node), spc: spc+4, |
2982 | flags, is_stmt: true); |
2983 | newline_and_indent (pp, spc+2); |
2984 | pp_right_brace (pp); |
2985 | } |
2986 | } |
2987 | is_expr = false; |
2988 | } |
2989 | else |
2990 | { |
2991 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
2992 | pp_space (pp); |
2993 | pp_question (pp); |
2994 | pp_space (pp); |
2995 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
2996 | pp_space (pp); |
2997 | pp_colon (pp); |
2998 | pp_space (pp); |
2999 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3000 | } |
3001 | break; |
3002 | |
3003 | case BIND_EXPR: |
3004 | pp_left_brace (pp); |
3005 | if (!(flags & TDF_SLIM)) |
3006 | { |
3007 | if (BIND_EXPR_VARS (node)) |
3008 | { |
3009 | pp_newline (pp); |
3010 | |
3011 | for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0)) |
3012 | { |
3013 | print_declaration (pp, op0, spc+2, flags); |
3014 | pp_newline (pp); |
3015 | } |
3016 | } |
3017 | |
3018 | newline_and_indent (pp, spc+2); |
3019 | dump_generic_node (pp, BIND_EXPR_BODY (node), spc: spc+2, flags, is_stmt: true); |
3020 | newline_and_indent (pp, spc); |
3021 | pp_right_brace (pp); |
3022 | } |
3023 | is_expr = false; |
3024 | break; |
3025 | |
3026 | case CALL_EXPR: |
3027 | if (CALL_EXPR_FN (node) != NULL_TREE) |
3028 | print_call_name (pp, CALL_EXPR_FN (node), flags); |
3029 | else |
3030 | { |
3031 | pp_dot (pp); |
3032 | pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node))); |
3033 | } |
3034 | |
3035 | /* Print parameters. */ |
3036 | pp_space (pp); |
3037 | pp_left_paren (pp); |
3038 | { |
3039 | tree arg; |
3040 | call_expr_arg_iterator iter; |
3041 | FOR_EACH_CALL_EXPR_ARG (arg, iter, node) |
3042 | { |
3043 | dump_generic_node (pp, node: arg, spc, flags, is_stmt: false); |
3044 | if (more_call_expr_args_p (iter: &iter)) |
3045 | { |
3046 | pp_comma (pp); |
3047 | pp_space (pp); |
3048 | } |
3049 | } |
3050 | } |
3051 | if (CALL_EXPR_VA_ARG_PACK (node)) |
3052 | { |
3053 | if (call_expr_nargs (node) > 0) |
3054 | { |
3055 | pp_comma (pp); |
3056 | pp_space (pp); |
3057 | } |
3058 | pp_string (pp, "__builtin_va_arg_pack ()" ); |
3059 | } |
3060 | pp_right_paren (pp); |
3061 | |
3062 | op1 = CALL_EXPR_STATIC_CHAIN (node); |
3063 | if (op1) |
3064 | { |
3065 | pp_string (pp, " [static-chain: " ); |
3066 | dump_generic_node (pp, node: op1, spc, flags, is_stmt: false); |
3067 | pp_right_bracket (pp); |
3068 | } |
3069 | |
3070 | if (CALL_EXPR_RETURN_SLOT_OPT (node)) |
3071 | pp_string (pp, " [return slot optimization]" ); |
3072 | if (CALL_EXPR_TAILCALL (node)) |
3073 | pp_string (pp, " [tail call]" ); |
3074 | break; |
3075 | |
3076 | case WITH_CLEANUP_EXPR: |
3077 | NIY; |
3078 | break; |
3079 | |
3080 | case CLEANUP_POINT_EXPR: |
3081 | pp_string (pp, "<<cleanup_point " ); |
3082 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3083 | pp_string (pp, ">>" ); |
3084 | break; |
3085 | |
3086 | case PLACEHOLDER_EXPR: |
3087 | pp_string (pp, "<PLACEHOLDER_EXPR " ); |
3088 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
3089 | pp_greater (pp); |
3090 | break; |
3091 | |
3092 | /* Binary arithmetic and logic expressions. */ |
3093 | case WIDEN_SUM_EXPR: |
3094 | case WIDEN_MULT_EXPR: |
3095 | case MULT_EXPR: |
3096 | case MULT_HIGHPART_EXPR: |
3097 | case PLUS_EXPR: |
3098 | case POINTER_PLUS_EXPR: |
3099 | case POINTER_DIFF_EXPR: |
3100 | case MINUS_EXPR: |
3101 | case TRUNC_DIV_EXPR: |
3102 | case CEIL_DIV_EXPR: |
3103 | case FLOOR_DIV_EXPR: |
3104 | case ROUND_DIV_EXPR: |
3105 | case TRUNC_MOD_EXPR: |
3106 | case CEIL_MOD_EXPR: |
3107 | case FLOOR_MOD_EXPR: |
3108 | case ROUND_MOD_EXPR: |
3109 | case RDIV_EXPR: |
3110 | case EXACT_DIV_EXPR: |
3111 | case LSHIFT_EXPR: |
3112 | case RSHIFT_EXPR: |
3113 | case LROTATE_EXPR: |
3114 | case RROTATE_EXPR: |
3115 | case WIDEN_LSHIFT_EXPR: |
3116 | case BIT_IOR_EXPR: |
3117 | case BIT_XOR_EXPR: |
3118 | case BIT_AND_EXPR: |
3119 | case TRUTH_ANDIF_EXPR: |
3120 | case TRUTH_ORIF_EXPR: |
3121 | case TRUTH_AND_EXPR: |
3122 | case TRUTH_OR_EXPR: |
3123 | case TRUTH_XOR_EXPR: |
3124 | case LT_EXPR: |
3125 | case LE_EXPR: |
3126 | case GT_EXPR: |
3127 | case GE_EXPR: |
3128 | case EQ_EXPR: |
3129 | case NE_EXPR: |
3130 | case UNLT_EXPR: |
3131 | case UNLE_EXPR: |
3132 | case UNGT_EXPR: |
3133 | case UNGE_EXPR: |
3134 | case UNEQ_EXPR: |
3135 | case LTGT_EXPR: |
3136 | case ORDERED_EXPR: |
3137 | case UNORDERED_EXPR: |
3138 | { |
3139 | const char *op = op_symbol (node); |
3140 | op0 = TREE_OPERAND (node, 0); |
3141 | op1 = TREE_OPERAND (node, 1); |
3142 | |
3143 | /* When the operands are expressions with less priority, |
3144 | keep semantics of the tree representation. */ |
3145 | if (op_prio (op0) <= op_prio (node)) |
3146 | { |
3147 | pp_left_paren (pp); |
3148 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3149 | pp_right_paren (pp); |
3150 | } |
3151 | else |
3152 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3153 | |
3154 | pp_space (pp); |
3155 | pp_string (pp, op); |
3156 | pp_space (pp); |
3157 | |
3158 | /* When the operands are expressions with less priority, |
3159 | keep semantics of the tree representation. */ |
3160 | if (op_prio (op1) <= op_prio (node)) |
3161 | { |
3162 | pp_left_paren (pp); |
3163 | dump_generic_node (pp, node: op1, spc, flags, is_stmt: false); |
3164 | pp_right_paren (pp); |
3165 | } |
3166 | else |
3167 | dump_generic_node (pp, node: op1, spc, flags, is_stmt: false); |
3168 | } |
3169 | break; |
3170 | |
3171 | /* Unary arithmetic and logic expressions. */ |
3172 | case ADDR_EXPR: |
3173 | if (flags & TDF_GIMPLE_VAL) |
3174 | { |
3175 | pp_string (pp, "_Literal (" ); |
3176 | dump_generic_node (pp, TREE_TYPE (node), spc, |
3177 | flags: flags & ~TDF_GIMPLE_VAL, is_stmt: false); |
3178 | pp_character (pp, ')'); |
3179 | } |
3180 | /* Fallthru. */ |
3181 | case NEGATE_EXPR: |
3182 | case BIT_NOT_EXPR: |
3183 | case TRUTH_NOT_EXPR: |
3184 | case PREDECREMENT_EXPR: |
3185 | case PREINCREMENT_EXPR: |
3186 | case INDIRECT_REF: |
3187 | if (!(flags & TDF_GIMPLE) |
3188 | && TREE_CODE (node) == ADDR_EXPR |
3189 | && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST |
3190 | || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL)) |
3191 | /* Do not output '&' for strings and function pointers when not |
3192 | dumping GIMPLE FE syntax. */ |
3193 | ; |
3194 | else |
3195 | pp_string (pp, op_symbol (node)); |
3196 | |
3197 | if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) |
3198 | { |
3199 | pp_left_paren (pp); |
3200 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3201 | pp_right_paren (pp); |
3202 | } |
3203 | else |
3204 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3205 | break; |
3206 | |
3207 | case POSTDECREMENT_EXPR: |
3208 | case POSTINCREMENT_EXPR: |
3209 | if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) |
3210 | { |
3211 | pp_left_paren (pp); |
3212 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3213 | pp_right_paren (pp); |
3214 | } |
3215 | else |
3216 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3217 | pp_string (pp, op_symbol (node)); |
3218 | break; |
3219 | |
3220 | case MIN_EXPR: |
3221 | pp_string (pp, "MIN_EXPR <" ); |
3222 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3223 | pp_string (pp, ", " ); |
3224 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3225 | pp_greater (pp); |
3226 | break; |
3227 | |
3228 | case MAX_EXPR: |
3229 | pp_string (pp, "MAX_EXPR <" ); |
3230 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3231 | pp_string (pp, ", " ); |
3232 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3233 | pp_greater (pp); |
3234 | break; |
3235 | |
3236 | case ABS_EXPR: |
3237 | pp_string (pp, "ABS_EXPR <" ); |
3238 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3239 | pp_greater (pp); |
3240 | break; |
3241 | |
3242 | case ABSU_EXPR: |
3243 | pp_string (pp, "ABSU_EXPR <" ); |
3244 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3245 | pp_greater (pp); |
3246 | break; |
3247 | |
3248 | case RANGE_EXPR: |
3249 | NIY; |
3250 | break; |
3251 | |
3252 | case ADDR_SPACE_CONVERT_EXPR: |
3253 | case FIXED_CONVERT_EXPR: |
3254 | case FIX_TRUNC_EXPR: |
3255 | case FLOAT_EXPR: |
3256 | CASE_CONVERT: |
3257 | type = TREE_TYPE (node); |
3258 | op0 = TREE_OPERAND (node, 0); |
3259 | if (type != TREE_TYPE (op0)) |
3260 | { |
3261 | pp_left_paren (pp); |
3262 | dump_generic_node (pp, node: type, spc, flags, is_stmt: false); |
3263 | pp_string (pp, ") " ); |
3264 | } |
3265 | if (op_prio (op0) < op_prio (node)) |
3266 | pp_left_paren (pp); |
3267 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3268 | if (op_prio (op0) < op_prio (node)) |
3269 | pp_right_paren (pp); |
3270 | break; |
3271 | |
3272 | case VIEW_CONVERT_EXPR: |
3273 | if (flags & TDF_GIMPLE) |
3274 | pp_string (pp, "__VIEW_CONVERT <" ); |
3275 | else |
3276 | pp_string (pp, "VIEW_CONVERT_EXPR<" ); |
3277 | dump_generic_node (pp, TREE_TYPE (node), spc, flags, is_stmt: false); |
3278 | pp_string (pp, ">(" ); |
3279 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3280 | pp_right_paren (pp); |
3281 | break; |
3282 | |
3283 | case PAREN_EXPR: |
3284 | pp_string (pp, "((" ); |
3285 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3286 | pp_string (pp, "))" ); |
3287 | break; |
3288 | |
3289 | case NON_LVALUE_EXPR: |
3290 | pp_string (pp, "NON_LVALUE_EXPR <" ); |
3291 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3292 | pp_greater (pp); |
3293 | break; |
3294 | |
3295 | case SAVE_EXPR: |
3296 | pp_string (pp, "SAVE_EXPR <" ); |
3297 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3298 | pp_greater (pp); |
3299 | break; |
3300 | |
3301 | case COMPLEX_EXPR: |
3302 | pp_string (pp, "COMPLEX_EXPR <" ); |
3303 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3304 | pp_string (pp, ", " ); |
3305 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3306 | pp_greater (pp); |
3307 | break; |
3308 | |
3309 | case CONJ_EXPR: |
3310 | pp_string (pp, "CONJ_EXPR <" ); |
3311 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3312 | pp_greater (pp); |
3313 | break; |
3314 | |
3315 | case REALPART_EXPR: |
3316 | if (flags & TDF_GIMPLE) |
3317 | { |
3318 | pp_string (pp, "__real " ); |
3319 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3320 | } |
3321 | else |
3322 | { |
3323 | pp_string (pp, "REALPART_EXPR <" ); |
3324 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3325 | pp_greater (pp); |
3326 | } |
3327 | break; |
3328 | |
3329 | case IMAGPART_EXPR: |
3330 | if (flags & TDF_GIMPLE) |
3331 | { |
3332 | pp_string (pp, "__imag " ); |
3333 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3334 | } |
3335 | else |
3336 | { |
3337 | pp_string (pp, "IMAGPART_EXPR <" ); |
3338 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3339 | pp_greater (pp); |
3340 | } |
3341 | break; |
3342 | |
3343 | case VA_ARG_EXPR: |
3344 | pp_string (pp, "VA_ARG_EXPR <" ); |
3345 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3346 | pp_greater (pp); |
3347 | break; |
3348 | |
3349 | case TRY_FINALLY_EXPR: |
3350 | case TRY_CATCH_EXPR: |
3351 | pp_string (pp, "try" ); |
3352 | newline_and_indent (pp, spc+2); |
3353 | pp_left_brace (pp); |
3354 | newline_and_indent (pp, spc+4); |
3355 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc: spc+4, flags, is_stmt: true); |
3356 | newline_and_indent (pp, spc+2); |
3357 | pp_right_brace (pp); |
3358 | newline_and_indent (pp, spc); |
3359 | if (TREE_CODE (node) == TRY_CATCH_EXPR) |
3360 | { |
3361 | node = TREE_OPERAND (node, 1); |
3362 | pp_string (pp, "catch" ); |
3363 | } |
3364 | else |
3365 | { |
3366 | gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR); |
3367 | node = TREE_OPERAND (node, 1); |
3368 | pp_string (pp, "finally" ); |
3369 | if (TREE_CODE (node) == EH_ELSE_EXPR) |
3370 | { |
3371 | newline_and_indent (pp, spc+2); |
3372 | pp_left_brace (pp); |
3373 | newline_and_indent (pp, spc+4); |
3374 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc: spc+4, |
3375 | flags, is_stmt: true); |
3376 | newline_and_indent (pp, spc+2); |
3377 | pp_right_brace (pp); |
3378 | newline_and_indent (pp, spc); |
3379 | node = TREE_OPERAND (node, 1); |
3380 | pp_string (pp, "else" ); |
3381 | } |
3382 | } |
3383 | newline_and_indent (pp, spc+2); |
3384 | pp_left_brace (pp); |
3385 | newline_and_indent (pp, spc+4); |
3386 | dump_generic_node (pp, node, spc: spc+4, flags, is_stmt: true); |
3387 | newline_and_indent (pp, spc+2); |
3388 | pp_right_brace (pp); |
3389 | is_expr = false; |
3390 | break; |
3391 | |
3392 | case CATCH_EXPR: |
3393 | pp_string (pp, "catch (" ); |
3394 | dump_generic_node (pp, CATCH_TYPES (node), spc: spc+2, flags, is_stmt: false); |
3395 | pp_right_paren (pp); |
3396 | newline_and_indent (pp, spc+2); |
3397 | pp_left_brace (pp); |
3398 | newline_and_indent (pp, spc+4); |
3399 | dump_generic_node (pp, CATCH_BODY (node), spc: spc+4, flags, is_stmt: true); |
3400 | newline_and_indent (pp, spc+2); |
3401 | pp_right_brace (pp); |
3402 | is_expr = false; |
3403 | break; |
3404 | |
3405 | case EH_FILTER_EXPR: |
3406 | pp_string (pp, "<<<eh_filter (" ); |
3407 | dump_generic_node (pp, EH_FILTER_TYPES (node), spc: spc+2, flags, is_stmt: false); |
3408 | pp_string (pp, ")>>>" ); |
3409 | newline_and_indent (pp, spc+2); |
3410 | pp_left_brace (pp); |
3411 | newline_and_indent (pp, spc+4); |
3412 | dump_generic_node (pp, EH_FILTER_FAILURE (node), spc: spc+4, flags, is_stmt: true); |
3413 | newline_and_indent (pp, spc+2); |
3414 | pp_right_brace (pp); |
3415 | is_expr = false; |
3416 | break; |
3417 | |
3418 | case LABEL_EXPR: |
3419 | op0 = TREE_OPERAND (node, 0); |
3420 | /* If this is for break or continue, don't bother printing it. */ |
3421 | if (DECL_NAME (op0)) |
3422 | { |
3423 | const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); |
3424 | if (strcmp (s1: name, s2: "break" ) == 0 |
3425 | || strcmp (s1: name, s2: "continue" ) == 0) |
3426 | break; |
3427 | } |
3428 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3429 | pp_colon (pp); |
3430 | if (DECL_NONLOCAL (op0)) |
3431 | pp_string (pp, " [non-local]" ); |
3432 | break; |
3433 | |
3434 | case LOOP_EXPR: |
3435 | pp_string (pp, "while (1)" ); |
3436 | if (!(flags & TDF_SLIM)) |
3437 | { |
3438 | newline_and_indent (pp, spc+2); |
3439 | pp_left_brace (pp); |
3440 | newline_and_indent (pp, spc+4); |
3441 | dump_generic_node (pp, LOOP_EXPR_BODY (node), spc: spc+4, flags, is_stmt: true); |
3442 | newline_and_indent (pp, spc+2); |
3443 | pp_right_brace (pp); |
3444 | } |
3445 | is_expr = false; |
3446 | break; |
3447 | |
3448 | case PREDICT_EXPR: |
3449 | pp_string (pp, "// predicted " ); |
3450 | if (PREDICT_EXPR_OUTCOME (node)) |
3451 | pp_string (pp, "likely by " ); |
3452 | else |
3453 | pp_string (pp, "unlikely by " ); |
3454 | pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node))); |
3455 | pp_string (pp, " predictor." ); |
3456 | break; |
3457 | |
3458 | case ANNOTATE_EXPR: |
3459 | pp_string (pp, "ANNOTATE_EXPR <" ); |
3460 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3461 | switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1))) |
3462 | { |
3463 | case annot_expr_ivdep_kind: |
3464 | pp_string (pp, ", ivdep" ); |
3465 | break; |
3466 | case annot_expr_unroll_kind: |
3467 | { |
3468 | pp_string (pp, ", unroll " ); |
3469 | pp_decimal_int (pp, |
3470 | (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2))); |
3471 | break; |
3472 | } |
3473 | case annot_expr_no_vector_kind: |
3474 | pp_string (pp, ", no-vector" ); |
3475 | break; |
3476 | case annot_expr_vector_kind: |
3477 | pp_string (pp, ", vector" ); |
3478 | break; |
3479 | case annot_expr_parallel_kind: |
3480 | pp_string (pp, ", parallel" ); |
3481 | break; |
3482 | case annot_expr_maybe_infinite_kind: |
3483 | pp_string (pp, ", maybe-infinite" ); |
3484 | break; |
3485 | default: |
3486 | gcc_unreachable (); |
3487 | } |
3488 | pp_greater (pp); |
3489 | break; |
3490 | |
3491 | case RETURN_EXPR: |
3492 | pp_string (pp, "return" ); |
3493 | op0 = TREE_OPERAND (node, 0); |
3494 | if (op0) |
3495 | { |
3496 | pp_space (pp); |
3497 | if (TREE_CODE (op0) == MODIFY_EXPR) |
3498 | dump_generic_node (pp, TREE_OPERAND (op0, 1), |
3499 | spc, flags, is_stmt: false); |
3500 | else |
3501 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3502 | } |
3503 | break; |
3504 | |
3505 | case EXIT_EXPR: |
3506 | pp_string (pp, "if (" ); |
3507 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3508 | pp_string (pp, ") break" ); |
3509 | break; |
3510 | |
3511 | case SWITCH_EXPR: |
3512 | pp_string (pp, "switch (" ); |
3513 | dump_generic_node (pp, SWITCH_COND (node), spc, flags, is_stmt: false); |
3514 | pp_right_paren (pp); |
3515 | if (!(flags & TDF_SLIM)) |
3516 | { |
3517 | newline_and_indent (pp, spc+2); |
3518 | pp_left_brace (pp); |
3519 | if (SWITCH_BODY (node)) |
3520 | { |
3521 | newline_and_indent (pp, spc+4); |
3522 | dump_generic_node (pp, SWITCH_BODY (node), spc: spc+4, flags, |
3523 | is_stmt: true); |
3524 | } |
3525 | newline_and_indent (pp, spc+2); |
3526 | pp_right_brace (pp); |
3527 | } |
3528 | is_expr = false; |
3529 | break; |
3530 | |
3531 | case GOTO_EXPR: |
3532 | op0 = GOTO_DESTINATION (node); |
3533 | if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0)) |
3534 | { |
3535 | const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); |
3536 | if (strcmp (s1: name, s2: "break" ) == 0 |
3537 | || strcmp (s1: name, s2: "continue" ) == 0) |
3538 | { |
3539 | pp_string (pp, name); |
3540 | break; |
3541 | } |
3542 | } |
3543 | pp_string (pp, "goto " ); |
3544 | dump_generic_node (pp, node: op0, spc, flags, is_stmt: false); |
3545 | break; |
3546 | |
3547 | case ASM_EXPR: |
3548 | pp_string (pp, "__asm__" ); |
3549 | if (ASM_VOLATILE_P (node)) |
3550 | pp_string (pp, " __volatile__" ); |
3551 | pp_left_paren (pp); |
3552 | dump_generic_node (pp, ASM_STRING (node), spc, flags, is_stmt: false); |
3553 | pp_colon (pp); |
3554 | dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, is_stmt: false); |
3555 | pp_colon (pp); |
3556 | dump_generic_node (pp, ASM_INPUTS (node), spc, flags, is_stmt: false); |
3557 | if (ASM_CLOBBERS (node)) |
3558 | { |
3559 | pp_colon (pp); |
3560 | dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, is_stmt: false); |
3561 | } |
3562 | pp_right_paren (pp); |
3563 | break; |
3564 | |
3565 | case CASE_LABEL_EXPR: |
3566 | if (CASE_LOW (node) && CASE_HIGH (node)) |
3567 | { |
3568 | pp_string (pp, "case " ); |
3569 | dump_generic_node (pp, CASE_LOW (node), spc, flags, is_stmt: false); |
3570 | pp_string (pp, " ... " ); |
3571 | dump_generic_node (pp, CASE_HIGH (node), spc, flags, is_stmt: false); |
3572 | } |
3573 | else if (CASE_LOW (node)) |
3574 | { |
3575 | pp_string (pp, "case " ); |
3576 | dump_generic_node (pp, CASE_LOW (node), spc, flags, is_stmt: false); |
3577 | } |
3578 | else |
3579 | pp_string (pp, "default" ); |
3580 | pp_colon (pp); |
3581 | break; |
3582 | |
3583 | case OBJ_TYPE_REF: |
3584 | pp_string (pp, "OBJ_TYPE_REF(" ); |
3585 | dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, is_stmt: false); |
3586 | pp_semicolon (pp); |
3587 | /* We omit the class type for -fcompare-debug because we may |
3588 | drop TYPE_BINFO early depending on debug info, and then |
3589 | virtual_method_call_p would return false, whereas when |
3590 | TYPE_BINFO is preserved it may still return true and then |
3591 | we'd print the class type. Compare tree and rtl dumps for |
3592 | libstdc++-prettyprinters/shared_ptr.cc with and without -g, |
3593 | for example, at occurrences of OBJ_TYPE_REF. */ |
3594 | if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG)) |
3595 | && virtual_method_call_p (node, true)) |
3596 | { |
3597 | pp_string (pp, "(" ); |
3598 | dump_generic_node (pp, node: obj_type_ref_class (ref: node, true), |
3599 | spc, flags, is_stmt: false); |
3600 | pp_string (pp, ")" ); |
3601 | } |
3602 | dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, is_stmt: false); |
3603 | pp_arrow (pp); |
3604 | dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, is_stmt: false); |
3605 | pp_right_paren (pp); |
3606 | break; |
3607 | |
3608 | case SSA_NAME: |
3609 | if (SSA_NAME_IDENTIFIER (node)) |
3610 | { |
3611 | if ((flags & TDF_NOUID) |
3612 | && SSA_NAME_VAR (node) |
3613 | && DECL_NAMELESS (SSA_NAME_VAR (node))) |
3614 | dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node)); |
3615 | else if (! (flags & TDF_GIMPLE) |
3616 | || SSA_NAME_VAR (node)) |
3617 | dump_generic_node (pp, SSA_NAME_IDENTIFIER (node), |
3618 | spc, flags, is_stmt: false); |
3619 | } |
3620 | pp_underscore (pp); |
3621 | pp_decimal_int (pp, SSA_NAME_VERSION (node)); |
3622 | if (SSA_NAME_IS_DEFAULT_DEF (node)) |
3623 | pp_string (pp, "(D)" ); |
3624 | if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) |
3625 | pp_string (pp, "(ab)" ); |
3626 | break; |
3627 | |
3628 | case WITH_SIZE_EXPR: |
3629 | pp_string (pp, "WITH_SIZE_EXPR <" ); |
3630 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3631 | pp_string (pp, ", " ); |
3632 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3633 | pp_greater (pp); |
3634 | break; |
3635 | |
3636 | case SCEV_KNOWN: |
3637 | pp_string (pp, "scev_known" ); |
3638 | break; |
3639 | |
3640 | case SCEV_NOT_KNOWN: |
3641 | pp_string (pp, "scev_not_known" ); |
3642 | break; |
3643 | |
3644 | case POLYNOMIAL_CHREC: |
3645 | pp_left_brace (pp); |
3646 | dump_generic_node (pp, CHREC_LEFT (node), spc, flags, is_stmt: false); |
3647 | pp_string (pp, ", +, " ); |
3648 | dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, is_stmt: false); |
3649 | pp_string (pp, !CHREC_NOWRAP (node) ? "}_" : "}<nw>_" ); |
3650 | pp_scalar (pp, "%u" , CHREC_VARIABLE (node)); |
3651 | is_stmt = false; |
3652 | break; |
3653 | |
3654 | case REALIGN_LOAD_EXPR: |
3655 | pp_string (pp, "REALIGN_LOAD <" ); |
3656 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3657 | pp_string (pp, ", " ); |
3658 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3659 | pp_string (pp, ", " ); |
3660 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3661 | pp_greater (pp); |
3662 | break; |
3663 | |
3664 | case VEC_COND_EXPR: |
3665 | pp_string (pp, " VEC_COND_EXPR < " ); |
3666 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3667 | pp_string (pp, " , " ); |
3668 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3669 | pp_string (pp, " , " ); |
3670 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3671 | pp_string (pp, " > " ); |
3672 | break; |
3673 | |
3674 | case VEC_PERM_EXPR: |
3675 | pp_string (pp, " VEC_PERM_EXPR < " ); |
3676 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3677 | pp_string (pp, " , " ); |
3678 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3679 | pp_string (pp, " , " ); |
3680 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3681 | pp_string (pp, " > " ); |
3682 | break; |
3683 | |
3684 | case DOT_PROD_EXPR: |
3685 | pp_string (pp, " DOT_PROD_EXPR < " ); |
3686 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3687 | pp_string (pp, ", " ); |
3688 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3689 | pp_string (pp, ", " ); |
3690 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3691 | pp_string (pp, " > " ); |
3692 | break; |
3693 | |
3694 | case WIDEN_MULT_PLUS_EXPR: |
3695 | pp_string (pp, " WIDEN_MULT_PLUS_EXPR < " ); |
3696 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3697 | pp_string (pp, ", " ); |
3698 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3699 | pp_string (pp, ", " ); |
3700 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3701 | pp_string (pp, " > " ); |
3702 | break; |
3703 | |
3704 | case WIDEN_MULT_MINUS_EXPR: |
3705 | pp_string (pp, " WIDEN_MULT_MINUS_EXPR < " ); |
3706 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3707 | pp_string (pp, ", " ); |
3708 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3709 | pp_string (pp, ", " ); |
3710 | dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, is_stmt: false); |
3711 | pp_string (pp, " > " ); |
3712 | break; |
3713 | |
3714 | case OACC_PARALLEL: |
3715 | pp_string (pp, "#pragma acc parallel" ); |
3716 | goto dump_omp_clauses_body; |
3717 | |
3718 | case OACC_KERNELS: |
3719 | pp_string (pp, "#pragma acc kernels" ); |
3720 | goto dump_omp_clauses_body; |
3721 | |
3722 | case OACC_SERIAL: |
3723 | pp_string (pp, "#pragma acc serial" ); |
3724 | goto dump_omp_clauses_body; |
3725 | |
3726 | case OACC_DATA: |
3727 | pp_string (pp, "#pragma acc data" ); |
3728 | dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags); |
3729 | goto dump_omp_body; |
3730 | |
3731 | case OACC_HOST_DATA: |
3732 | pp_string (pp, "#pragma acc host_data" ); |
3733 | dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags); |
3734 | goto dump_omp_body; |
3735 | |
3736 | case OACC_DECLARE: |
3737 | pp_string (pp, "#pragma acc declare" ); |
3738 | dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags); |
3739 | break; |
3740 | |
3741 | case OACC_UPDATE: |
3742 | pp_string (pp, "#pragma acc update" ); |
3743 | dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags); |
3744 | break; |
3745 | |
3746 | case OACC_ENTER_DATA: |
3747 | pp_string (pp, "#pragma acc enter data" ); |
3748 | dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags); |
3749 | break; |
3750 | |
3751 | case OACC_EXIT_DATA: |
3752 | pp_string (pp, "#pragma acc exit data" ); |
3753 | dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags); |
3754 | break; |
3755 | |
3756 | case OACC_CACHE: |
3757 | pp_string (pp, "#pragma acc cache" ); |
3758 | dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags); |
3759 | break; |
3760 | |
3761 | case OMP_PARALLEL: |
3762 | pp_string (pp, "#pragma omp parallel" ); |
3763 | dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags); |
3764 | goto dump_omp_body; |
3765 | |
3766 | dump_omp_clauses_body: |
3767 | dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags); |
3768 | goto dump_omp_body; |
3769 | |
3770 | dump_omp_body: |
3771 | if (!(flags & TDF_SLIM) && OMP_BODY (node)) |
3772 | { |
3773 | newline_and_indent (pp, spc + 2); |
3774 | pp_left_brace (pp); |
3775 | newline_and_indent (pp, spc + 4); |
3776 | dump_generic_node (pp, OMP_BODY (node), spc: spc + 4, flags, is_stmt: false); |
3777 | newline_and_indent (pp, spc + 2); |
3778 | pp_right_brace (pp); |
3779 | } |
3780 | is_expr = false; |
3781 | break; |
3782 | |
3783 | case OMP_TASK: |
3784 | pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task" |
3785 | : "#pragma omp taskwait" ); |
3786 | dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags); |
3787 | goto dump_omp_body; |
3788 | |
3789 | case OMP_FOR: |
3790 | pp_string (pp, "#pragma omp for" ); |
3791 | goto dump_omp_loop; |
3792 | |
3793 | case OMP_SIMD: |
3794 | pp_string (pp, "#pragma omp simd" ); |
3795 | goto dump_omp_loop; |
3796 | |
3797 | case OMP_DISTRIBUTE: |
3798 | pp_string (pp, "#pragma omp distribute" ); |
3799 | goto dump_omp_loop; |
3800 | |
3801 | case OMP_TASKLOOP: |
3802 | pp_string (pp, "#pragma omp taskloop" ); |
3803 | goto dump_omp_loop; |
3804 | |
3805 | case OMP_LOOP: |
3806 | pp_string (pp, "#pragma omp loop" ); |
3807 | goto dump_omp_loop; |
3808 | |
3809 | case OACC_LOOP: |
3810 | pp_string (pp, "#pragma acc loop" ); |
3811 | goto dump_omp_loop; |
3812 | |
3813 | case OMP_TEAMS: |
3814 | pp_string (pp, "#pragma omp teams" ); |
3815 | dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags); |
3816 | goto dump_omp_body; |
3817 | |
3818 | case OMP_TARGET_DATA: |
3819 | pp_string (pp, "#pragma omp target data" ); |
3820 | dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags); |
3821 | goto dump_omp_body; |
3822 | |
3823 | case OMP_TARGET_ENTER_DATA: |
3824 | pp_string (pp, "#pragma omp target enter data" ); |
3825 | dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags); |
3826 | is_expr = false; |
3827 | break; |
3828 | |
3829 | case OMP_TARGET_EXIT_DATA: |
3830 | pp_string (pp, "#pragma omp target exit data" ); |
3831 | dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags); |
3832 | is_expr = false; |
3833 | break; |
3834 | |
3835 | case OMP_TARGET: |
3836 | pp_string (pp, "#pragma omp target" ); |
3837 | dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags); |
3838 | goto dump_omp_body; |
3839 | |
3840 | case OMP_TARGET_UPDATE: |
3841 | pp_string (pp, "#pragma omp target update" ); |
3842 | dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags); |
3843 | is_expr = false; |
3844 | break; |
3845 | |
3846 | dump_omp_loop: |
3847 | dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags); |
3848 | if (!(flags & TDF_SLIM)) |
3849 | { |
3850 | int i; |
3851 | |
3852 | if (OMP_FOR_PRE_BODY (node)) |
3853 | { |
3854 | newline_and_indent (pp, spc + 2); |
3855 | pp_left_brace (pp); |
3856 | spc += 4; |
3857 | newline_and_indent (pp, spc); |
3858 | dump_generic_node (pp, OMP_FOR_PRE_BODY (node), |
3859 | spc, flags, is_stmt: false); |
3860 | } |
3861 | if (OMP_FOR_INIT (node)) |
3862 | { |
3863 | spc -= 2; |
3864 | for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++) |
3865 | { |
3866 | spc += 2; |
3867 | newline_and_indent (pp, spc); |
3868 | pp_string (pp, "for (" ); |
3869 | tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i); |
3870 | if (TREE_CODE (init) != MODIFY_EXPR |
3871 | || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC) |
3872 | dump_generic_node (pp, node: init, spc, flags, is_stmt: false); |
3873 | else |
3874 | { |
3875 | dump_generic_node (pp, TREE_OPERAND (init, 0), |
3876 | spc, flags, is_stmt: false); |
3877 | pp_string (pp, " = " ); |
3878 | dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1), |
3879 | spc, flags); |
3880 | } |
3881 | pp_string (pp, "; " ); |
3882 | tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i); |
3883 | if (!COMPARISON_CLASS_P (cond) |
3884 | || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC) |
3885 | dump_generic_node (pp, node: cond, spc, flags, is_stmt: false); |
3886 | else |
3887 | { |
3888 | dump_generic_node (pp, TREE_OPERAND (cond, 0), |
3889 | spc, flags, is_stmt: false); |
3890 | const char *op = op_symbol (cond); |
3891 | pp_space (pp); |
3892 | pp_string (pp, op); |
3893 | pp_space (pp); |
3894 | dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1), |
3895 | spc, flags); |
3896 | } |
3897 | pp_string (pp, "; " ); |
3898 | dump_generic_node (pp, |
3899 | TREE_VEC_ELT (OMP_FOR_INCR (node), i), |
3900 | spc, flags, is_stmt: false); |
3901 | pp_right_paren (pp); |
3902 | } |
3903 | } |
3904 | if (OMP_FOR_BODY (node)) |
3905 | { |
3906 | newline_and_indent (pp, spc + 2); |
3907 | pp_left_brace (pp); |
3908 | newline_and_indent (pp, spc + 4); |
3909 | dump_generic_node (pp, OMP_FOR_BODY (node), spc: spc + 4, flags, |
3910 | is_stmt: false); |
3911 | newline_and_indent (pp, spc + 2); |
3912 | pp_right_brace (pp); |
3913 | } |
3914 | if (OMP_FOR_INIT (node)) |
3915 | spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2; |
3916 | if (OMP_FOR_PRE_BODY (node)) |
3917 | { |
3918 | spc -= 4; |
3919 | newline_and_indent (pp, spc + 2); |
3920 | pp_right_brace (pp); |
3921 | } |
3922 | } |
3923 | is_expr = false; |
3924 | break; |
3925 | |
3926 | case OMP_SECTIONS: |
3927 | pp_string (pp, "#pragma omp sections" ); |
3928 | dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags); |
3929 | goto dump_omp_body; |
3930 | |
3931 | case OMP_SECTION: |
3932 | pp_string (pp, "#pragma omp section" ); |
3933 | goto dump_omp_body; |
3934 | |
3935 | case OMP_STRUCTURED_BLOCK: |
3936 | pp_string (pp, "#pragma omp __structured_block" ); |
3937 | goto dump_omp_body; |
3938 | |
3939 | case OMP_SCAN: |
3940 | if (OMP_SCAN_CLAUSES (node)) |
3941 | { |
3942 | pp_string (pp, "#pragma omp scan" ); |
3943 | dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags); |
3944 | } |
3945 | goto dump_omp_body; |
3946 | |
3947 | case OMP_MASTER: |
3948 | pp_string (pp, "#pragma omp master" ); |
3949 | goto dump_omp_body; |
3950 | |
3951 | case OMP_MASKED: |
3952 | pp_string (pp, "#pragma omp masked" ); |
3953 | dump_omp_clauses (pp, OMP_MASKED_CLAUSES (node), spc, flags); |
3954 | goto dump_omp_body; |
3955 | |
3956 | case OMP_TASKGROUP: |
3957 | pp_string (pp, "#pragma omp taskgroup" ); |
3958 | dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags); |
3959 | goto dump_omp_body; |
3960 | |
3961 | case OMP_ORDERED: |
3962 | pp_string (pp, "#pragma omp ordered" ); |
3963 | dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags); |
3964 | goto dump_omp_body; |
3965 | |
3966 | case OMP_CRITICAL: |
3967 | pp_string (pp, "#pragma omp critical" ); |
3968 | if (OMP_CRITICAL_NAME (node)) |
3969 | { |
3970 | pp_space (pp); |
3971 | pp_left_paren (pp); |
3972 | dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc, |
3973 | flags, is_stmt: false); |
3974 | pp_right_paren (pp); |
3975 | } |
3976 | dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags); |
3977 | goto dump_omp_body; |
3978 | |
3979 | case OMP_ATOMIC: |
3980 | pp_string (pp, "#pragma omp atomic" ); |
3981 | if (OMP_ATOMIC_WEAK (node)) |
3982 | pp_string (pp, " weak" ); |
3983 | dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node)); |
3984 | newline_and_indent (pp, spc + 2); |
3985 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3986 | pp_space (pp); |
3987 | pp_equal (pp); |
3988 | pp_space (pp); |
3989 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
3990 | break; |
3991 | |
3992 | case OMP_ATOMIC_READ: |
3993 | pp_string (pp, "#pragma omp atomic read" ); |
3994 | dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node)); |
3995 | newline_and_indent (pp, spc + 2); |
3996 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
3997 | pp_space (pp); |
3998 | break; |
3999 | |
4000 | case OMP_ATOMIC_CAPTURE_OLD: |
4001 | case OMP_ATOMIC_CAPTURE_NEW: |
4002 | pp_string (pp, "#pragma omp atomic capture" ); |
4003 | if (OMP_ATOMIC_WEAK (node)) |
4004 | pp_string (pp, " weak" ); |
4005 | dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node)); |
4006 | newline_and_indent (pp, spc + 2); |
4007 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4008 | pp_space (pp); |
4009 | pp_equal (pp); |
4010 | pp_space (pp); |
4011 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4012 | break; |
4013 | |
4014 | case OMP_SINGLE: |
4015 | pp_string (pp, "#pragma omp single" ); |
4016 | dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags); |
4017 | goto dump_omp_body; |
4018 | |
4019 | case OMP_SCOPE: |
4020 | pp_string (pp, "#pragma omp scope" ); |
4021 | dump_omp_clauses (pp, OMP_SCOPE_CLAUSES (node), spc, flags); |
4022 | goto dump_omp_body; |
4023 | |
4024 | case OMP_CLAUSE: |
4025 | /* If we come here, we're dumping something that's not an OMP construct, |
4026 | for example, OMP clauses attached to a function's '__attribute__'. |
4027 | Dump the whole OMP clause chain. */ |
4028 | dump_omp_clauses (pp, clause: node, spc, flags, leading_space: false); |
4029 | is_expr = false; |
4030 | break; |
4031 | |
4032 | case TRANSACTION_EXPR: |
4033 | if (TRANSACTION_EXPR_OUTER (node)) |
4034 | pp_string (pp, "__transaction_atomic [[outer]]" ); |
4035 | else if (TRANSACTION_EXPR_RELAXED (node)) |
4036 | pp_string (pp, "__transaction_relaxed" ); |
4037 | else |
4038 | pp_string (pp, "__transaction_atomic" ); |
4039 | if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node)) |
4040 | { |
4041 | newline_and_indent (pp, spc); |
4042 | pp_left_brace (pp); |
4043 | newline_and_indent (pp, spc + 2); |
4044 | dump_generic_node (pp, TRANSACTION_EXPR_BODY (node), |
4045 | spc: spc + 2, flags, is_stmt: false); |
4046 | newline_and_indent (pp, spc); |
4047 | pp_right_brace (pp); |
4048 | } |
4049 | is_expr = false; |
4050 | break; |
4051 | |
4052 | case VEC_SERIES_EXPR: |
4053 | case VEC_WIDEN_MULT_HI_EXPR: |
4054 | case VEC_WIDEN_MULT_LO_EXPR: |
4055 | case VEC_WIDEN_MULT_EVEN_EXPR: |
4056 | case VEC_WIDEN_MULT_ODD_EXPR: |
4057 | case VEC_WIDEN_LSHIFT_HI_EXPR: |
4058 | case VEC_WIDEN_LSHIFT_LO_EXPR: |
4059 | pp_space (pp); |
4060 | for (str = get_tree_code_name (code); *str; str++) |
4061 | pp_character (pp, TOUPPER (*str)); |
4062 | pp_string (pp, " < " ); |
4063 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4064 | pp_string (pp, ", " ); |
4065 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4066 | pp_string (pp, " > " ); |
4067 | break; |
4068 | |
4069 | case VEC_DUPLICATE_EXPR: |
4070 | pp_space (pp); |
4071 | for (str = get_tree_code_name (code); *str; str++) |
4072 | pp_character (pp, TOUPPER (*str)); |
4073 | pp_string (pp, " < " ); |
4074 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4075 | pp_string (pp, " > " ); |
4076 | break; |
4077 | |
4078 | case VEC_UNPACK_HI_EXPR: |
4079 | pp_string (pp, " VEC_UNPACK_HI_EXPR < " ); |
4080 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4081 | pp_string (pp, " > " ); |
4082 | break; |
4083 | |
4084 | case VEC_UNPACK_LO_EXPR: |
4085 | pp_string (pp, " VEC_UNPACK_LO_EXPR < " ); |
4086 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4087 | pp_string (pp, " > " ); |
4088 | break; |
4089 | |
4090 | case VEC_UNPACK_FLOAT_HI_EXPR: |
4091 | pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < " ); |
4092 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4093 | pp_string (pp, " > " ); |
4094 | break; |
4095 | |
4096 | case VEC_UNPACK_FLOAT_LO_EXPR: |
4097 | pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < " ); |
4098 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4099 | pp_string (pp, " > " ); |
4100 | break; |
4101 | |
4102 | case VEC_UNPACK_FIX_TRUNC_HI_EXPR: |
4103 | pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < " ); |
4104 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4105 | pp_string (pp, " > " ); |
4106 | break; |
4107 | |
4108 | case VEC_UNPACK_FIX_TRUNC_LO_EXPR: |
4109 | pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < " ); |
4110 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4111 | pp_string (pp, " > " ); |
4112 | break; |
4113 | |
4114 | case VEC_PACK_TRUNC_EXPR: |
4115 | pp_string (pp, " VEC_PACK_TRUNC_EXPR < " ); |
4116 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4117 | pp_string (pp, ", " ); |
4118 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4119 | pp_string (pp, " > " ); |
4120 | break; |
4121 | |
4122 | case VEC_PACK_SAT_EXPR: |
4123 | pp_string (pp, " VEC_PACK_SAT_EXPR < " ); |
4124 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4125 | pp_string (pp, ", " ); |
4126 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4127 | pp_string (pp, " > " ); |
4128 | break; |
4129 | |
4130 | case VEC_PACK_FIX_TRUNC_EXPR: |
4131 | pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < " ); |
4132 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4133 | pp_string (pp, ", " ); |
4134 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4135 | pp_string (pp, " > " ); |
4136 | break; |
4137 | |
4138 | case VEC_PACK_FLOAT_EXPR: |
4139 | pp_string (pp, " VEC_PACK_FLOAT_EXPR < " ); |
4140 | dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, is_stmt: false); |
4141 | pp_string (pp, ", " ); |
4142 | dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, is_stmt: false); |
4143 | pp_string (pp, " > " ); |
4144 | break; |
4145 | |
4146 | case BLOCK: |
4147 | dump_block_node (pp, block: node, spc, flags); |
4148 | break; |
4149 | |
4150 | case DEBUG_BEGIN_STMT: |
4151 | pp_string (pp, "# DEBUG BEGIN STMT" ); |
4152 | break; |
4153 | |
4154 | default: |
4155 | NIY; |
4156 | } |
4157 | |
4158 | if (is_stmt && is_expr) |
4159 | pp_semicolon (pp); |
4160 | |
4161 | return spc; |
4162 | } |
4163 | |
4164 | /* Print the declaration of a variable. */ |
4165 | |
4166 | void |
4167 | print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags) |
4168 | { |
4169 | INDENT (spc); |
4170 | |
4171 | if (TREE_CODE(t) == NAMELIST_DECL) |
4172 | { |
4173 | pp_string(pp, "namelist " ); |
4174 | dump_decl_name (pp, node: t, flags); |
4175 | pp_semicolon (pp); |
4176 | return; |
4177 | } |
4178 | |
4179 | if (TREE_CODE (t) == TYPE_DECL) |
4180 | pp_string (pp, "typedef " ); |
4181 | |
4182 | if (HAS_RTL_P (t) && DECL_REGISTER (t)) |
4183 | pp_string (pp, "register " ); |
4184 | |
4185 | if (TREE_PUBLIC (t) && DECL_EXTERNAL (t)) |
4186 | pp_string (pp, "extern " ); |
4187 | else if (TREE_STATIC (t)) |
4188 | pp_string (pp, "static " ); |
4189 | |
4190 | /* Print the type and name. */ |
4191 | if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) |
4192 | { |
4193 | tree tmp; |
4194 | |
4195 | /* Print array's type. */ |
4196 | tmp = TREE_TYPE (t); |
4197 | while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE) |
4198 | tmp = TREE_TYPE (tmp); |
4199 | dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, is_stmt: false); |
4200 | |
4201 | /* Print variable's name. */ |
4202 | pp_space (pp); |
4203 | dump_generic_node (pp, node: t, spc, flags, is_stmt: false); |
4204 | |
4205 | /* Print the dimensions. */ |
4206 | tmp = TREE_TYPE (t); |
4207 | while (TREE_CODE (tmp) == ARRAY_TYPE) |
4208 | { |
4209 | dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags); |
4210 | tmp = TREE_TYPE (tmp); |
4211 | } |
4212 | } |
4213 | else if (TREE_CODE (t) == FUNCTION_DECL) |
4214 | { |
4215 | dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, is_stmt: false); |
4216 | pp_space (pp); |
4217 | dump_decl_name (pp, node: t, flags); |
4218 | dump_function_declaration (pp, TREE_TYPE (t), spc, flags); |
4219 | } |
4220 | else |
4221 | { |
4222 | /* Print type declaration. */ |
4223 | dump_generic_node (pp, TREE_TYPE (t), spc, flags, is_stmt: false); |
4224 | |
4225 | /* Print variable's name. */ |
4226 | pp_space (pp); |
4227 | dump_generic_node (pp, node: t, spc, flags, is_stmt: false); |
4228 | } |
4229 | |
4230 | if (VAR_P (t) && DECL_HARD_REGISTER (t)) |
4231 | { |
4232 | pp_string (pp, " __asm__ " ); |
4233 | pp_left_paren (pp); |
4234 | dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, is_stmt: false); |
4235 | pp_right_paren (pp); |
4236 | } |
4237 | |
4238 | /* The initial value of a function serves to determine whether the function |
4239 | is declared or defined. So the following does not apply to function |
4240 | nodes. */ |
4241 | if (TREE_CODE (t) != FUNCTION_DECL) |
4242 | { |
4243 | /* Print the initial value. */ |
4244 | if (DECL_INITIAL (t)) |
4245 | { |
4246 | pp_space (pp); |
4247 | pp_equal (pp); |
4248 | pp_space (pp); |
4249 | if (!(flags & TDF_SLIM)) |
4250 | dump_generic_node (pp, DECL_INITIAL (t), spc, flags, is_stmt: false); |
4251 | else |
4252 | pp_string (pp, "<<< omitted >>>" ); |
4253 | } |
4254 | } |
4255 | |
4256 | if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t)) |
4257 | { |
4258 | pp_string (pp, " [value-expr: " ); |
4259 | dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, is_stmt: false); |
4260 | pp_right_bracket (pp); |
4261 | } |
4262 | |
4263 | pp_semicolon (pp); |
4264 | } |
4265 | |
4266 | |
4267 | /* Prints a structure: name, fields, and methods. |
4268 | FIXME: Still incomplete. */ |
4269 | |
4270 | static void |
4271 | print_struct_decl (pretty_printer *pp, const_tree node, int spc, |
4272 | dump_flags_t flags) |
4273 | { |
4274 | /* Print the name of the structure. */ |
4275 | if (TYPE_NAME (node)) |
4276 | { |
4277 | INDENT (spc); |
4278 | if (TREE_CODE (node) == RECORD_TYPE) |
4279 | pp_string (pp, "struct " ); |
4280 | else if ((TREE_CODE (node) == UNION_TYPE |
4281 | || TREE_CODE (node) == QUAL_UNION_TYPE)) |
4282 | pp_string (pp, "union " ); |
4283 | |
4284 | dump_generic_node (pp, TYPE_NAME (node), spc, flags: TDF_NONE, is_stmt: false); |
4285 | } |
4286 | |
4287 | /* Print the contents of the structure. */ |
4288 | pp_newline (pp); |
4289 | INDENT (spc); |
4290 | pp_left_brace (pp); |
4291 | pp_newline (pp); |
4292 | |
4293 | /* Print the fields of the structure. */ |
4294 | { |
4295 | tree tmp; |
4296 | tmp = TYPE_FIELDS (node); |
4297 | while (tmp) |
4298 | { |
4299 | /* Avoid to print recursively the structure. */ |
4300 | /* FIXME : Not implemented correctly..., |
4301 | what about the case when we have a cycle in the contain graph? ... |
4302 | Maybe this could be solved by looking at the scope in which the |
4303 | structure was declared. */ |
4304 | if (TREE_TYPE (tmp) != node |
4305 | && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE |
4306 | || TREE_TYPE (TREE_TYPE (tmp)) != node)) |
4307 | { |
4308 | print_declaration (pp, t: tmp, spc: spc+2, flags); |
4309 | pp_newline (pp); |
4310 | } |
4311 | tmp = DECL_CHAIN (tmp); |
4312 | } |
4313 | } |
4314 | INDENT (spc); |
4315 | pp_right_brace (pp); |
4316 | } |
4317 | |
4318 | /* Return the priority of the operator CODE. |
4319 | |
4320 | From lowest to highest precedence with either left-to-right (L-R) |
4321 | or right-to-left (R-L) associativity]: |
4322 | |
4323 | 1 [L-R] , |
4324 | 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>= |
4325 | 3 [R-L] ?: |
4326 | 4 [L-R] || |
4327 | 5 [L-R] && |
4328 | 6 [L-R] | |
4329 | 7 [L-R] ^ |
4330 | 8 [L-R] & |
4331 | 9 [L-R] == != |
4332 | 10 [L-R] < <= > >= |
4333 | 11 [L-R] << >> |
4334 | 12 [L-R] + - |
4335 | 13 [L-R] * / % |
4336 | 14 [R-L] ! ~ ++ -- + - * & (type) sizeof |
4337 | 15 [L-R] fn() [] -> . |
4338 | |
4339 | unary +, - and * have higher precedence than the corresponding binary |
4340 | operators. */ |
4341 | |
4342 | int |
4343 | op_code_prio (enum tree_code code) |
4344 | { |
4345 | switch (code) |
4346 | { |
4347 | case TREE_LIST: |
4348 | case COMPOUND_EXPR: |
4349 | case BIND_EXPR: |
4350 | return 1; |
4351 | |
4352 | case MODIFY_EXPR: |
4353 | case INIT_EXPR: |
4354 | return 2; |
4355 | |
4356 | case COND_EXPR: |
4357 | return 3; |
4358 | |
4359 | case TRUTH_OR_EXPR: |
4360 | case TRUTH_ORIF_EXPR: |
4361 | return 4; |
4362 | |
4363 | case TRUTH_AND_EXPR: |
4364 | case TRUTH_ANDIF_EXPR: |
4365 | return 5; |
4366 | |
4367 | case BIT_IOR_EXPR: |
4368 | return 6; |
4369 | |
4370 | case BIT_XOR_EXPR: |
4371 | case TRUTH_XOR_EXPR: |
4372 | return 7; |
4373 | |
4374 | case BIT_AND_EXPR: |
4375 | return 8; |
4376 | |
4377 | case EQ_EXPR: |
4378 | case NE_EXPR: |
4379 | return 9; |
4380 | |
4381 | case UNLT_EXPR: |
4382 | case UNLE_EXPR: |
4383 | case UNGT_EXPR: |
4384 | case UNGE_EXPR: |
4385 | case UNEQ_EXPR: |
4386 | case LTGT_EXPR: |
4387 | case ORDERED_EXPR: |
4388 | case UNORDERED_EXPR: |
4389 | case LT_EXPR: |
4390 | case LE_EXPR: |
4391 | case GT_EXPR: |
4392 | case GE_EXPR: |
4393 | return 10; |
4394 | |
4395 | case LSHIFT_EXPR: |
4396 | case RSHIFT_EXPR: |
4397 | case LROTATE_EXPR: |
4398 | case RROTATE_EXPR: |
4399 | case VEC_WIDEN_LSHIFT_HI_EXPR: |
4400 | case VEC_WIDEN_LSHIFT_LO_EXPR: |
4401 | case WIDEN_LSHIFT_EXPR: |
4402 | return 11; |
4403 | |
4404 | case WIDEN_SUM_EXPR: |
4405 | case PLUS_EXPR: |
4406 | case POINTER_PLUS_EXPR: |
4407 | case POINTER_DIFF_EXPR: |
4408 | case MINUS_EXPR: |
4409 | return 12; |
4410 | |
4411 | case VEC_WIDEN_MULT_HI_EXPR: |
4412 | case VEC_WIDEN_MULT_LO_EXPR: |
4413 | case WIDEN_MULT_EXPR: |
4414 | case DOT_PROD_EXPR: |
4415 | case WIDEN_MULT_PLUS_EXPR: |
4416 | case WIDEN_MULT_MINUS_EXPR: |
4417 | case MULT_EXPR: |
4418 | case MULT_HIGHPART_EXPR: |
4419 | case TRUNC_DIV_EXPR: |
4420 | case CEIL_DIV_EXPR: |
4421 | case FLOOR_DIV_EXPR: |
4422 | case ROUND_DIV_EXPR: |
4423 | case RDIV_EXPR: |
4424 | case EXACT_DIV_EXPR: |
4425 | case TRUNC_MOD_EXPR: |
4426 | case CEIL_MOD_EXPR: |
4427 | case FLOOR_MOD_EXPR: |
4428 | case ROUND_MOD_EXPR: |
4429 | return 13; |
4430 | |
4431 | case TRUTH_NOT_EXPR: |
4432 | case BIT_NOT_EXPR: |
4433 | case POSTINCREMENT_EXPR: |
4434 | case POSTDECREMENT_EXPR: |
4435 | case PREINCREMENT_EXPR: |
4436 | case PREDECREMENT_EXPR: |
4437 | case NEGATE_EXPR: |
4438 | case INDIRECT_REF: |
4439 | case ADDR_EXPR: |
4440 | case FLOAT_EXPR: |
4441 | CASE_CONVERT: |
4442 | case FIX_TRUNC_EXPR: |
4443 | case TARGET_EXPR: |
4444 | return 14; |
4445 | |
4446 | case CALL_EXPR: |
4447 | case ARRAY_REF: |
4448 | case ARRAY_RANGE_REF: |
4449 | case COMPONENT_REF: |
4450 | return 15; |
4451 | |
4452 | /* Special expressions. */ |
4453 | case MIN_EXPR: |
4454 | case MAX_EXPR: |
4455 | case ABS_EXPR: |
4456 | case REALPART_EXPR: |
4457 | case IMAGPART_EXPR: |
4458 | case VEC_UNPACK_HI_EXPR: |
4459 | case VEC_UNPACK_LO_EXPR: |
4460 | case VEC_UNPACK_FLOAT_HI_EXPR: |
4461 | case VEC_UNPACK_FLOAT_LO_EXPR: |
4462 | case VEC_UNPACK_FIX_TRUNC_HI_EXPR: |
4463 | case VEC_UNPACK_FIX_TRUNC_LO_EXPR: |
4464 | case VEC_PACK_TRUNC_EXPR: |
4465 | case VEC_PACK_SAT_EXPR: |
4466 | return 16; |
4467 | |
4468 | default: |
4469 | /* Return an arbitrarily high precedence to avoid surrounding single |
4470 | VAR_DECLs in ()s. */ |
4471 | return 9999; |
4472 | } |
4473 | } |
4474 | |
4475 | /* Return the priority of the operator OP. */ |
4476 | |
4477 | int |
4478 | op_prio (const_tree op) |
4479 | { |
4480 | enum tree_code code; |
4481 | |
4482 | if (op == NULL) |
4483 | return 9999; |
4484 | |
4485 | code = TREE_CODE (op); |
4486 | if (code == SAVE_EXPR || code == NON_LVALUE_EXPR) |
4487 | return op_prio (TREE_OPERAND (op, 0)); |
4488 | |
4489 | return op_code_prio (code); |
4490 | } |
4491 | |
4492 | /* Return the symbol associated with operator CODE. */ |
4493 | |
4494 | const char * |
4495 | op_symbol_code (enum tree_code code, dump_flags_t flags) |
4496 | { |
4497 | switch (code) |
4498 | { |
4499 | case MODIFY_EXPR: |
4500 | return "=" ; |
4501 | |
4502 | case TRUTH_OR_EXPR: |
4503 | case TRUTH_ORIF_EXPR: |
4504 | return "||" ; |
4505 | |
4506 | case TRUTH_AND_EXPR: |
4507 | case TRUTH_ANDIF_EXPR: |
4508 | return "&&" ; |
4509 | |
4510 | case BIT_IOR_EXPR: |
4511 | return "|" ; |
4512 | |
4513 | case TRUTH_XOR_EXPR: |
4514 | case BIT_XOR_EXPR: |
4515 | return "^" ; |
4516 | |
4517 | case ADDR_EXPR: |
4518 | case BIT_AND_EXPR: |
4519 | return "&" ; |
4520 | |
4521 | case ORDERED_EXPR: |
4522 | return (flags & TDF_GIMPLE) ? "__ORDERED" : "ord" ; |
4523 | case UNORDERED_EXPR: |
4524 | return (flags & TDF_GIMPLE) ? "__UNORDERED" : "unord" ; |
4525 | |
4526 | case EQ_EXPR: |
4527 | return "==" ; |
4528 | case UNEQ_EXPR: |
4529 | return (flags & TDF_GIMPLE) ? "__UNEQ" : "u==" ; |
4530 | |
4531 | case NE_EXPR: |
4532 | return "!=" ; |
4533 | |
4534 | case LT_EXPR: |
4535 | return "<" ; |
4536 | case UNLT_EXPR: |
4537 | return (flags & TDF_GIMPLE) ? "__UNLT" : "u<" ; |
4538 | |
4539 | case LE_EXPR: |
4540 | return "<=" ; |
4541 | case UNLE_EXPR: |
4542 | return (flags & TDF_GIMPLE) ? "__UNLE" : "u<=" ; |
4543 | |
4544 | case GT_EXPR: |
4545 | return ">" ; |
4546 | case UNGT_EXPR: |
4547 | return (flags & TDF_GIMPLE) ? "__UNGT" : "u>" ; |
4548 | |
4549 | case GE_EXPR: |
4550 | return ">=" ; |
4551 | case UNGE_EXPR: |
4552 | return (flags & TDF_GIMPLE) ? "__UNGE" : "u>=" ; |
4553 | |
4554 | case LTGT_EXPR: |
4555 | return (flags & TDF_GIMPLE) ? "__LTGT" : "<>" ; |
4556 | |
4557 | case LSHIFT_EXPR: |
4558 | return "<<" ; |
4559 | |
4560 | case RSHIFT_EXPR: |
4561 | return ">>" ; |
4562 | |
4563 | case LROTATE_EXPR: |
4564 | return "r<<" ; |
4565 | |
4566 | case RROTATE_EXPR: |
4567 | return "r>>" ; |
4568 | |
4569 | case WIDEN_LSHIFT_EXPR: |
4570 | return "w<<" ; |
4571 | |
4572 | case POINTER_PLUS_EXPR: |
4573 | return "+" ; |
4574 | |
4575 | case PLUS_EXPR: |
4576 | return "+" ; |
4577 | |
4578 | case WIDEN_SUM_EXPR: |
4579 | return "w+" ; |
4580 | |
4581 | case WIDEN_MULT_EXPR: |
4582 | return "w*" ; |
4583 | |
4584 | case MULT_HIGHPART_EXPR: |
4585 | return (flags & TDF_GIMPLE) ? "__MULT_HIGHPART" : "h*" ; |
4586 | |
4587 | case NEGATE_EXPR: |
4588 | case MINUS_EXPR: |
4589 | case POINTER_DIFF_EXPR: |
4590 | return "-" ; |
4591 | |
4592 | case BIT_NOT_EXPR: |
4593 | return "~" ; |
4594 | |
4595 | case TRUTH_NOT_EXPR: |
4596 | return "!" ; |
4597 | |
4598 | case MULT_EXPR: |
4599 | case INDIRECT_REF: |
4600 | return "*" ; |
4601 | |
4602 | case TRUNC_DIV_EXPR: |
4603 | case RDIV_EXPR: |
4604 | return "/" ; |
4605 | |
4606 | case CEIL_DIV_EXPR: |
4607 | return "/[cl]" ; |
4608 | |
4609 | case FLOOR_DIV_EXPR: |
4610 | return "/[fl]" ; |
4611 | |
4612 | case ROUND_DIV_EXPR: |
4613 | return "/[rd]" ; |
4614 | |
4615 | case EXACT_DIV_EXPR: |
4616 | return "/[ex]" ; |
4617 | |
4618 | case TRUNC_MOD_EXPR: |
4619 | return "%" ; |
4620 | |
4621 | case CEIL_MOD_EXPR: |
4622 | return "%[cl]" ; |
4623 | |
4624 | case FLOOR_MOD_EXPR: |
4625 | return "%[fl]" ; |
4626 | |
4627 | case ROUND_MOD_EXPR: |
4628 | return "%[rd]" ; |
4629 | |
4630 | case PREDECREMENT_EXPR: |
4631 | return " --" ; |
4632 | |
4633 | case PREINCREMENT_EXPR: |
4634 | return " ++" ; |
4635 | |
4636 | case POSTDECREMENT_EXPR: |
4637 | return "-- " ; |
4638 | |
4639 | case POSTINCREMENT_EXPR: |
4640 | return "++ " ; |
4641 | |
4642 | case MAX_EXPR: |
4643 | return "max" ; |
4644 | |
4645 | case MIN_EXPR: |
4646 | return "min" ; |
4647 | |
4648 | default: |
4649 | return "<<< ??? >>>" ; |
4650 | } |
4651 | } |
4652 | |
4653 | /* Return the symbol associated with operator OP. */ |
4654 | |
4655 | static const char * |
4656 | op_symbol (const_tree op, dump_flags_t flags) |
4657 | { |
4658 | return op_symbol_code (TREE_CODE (op), flags); |
4659 | } |
4660 | |
4661 | /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or |
4662 | the gimple_call_fn of a GIMPLE_CALL. */ |
4663 | |
4664 | void |
4665 | print_call_name (pretty_printer *pp, tree node, dump_flags_t flags) |
4666 | { |
4667 | tree op0 = node; |
4668 | int spc = 0; |
4669 | |
4670 | if (TREE_CODE (op0) == NON_LVALUE_EXPR) |
4671 | op0 = TREE_OPERAND (op0, 0); |
4672 | |
4673 | again: |
4674 | switch (TREE_CODE (op0)) |
4675 | { |
4676 | case VAR_DECL: |
4677 | case PARM_DECL: |
4678 | case FUNCTION_DECL: |
4679 | dump_function_name (pp, node: op0, flags); |
4680 | break; |
4681 | |
4682 | case ADDR_EXPR: |
4683 | case INDIRECT_REF: |
4684 | CASE_CONVERT: |
4685 | op0 = TREE_OPERAND (op0, 0); |
4686 | goto again; |
4687 | |
4688 | case COND_EXPR: |
4689 | pp_left_paren (pp); |
4690 | dump_generic_node (pp, TREE_OPERAND (op0, 0), spc: 0, flags, is_stmt: false); |
4691 | pp_string (pp, ") ? " ); |
4692 | dump_generic_node (pp, TREE_OPERAND (op0, 1), spc: 0, flags, is_stmt: false); |
4693 | pp_string (pp, " : " ); |
4694 | dump_generic_node (pp, TREE_OPERAND (op0, 2), spc: 0, flags, is_stmt: false); |
4695 | break; |
4696 | |
4697 | case ARRAY_REF: |
4698 | if (VAR_P (TREE_OPERAND (op0, 0))) |
4699 | dump_function_name (pp, TREE_OPERAND (op0, 0), flags); |
4700 | else |
4701 | dump_generic_node (pp, node: op0, spc: 0, flags, is_stmt: false); |
4702 | break; |
4703 | |
4704 | case MEM_REF: |
4705 | if (integer_zerop (TREE_OPERAND (op0, 1))) |
4706 | { |
4707 | op0 = TREE_OPERAND (op0, 0); |
4708 | goto again; |
4709 | } |
4710 | /* Fallthru. */ |
4711 | case COMPONENT_REF: |
4712 | case SSA_NAME: |
4713 | case OBJ_TYPE_REF: |
4714 | dump_generic_node (pp, node: op0, spc: 0, flags, is_stmt: false); |
4715 | break; |
4716 | |
4717 | default: |
4718 | NIY; |
4719 | } |
4720 | } |
4721 | |
4722 | /* Print the first N characters in the array STR, replacing non-printable |
4723 | characters (including embedded nuls) with unambiguous escape sequences. */ |
4724 | |
4725 | void |
4726 | pretty_print_string (pretty_printer *pp, const char *str, size_t n) |
4727 | { |
4728 | if (str == NULL) |
4729 | return; |
4730 | |
4731 | for ( ; n; --n, ++str) |
4732 | { |
4733 | switch (str[0]) |
4734 | { |
4735 | case '\b': |
4736 | pp_string (pp, "\\b" ); |
4737 | break; |
4738 | |
4739 | case '\f': |
4740 | pp_string (pp, "\\f" ); |
4741 | break; |
4742 | |
4743 | case '\n': |
4744 | pp_string (pp, "\\n" ); |
4745 | break; |
4746 | |
4747 | case '\r': |
4748 | pp_string (pp, "\\r" ); |
4749 | break; |
4750 | |
4751 | case '\t': |
4752 | pp_string (pp, "\\t" ); |
4753 | break; |
4754 | |
4755 | case '\v': |
4756 | pp_string (pp, "\\v" ); |
4757 | break; |
4758 | |
4759 | case '\\': |
4760 | pp_string (pp, "\\\\" ); |
4761 | break; |
4762 | |
4763 | case '\"': |
4764 | pp_string (pp, "\\\"" ); |
4765 | break; |
4766 | |
4767 | case '\'': |
4768 | pp_string (pp, "\\'" ); |
4769 | break; |
4770 | |
4771 | default: |
4772 | if (str[0] || n > 1) |
4773 | { |
4774 | if (!ISPRINT (str[0])) |
4775 | { |
4776 | char buf[5]; |
4777 | sprintf (s: buf, format: "\\x%02x" , (unsigned char)str[0]); |
4778 | pp_string (pp, buf); |
4779 | } |
4780 | else |
4781 | pp_character (pp, str[0]); |
4782 | break; |
4783 | } |
4784 | } |
4785 | } |
4786 | } |
4787 | |
4788 | static void |
4789 | maybe_init_pretty_print (FILE *file) |
4790 | { |
4791 | if (!tree_pp) |
4792 | { |
4793 | tree_pp = new pretty_printer (); |
4794 | pp_needs_newline (tree_pp) = true; |
4795 | pp_translate_identifiers (tree_pp) = false; |
4796 | } |
4797 | |
4798 | tree_pp->buffer->stream = file; |
4799 | } |
4800 | |
4801 | static void |
4802 | newline_and_indent (pretty_printer *pp, int spc) |
4803 | { |
4804 | pp_newline (pp); |
4805 | INDENT (spc); |
4806 | } |
4807 | |
4808 | /* Print the identifier ID to PRETTY-PRINTER. */ |
4809 | |
4810 | void |
4811 | pp_tree_identifier (pretty_printer *pp, tree id) |
4812 | { |
4813 | if (pp_translate_identifiers (pp)) |
4814 | { |
4815 | const char *text = identifier_to_locale (IDENTIFIER_POINTER (id)); |
4816 | pp_append_text (pp, text, text + strlen (s: text)); |
4817 | } |
4818 | else |
4819 | pp_append_text (pp, IDENTIFIER_POINTER (id), |
4820 | IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id)); |
4821 | } |
4822 | |
4823 | /* A helper function that is used to dump function information before the |
4824 | function dump. */ |
4825 | |
4826 | void |
4827 | (FILE *dump_file, tree fdecl, dump_flags_t flags) |
4828 | { |
4829 | const char *dname, *aname; |
4830 | struct cgraph_node *node = cgraph_node::get (decl: fdecl); |
4831 | struct function *fun = DECL_STRUCT_FUNCTION (fdecl); |
4832 | |
4833 | dname = lang_hooks.decl_printable_name (fdecl, 1); |
4834 | |
4835 | if (DECL_ASSEMBLER_NAME_SET_P (fdecl)) |
4836 | aname = (IDENTIFIER_POINTER |
4837 | (DECL_ASSEMBLER_NAME (fdecl))); |
4838 | else |
4839 | aname = "<unset-asm-name>" ; |
4840 | |
4841 | fprintf (stream: dump_file, format: "\n;; Function %s (%s, funcdef_no=%d" , |
4842 | dname, aname, fun->funcdef_no); |
4843 | if (!(flags & TDF_NOUID)) |
4844 | fprintf (stream: dump_file, format: ", decl_uid=%d" , DECL_UID (fdecl)); |
4845 | if (node) |
4846 | { |
4847 | fprintf (stream: dump_file, format: ", cgraph_uid=%d" , node->get_uid ()); |
4848 | fprintf (stream: dump_file, format: ", symbol_order=%d)%s\n\n" , node->order, |
4849 | node->frequency == NODE_FREQUENCY_HOT |
4850 | ? " (hot)" |
4851 | : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED |
4852 | ? " (unlikely executed)" |
4853 | : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE |
4854 | ? " (executed once)" |
4855 | : "" ); |
4856 | } |
4857 | else |
4858 | fprintf (stream: dump_file, format: ")\n\n" ); |
4859 | } |
4860 | |
4861 | /* Dump double_int D to pretty_printer PP. UNS is true |
4862 | if D is unsigned and false otherwise. */ |
4863 | void |
4864 | pp_double_int (pretty_printer *pp, double_int d, bool uns) |
4865 | { |
4866 | if (d.fits_shwi ()) |
4867 | pp_wide_integer (pp, i: d.low); |
4868 | else if (d.fits_uhwi ()) |
4869 | pp_unsigned_wide_integer (pp, d.low); |
4870 | else |
4871 | { |
4872 | unsigned HOST_WIDE_INT low = d.low; |
4873 | HOST_WIDE_INT high = d.high; |
4874 | if (!uns && d.is_negative ()) |
4875 | { |
4876 | pp_minus (pp); |
4877 | high = ~high + !low; |
4878 | low = -low; |
4879 | } |
4880 | /* Would "%x%0*x" or "%x%*0x" get zero-padding on all |
4881 | systems? */ |
4882 | sprintf (pp_buffer (pp)->digit_buffer, |
4883 | HOST_WIDE_INT_PRINT_DOUBLE_HEX, |
4884 | (unsigned HOST_WIDE_INT) high, low); |
4885 | pp_string (pp, pp_buffer (pp)->digit_buffer); |
4886 | } |
4887 | } |
4888 | |
4889 | #if __GNUC__ >= 10 |
4890 | # pragma GCC diagnostic pop |
4891 | #endif |
4892 | |