| /* Pretty formatting of GENERIC trees in C syntax. |
| Copyright (C) 2001-2020 Free Software Foundation, Inc. |
| Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com> |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "backend.h" |
| #include "rtl.h" |
| #include "tree.h" |
| #include "predict.h" |
| #include "cgraph.h" |
| #include "tree-pretty-print.h" |
| #include "stor-layout.h" |
| #include "langhooks.h" |
| #include "tree-iterator.h" |
| #include "dumpfile.h" |
| #include "internal-fn.h" |
| #include "gomp-constants.h" |
| #include "gimple.h" |
| #include "fold-const.h" |
| |
| /* Disable warnings about quoting issues in the pp_xxx calls below |
| that (intentionally) don't follow GCC diagnostic conventions. */ |
| #if __GNUC__ >= 10 |
| # pragma GCC diagnostic push |
| # pragma GCC diagnostic ignored "-Wformat-diag" |
| #endif |
| |
| /* Local functions, macros and variables. */ |
| static const char *op_symbol (const_tree); |
| static void newline_and_indent (pretty_printer *, int); |
| static void maybe_init_pretty_print (FILE *); |
| static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t); |
| static void do_niy (pretty_printer *, const_tree, dump_flags_t); |
| |
| #define INDENT(SPACE) do { \ |
| int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0) |
| |
| #define NIY do_niy (pp, node, flags) |
| |
| static pretty_printer *tree_pp; |
| |
| /* Try to print something for an unknown tree code. */ |
| |
| static void |
| do_niy (pretty_printer *pp, const_tree node, dump_flags_t flags) |
| { |
| int i, len; |
| |
| pp_string (pp, "<<< Unknown tree: "); |
| pp_string (pp, get_tree_code_name (TREE_CODE (node))); |
| |
| if (EXPR_P (node)) |
| { |
| len = TREE_OPERAND_LENGTH (node); |
| for (i = 0; i < len; ++i) |
| { |
| newline_and_indent (pp, 2); |
| dump_generic_node (pp, TREE_OPERAND (node, i), 2, flags, false); |
| } |
| } |
| |
| pp_string (pp, " >>>"); |
| } |
| |
| /* Debugging function to print out a generic expression. */ |
| |
| DEBUG_FUNCTION void |
| debug_generic_expr (tree t) |
| { |
| print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); |
| fprintf (stderr, "\n"); |
| } |
| |
| /* Debugging function to print out a generic statement. */ |
| |
| DEBUG_FUNCTION void |
| debug_generic_stmt (tree t) |
| { |
| print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); |
| fprintf (stderr, "\n"); |
| } |
| |
| /* Debugging function to print out a chain of trees . */ |
| |
| DEBUG_FUNCTION void |
| debug_tree_chain (tree t) |
| { |
| hash_set<tree> seen; |
| |
| while (t) |
| { |
| print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
| fprintf (stderr, " "); |
| t = TREE_CHAIN (t); |
| if (seen.add (t)) |
| { |
| fprintf (stderr, "... [cycled back to "); |
| print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
| fprintf (stderr, "]"); |
| break; |
| } |
| } |
| fprintf (stderr, "\n"); |
| } |
| |
| /* Prints declaration DECL to the FILE with details specified by FLAGS. */ |
| void |
| print_generic_decl (FILE *file, tree decl, dump_flags_t flags) |
| { |
| maybe_init_pretty_print (file); |
| print_declaration (tree_pp, decl, 2, flags); |
| pp_write_text_to_stream (tree_pp); |
| } |
| |
| /* Print tree T, and its successors, on file FILE. FLAGS specifies details |
| to show in the dump. See TDF_* in dumpfile.h. */ |
| |
| void |
| print_generic_stmt (FILE *file, tree t, dump_flags_t flags) |
| { |
| maybe_init_pretty_print (file); |
| dump_generic_node (tree_pp, t, 0, flags, true); |
| pp_newline_and_flush (tree_pp); |
| } |
| |
| /* Print tree T, and its successors, on file FILE. FLAGS specifies details |
| to show in the dump. See TDF_* in dumpfile.h. The output is indented by |
| INDENT spaces. */ |
| |
| void |
| print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent) |
| { |
| int i; |
| |
| maybe_init_pretty_print (file); |
| |
| for (i = 0; i < indent; i++) |
| pp_space (tree_pp); |
| dump_generic_node (tree_pp, t, indent, flags, true); |
| pp_newline_and_flush (tree_pp); |
| } |
| |
| /* Print a single expression T on file FILE. FLAGS specifies details to show |
| in the dump. See TDF_* in dumpfile.h. */ |
| |
| void |
| print_generic_expr (FILE *file, tree t, dump_flags_t flags) |
| { |
| maybe_init_pretty_print (file); |
| dump_generic_node (tree_pp, t, 0, flags, false); |
| pp_flush (tree_pp); |
| } |
| |
| /* Print a single expression T to string, and return it. */ |
| |
| char * |
| print_generic_expr_to_str (tree t) |
| { |
| pretty_printer pp; |
| dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false); |
| return xstrdup (pp_formatted_text (&pp)); |
| } |
| |
| /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences |
| in it are replaced with Dxxxx, as long as they are at the start or |
| preceded by $ and at the end or followed by $. See make_fancy_name |
| in tree-sra.c. */ |
| |
| static void |
| dump_fancy_name (pretty_printer *pp, tree name) |
| { |
| int cnt = 0; |
| int length = IDENTIFIER_LENGTH (name); |
| const char *n = IDENTIFIER_POINTER (name); |
| do |
| { |
| n = strchr (n, 'D'); |
| if (n == NULL) |
| break; |
| if (ISDIGIT (n[1]) |
| && (n == IDENTIFIER_POINTER (name) || n[-1] == '$')) |
| { |
| int l = 2; |
| while (ISDIGIT (n[l])) |
| l++; |
| if (n[l] == '\0' || n[l] == '$') |
| { |
| cnt++; |
| length += 5 - l; |
| } |
| n += l; |
| } |
| else |
| n++; |
| } |
| while (1); |
| if (cnt == 0) |
| { |
| pp_tree_identifier (pp, name); |
| return; |
| } |
| |
| char *str = XNEWVEC (char, length + 1); |
| char *p = str; |
| const char *q; |
| q = n = IDENTIFIER_POINTER (name); |
| do |
| { |
| q = strchr (q, 'D'); |
| if (q == NULL) |
| break; |
| if (ISDIGIT (q[1]) |
| && (q == IDENTIFIER_POINTER (name) || q[-1] == '$')) |
| { |
| int l = 2; |
| while (ISDIGIT (q[l])) |
| l++; |
| if (q[l] == '\0' || q[l] == '$') |
| { |
| memcpy (p, n, q - n); |
| memcpy (p + (q - n), "Dxxxx", 5); |
| p += (q - n) + 5; |
| n = q + l; |
| } |
| q += l; |
| } |
| else |
| q++; |
| } |
| while (1); |
| memcpy (p, n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name))); |
| str[length] = '\0'; |
| if (pp_translate_identifiers (pp)) |
| { |
| const char *text = identifier_to_locale (str); |
| pp_append_text (pp, text, text + strlen (text)); |
| } |
| else |
| pp_append_text (pp, str, str + length); |
| XDELETEVEC (str); |
| } |
| |
| /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set |
| in FLAGS. */ |
| |
| static void |
| dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags) |
| { |
| tree name = DECL_NAME (node); |
| if (name) |
| { |
| if ((flags & TDF_ASMNAME) |
| && HAS_DECL_ASSEMBLER_NAME_P (node) |
| && DECL_ASSEMBLER_NAME_SET_P (node)) |
| pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node)); |
| /* For -fcompare-debug don't dump DECL_NAMELESS names at all, |
| -g might have created more fancy names and their indexes |
| could get out of sync. Usually those should be DECL_IGNORED_P |
| too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy |
| names, let's hope those never get out of sync after doing the |
| dump_fancy_name sanitization. */ |
| else if ((flags & TDF_COMPARE_DEBUG) |
| && DECL_NAMELESS (node) |
| && DECL_IGNORED_P (node)) |
| name = NULL_TREE; |
| /* For DECL_NAMELESS names look for embedded uids in the |
| names and sanitize them for TDF_NOUID. */ |
| else if ((flags & TDF_NOUID) && DECL_NAMELESS (node)) |
| dump_fancy_name (pp, name); |
| else |
| pp_tree_identifier (pp, name); |
| } |
| char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.'; |
| if ((flags & TDF_UID) || name == NULL_TREE) |
| { |
| if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) |
| pp_printf (pp, "L%c%d", uid_sep, (int) LABEL_DECL_UID (node)); |
| else if (TREE_CODE (node) == DEBUG_EXPR_DECL) |
| { |
| if (flags & TDF_NOUID) |
| pp_string (pp, "D#xxxx"); |
| else |
| pp_printf (pp, "D#%i", DEBUG_TEMP_UID (node)); |
| } |
| else |
| { |
| char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D'; |
| if (flags & TDF_NOUID) |
| pp_printf (pp, "%c.xxxx", c); |
| else |
| pp_printf (pp, "%c%c%u", c, uid_sep, DECL_UID (node)); |
| } |
| } |
| if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node)) |
| { |
| if (flags & TDF_NOUID) |
| pp_printf (pp, "ptD.xxxx"); |
| else |
| pp_printf (pp, "ptD.%u", DECL_PT_UID (node)); |
| } |
| } |
| |
| /* Like the above, but used for pretty printing function calls. */ |
| |
| static void |
| dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags) |
| { |
| if (CONVERT_EXPR_P (node)) |
| node = TREE_OPERAND (node, 0); |
| if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0) |
| pp_string (pp, lang_hooks.decl_printable_name (node, 1)); |
| else |
| dump_decl_name (pp, node, flags); |
| } |
| |
| /* Dump a function declaration. NODE is the FUNCTION_TYPE. PP, SPC and |
| FLAGS are as in dump_generic_node. */ |
| |
| static void |
| dump_function_declaration (pretty_printer *pp, tree node, |
| int spc, dump_flags_t flags) |
| { |
| bool wrote_arg = false; |
| tree arg; |
| |
| pp_space (pp); |
| pp_left_paren (pp); |
| |
| /* Print the argument types. */ |
| arg = TYPE_ARG_TYPES (node); |
| while (arg && arg != void_list_node && arg != error_mark_node) |
| { |
| if (wrote_arg) |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| wrote_arg = true; |
| dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false); |
| arg = TREE_CHAIN (arg); |
| } |
| |
| /* Drop the trailing void_type_node if we had any previous argument. */ |
| if (arg == void_list_node && !wrote_arg) |
| pp_string (pp, "void"); |
| /* Properly dump vararg function types. */ |
| else if (!arg && wrote_arg) |
| pp_string (pp, ", ..."); |
| /* Avoid printing any arg for unprototyped functions. */ |
| |
| pp_right_paren (pp); |
| } |
| |
| /* Dump the domain associated with an array. */ |
| |
| static void |
| dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags) |
| { |
| pp_left_bracket (pp); |
| if (domain) |
| { |
| tree min = TYPE_MIN_VALUE (domain); |
| tree max = TYPE_MAX_VALUE (domain); |
| |
| if (min && max |
| && integer_zerop (min) |
| && tree_fits_shwi_p (max)) |
| pp_wide_integer (pp, tree_to_shwi (max) + 1); |
| else |
| { |
| if (min) |
| dump_generic_node (pp, min, spc, flags, false); |
| pp_colon (pp); |
| if (max) |
| dump_generic_node (pp, max, spc, flags, false); |
| } |
| } |
| else |
| pp_string (pp, "<unknown>"); |
| pp_right_bracket (pp); |
| } |
| |
| |
| /* Dump OpenMP iterators ITER. */ |
| |
| static void |
| dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags) |
| { |
| pp_string (pp, "iterator("); |
| for (tree it = iter; it; it = TREE_CHAIN (it)) |
| { |
| if (it != iter) |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_TYPE (TREE_VEC_ELT (it, 0)), spc, flags, |
| false); |
| pp_space (pp); |
| dump_generic_node (pp, TREE_VEC_ELT (it, 0), spc, flags, false); |
| pp_equal (pp); |
| dump_generic_node (pp, TREE_VEC_ELT (it, 1), spc, flags, false); |
| pp_colon (pp); |
| dump_generic_node (pp, TREE_VEC_ELT (it, 2), spc, flags, false); |
| pp_colon (pp); |
| dump_generic_node (pp, TREE_VEC_ELT (it, 3), spc, flags, false); |
| } |
| pp_right_paren (pp); |
| } |
| |
| |
| /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in |
| dump_generic_node. */ |
| |
| static void |
| dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags) |
| { |
| const char *name; |
| const char *modifier = NULL; |
| switch (OMP_CLAUSE_CODE (clause)) |
| { |
| case OMP_CLAUSE_PRIVATE: |
| name = "private"; |
| goto print_remap; |
| case OMP_CLAUSE_SHARED: |
| name = "shared"; |
| goto print_remap; |
| case OMP_CLAUSE_FIRSTPRIVATE: |
| name = "firstprivate"; |
| goto print_remap; |
| case OMP_CLAUSE_LASTPRIVATE: |
| name = "lastprivate"; |
| if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause)) |
| modifier = "conditional:"; |
| goto print_remap; |
| case OMP_CLAUSE_COPYIN: |
| name = "copyin"; |
| goto print_remap; |
| case OMP_CLAUSE_COPYPRIVATE: |
| name = "copyprivate"; |
| goto print_remap; |
| case OMP_CLAUSE_UNIFORM: |
| name = "uniform"; |
| goto print_remap; |
| case OMP_CLAUSE_USE_DEVICE_PTR: |
| name = "use_device_ptr"; |
| if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause)) |
| modifier = "if_present:"; |
| goto print_remap; |
| case OMP_CLAUSE_USE_DEVICE_ADDR: |
| name = "use_device_addr"; |
| goto print_remap; |
| case OMP_CLAUSE_IS_DEVICE_PTR: |
| name = "is_device_ptr"; |
| goto print_remap; |
| case OMP_CLAUSE_INCLUSIVE: |
| name = "inclusive"; |
| goto print_remap; |
| case OMP_CLAUSE_EXCLUSIVE: |
| name = "exclusive"; |
| goto print_remap; |
| case OMP_CLAUSE__LOOPTEMP_: |
| name = "_looptemp_"; |
| goto print_remap; |
| case OMP_CLAUSE__REDUCTEMP_: |
| name = "_reductemp_"; |
| goto print_remap; |
| case OMP_CLAUSE__CONDTEMP_: |
| name = "_condtemp_"; |
| goto print_remap; |
| case OMP_CLAUSE__SCANTEMP_: |
| name = "_scantemp_"; |
| goto print_remap; |
| case OMP_CLAUSE_TO_DECLARE: |
| name = "to"; |
| goto print_remap; |
| case OMP_CLAUSE_LINK: |
| name = "link"; |
| goto print_remap; |
| case OMP_CLAUSE_NONTEMPORAL: |
| name = "nontemporal"; |
| goto print_remap; |
| print_remap: |
| pp_string (pp, name); |
| pp_left_paren (pp); |
| if (modifier) |
| pp_string (pp, modifier); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_TASK_REDUCTION: |
| case OMP_CLAUSE_IN_REDUCTION: |
| pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION |
| ? "in_" : "task_"); |
| /* FALLTHRU */ |
| case OMP_CLAUSE_REDUCTION: |
| pp_string (pp, "reduction("); |
| if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION) |
| { |
| if (OMP_CLAUSE_REDUCTION_TASK (clause)) |
| pp_string (pp, "task,"); |
| else if (OMP_CLAUSE_REDUCTION_INSCAN (clause)) |
| pp_string (pp, "inscan,"); |
| } |
| if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK) |
| { |
| pp_string (pp, |
| op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); |
| pp_colon (pp); |
| } |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_IF: |
| pp_string (pp, "if("); |
| switch (OMP_CLAUSE_IF_MODIFIER (clause)) |
| { |
| case ERROR_MARK: break; |
| case VOID_CST: pp_string (pp, "cancel:"); break; |
| case OMP_PARALLEL: pp_string (pp, "parallel:"); break; |
| case OMP_SIMD: pp_string (pp, "simd:"); break; |
| case OMP_TASK: pp_string (pp, "task:"); break; |
| case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break; |
| case OMP_TARGET_DATA: pp_string (pp, "target data:"); break; |
| case OMP_TARGET: pp_string (pp, "target:"); break; |
| case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break; |
| case OMP_TARGET_ENTER_DATA: |
| pp_string (pp, "target enter data:"); break; |
| case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:"); break; |
| default: gcc_unreachable (); |
| } |
| dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_NUM_THREADS: |
| pp_string (pp, "num_threads("); |
| dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_NOWAIT: |
| pp_string (pp, "nowait"); |
| break; |
| case OMP_CLAUSE_ORDERED: |
| pp_string (pp, "ordered"); |
| if (OMP_CLAUSE_ORDERED_EXPR (clause)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| } |
| break; |
| |
| case OMP_CLAUSE_DEFAULT: |
| pp_string (pp, "default("); |
| switch (OMP_CLAUSE_DEFAULT_KIND (clause)) |
| { |
| case OMP_CLAUSE_DEFAULT_UNSPECIFIED: |
| break; |
| case OMP_CLAUSE_DEFAULT_SHARED: |
| pp_string (pp, "shared"); |
| break; |
| case OMP_CLAUSE_DEFAULT_NONE: |
| pp_string (pp, "none"); |
| break; |
| case OMP_CLAUSE_DEFAULT_PRIVATE: |
| pp_string (pp, "private"); |
| break; |
| case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE: |
| pp_string (pp, "firstprivate"); |
| break; |
| case OMP_CLAUSE_DEFAULT_PRESENT: |
| pp_string (pp, "present"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_SCHEDULE: |
| pp_string (pp, "schedule("); |
| if (OMP_CLAUSE_SCHEDULE_KIND (clause) |
| & (OMP_CLAUSE_SCHEDULE_MONOTONIC |
| | OMP_CLAUSE_SCHEDULE_NONMONOTONIC)) |
| { |
| if (OMP_CLAUSE_SCHEDULE_KIND (clause) |
| & OMP_CLAUSE_SCHEDULE_MONOTONIC) |
| pp_string (pp, "monotonic"); |
| else |
| pp_string (pp, "nonmonotonic"); |
| if (OMP_CLAUSE_SCHEDULE_SIMD (clause)) |
| pp_comma (pp); |
| else |
| pp_colon (pp); |
| } |
| if (OMP_CLAUSE_SCHEDULE_SIMD (clause)) |
| pp_string (pp, "simd:"); |
| |
| switch (OMP_CLAUSE_SCHEDULE_KIND (clause) & OMP_CLAUSE_SCHEDULE_MASK) |
| { |
| case OMP_CLAUSE_SCHEDULE_STATIC: |
| pp_string (pp, "static"); |
| break; |
| case OMP_CLAUSE_SCHEDULE_DYNAMIC: |
| pp_string (pp, "dynamic"); |
| break; |
| case OMP_CLAUSE_SCHEDULE_GUIDED: |
| pp_string (pp, "guided"); |
| break; |
| case OMP_CLAUSE_SCHEDULE_RUNTIME: |
| pp_string (pp, "runtime"); |
| break; |
| case OMP_CLAUSE_SCHEDULE_AUTO: |
| pp_string (pp, "auto"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) |
| { |
| pp_comma (pp); |
| dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause), |
| spc, flags, false); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_UNTIED: |
| pp_string (pp, "untied"); |
| break; |
| |
| case OMP_CLAUSE_COLLAPSE: |
| pp_string (pp, "collapse("); |
| dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_FINAL: |
| pp_string (pp, "final("); |
| dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_MERGEABLE: |
| pp_string (pp, "mergeable"); |
| break; |
| |
| case OMP_CLAUSE_LINEAR: |
| pp_string (pp, "linear("); |
| switch (OMP_CLAUSE_LINEAR_KIND (clause)) |
| { |
| case OMP_CLAUSE_LINEAR_DEFAULT: |
| break; |
| case OMP_CLAUSE_LINEAR_REF: |
| pp_string (pp, "ref("); |
| break; |
| case OMP_CLAUSE_LINEAR_VAL: |
| pp_string (pp, "val("); |
| break; |
| case OMP_CLAUSE_LINEAR_UVAL: |
| pp_string (pp, "uval("); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| if (OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT) |
| pp_right_paren (pp); |
| pp_colon (pp); |
| dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_ALIGNED: |
| pp_string (pp, "aligned("); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause)) |
| { |
| pp_colon (pp); |
| dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), |
| spc, flags, false); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_DEPEND: |
| pp_string (pp, "depend("); |
| switch (OMP_CLAUSE_DEPEND_KIND (clause)) |
| { |
| case OMP_CLAUSE_DEPEND_DEPOBJ: |
| name = "depobj"; |
| break; |
| case OMP_CLAUSE_DEPEND_IN: |
| name = "in"; |
| break; |
| case OMP_CLAUSE_DEPEND_OUT: |
| name = "out"; |
| break; |
| case OMP_CLAUSE_DEPEND_INOUT: |
| name = "inout"; |
| break; |
| case OMP_CLAUSE_DEPEND_MUTEXINOUTSET: |
| name = "mutexinoutset"; |
| break; |
| case OMP_CLAUSE_DEPEND_SOURCE: |
| pp_string (pp, "source)"); |
| return; |
| case OMP_CLAUSE_DEPEND_LAST: |
| name = "__internal__"; |
| break; |
| case OMP_CLAUSE_DEPEND_SINK: |
| pp_string (pp, "sink:"); |
| for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t)) |
| if (TREE_CODE (t) == TREE_LIST) |
| { |
| dump_generic_node (pp, TREE_VALUE (t), spc, flags, false); |
| if (TREE_PURPOSE (t) != integer_zero_node) |
| { |
| if (OMP_CLAUSE_DEPEND_SINK_NEGATIVE (t)) |
| pp_minus (pp); |
| else |
| pp_plus (pp); |
| dump_generic_node (pp, TREE_PURPOSE (t), spc, flags, |
| false); |
| } |
| if (TREE_CHAIN (t)) |
| pp_comma (pp); |
| } |
| else |
| gcc_unreachable (); |
| pp_right_paren (pp); |
| return; |
| default: |
| gcc_unreachable (); |
| } |
| { |
| tree t = OMP_CLAUSE_DECL (clause); |
| if (TREE_CODE (t) == TREE_LIST |
| && TREE_PURPOSE (t) |
| && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC) |
| { |
| dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags); |
| pp_colon (pp); |
| t = TREE_VALUE (t); |
| } |
| pp_string (pp, name); |
| pp_colon (pp); |
| dump_generic_node (pp, t, spc, flags, false); |
| pp_right_paren (pp); |
| } |
| break; |
| |
| case OMP_CLAUSE_MAP: |
| pp_string (pp, "map("); |
| switch (OMP_CLAUSE_MAP_KIND (clause)) |
| { |
| case GOMP_MAP_ALLOC: |
| case GOMP_MAP_POINTER: |
| pp_string (pp, "alloc"); |
| break; |
| case GOMP_MAP_IF_PRESENT: |
| pp_string (pp, "no_alloc"); |
| break; |
| case GOMP_MAP_TO: |
| case GOMP_MAP_TO_PSET: |
| pp_string (pp, "to"); |
| break; |
| case GOMP_MAP_FROM: |
| pp_string (pp, "from"); |
| break; |
| case GOMP_MAP_TOFROM: |
| pp_string (pp, "tofrom"); |
| break; |
| case GOMP_MAP_FORCE_ALLOC: |
| pp_string (pp, "force_alloc"); |
| break; |
| case GOMP_MAP_FORCE_TO: |
| pp_string (pp, "force_to"); |
| break; |
| case GOMP_MAP_FORCE_FROM: |
| pp_string (pp, "force_from"); |
| break; |
| case GOMP_MAP_FORCE_TOFROM: |
| pp_string (pp, "force_tofrom"); |
| break; |
| case GOMP_MAP_FORCE_PRESENT: |
| pp_string (pp, "force_present"); |
| break; |
| case GOMP_MAP_DELETE: |
| pp_string (pp, "delete"); |
| break; |
| case GOMP_MAP_FORCE_DEVICEPTR: |
| pp_string (pp, "force_deviceptr"); |
| break; |
| case GOMP_MAP_ALWAYS_TO: |
| pp_string (pp, "always,to"); |
| break; |
| case GOMP_MAP_ALWAYS_FROM: |
| pp_string (pp, "always,from"); |
| break; |
| case GOMP_MAP_ALWAYS_TOFROM: |
| pp_string (pp, "always,tofrom"); |
| break; |
| case GOMP_MAP_RELEASE: |
| pp_string (pp, "release"); |
| break; |
| case GOMP_MAP_FIRSTPRIVATE_POINTER: |
| pp_string (pp, "firstprivate"); |
| break; |
| case GOMP_MAP_FIRSTPRIVATE_REFERENCE: |
| pp_string (pp, "firstprivate ref"); |
| break; |
| case GOMP_MAP_STRUCT: |
| pp_string (pp, "struct"); |
| break; |
| case GOMP_MAP_ALWAYS_POINTER: |
| pp_string (pp, "always_pointer"); |
| break; |
| case GOMP_MAP_DEVICE_RESIDENT: |
| pp_string (pp, "device_resident"); |
| break; |
| case GOMP_MAP_LINK: |
| pp_string (pp, "link"); |
| break; |
| case GOMP_MAP_ATTACH: |
| pp_string (pp, "attach"); |
| break; |
| case GOMP_MAP_DETACH: |
| pp_string (pp, "detach"); |
| break; |
| case GOMP_MAP_FORCE_DETACH: |
| pp_string (pp, "force_detach"); |
| break; |
| case GOMP_MAP_ATTACH_DETACH: |
| pp_string (pp, "attach_detach"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_colon (pp); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| print_clause_size: |
| if (OMP_CLAUSE_SIZE (clause)) |
| { |
| switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP |
| ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO) |
| { |
| case GOMP_MAP_POINTER: |
| case GOMP_MAP_FIRSTPRIVATE_POINTER: |
| case GOMP_MAP_FIRSTPRIVATE_REFERENCE: |
| case GOMP_MAP_ALWAYS_POINTER: |
| pp_string (pp, " [pointer assign, bias: "); |
| break; |
| case GOMP_MAP_TO_PSET: |
| pp_string (pp, " [pointer set, len: "); |
| break; |
| case GOMP_MAP_ATTACH: |
| case GOMP_MAP_DETACH: |
| case GOMP_MAP_FORCE_DETACH: |
| case GOMP_MAP_ATTACH_DETACH: |
| pp_string (pp, " [bias: "); |
| break; |
| default: |
| pp_string (pp, " [len: "); |
| break; |
| } |
| dump_generic_node (pp, OMP_CLAUSE_SIZE (clause), |
| spc, flags, false); |
| pp_right_bracket (pp); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_FROM: |
| pp_string (pp, "from("); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| goto print_clause_size; |
| |
| case OMP_CLAUSE_TO: |
| pp_string (pp, "to("); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| goto print_clause_size; |
| |
| case OMP_CLAUSE__CACHE_: |
| pp_string (pp, "("); |
| dump_generic_node (pp, OMP_CLAUSE_DECL (clause), |
| spc, flags, false); |
| goto print_clause_size; |
| |
| case OMP_CLAUSE_NUM_TEAMS: |
| pp_string (pp, "num_teams("); |
| dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_THREAD_LIMIT: |
| pp_string (pp, "thread_limit("); |
| dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_DEVICE: |
| pp_string (pp, "device("); |
| dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_DIST_SCHEDULE: |
| pp_string (pp, "dist_schedule(static"); |
| if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause)) |
| { |
| pp_comma (pp); |
| dump_generic_node (pp, |
| OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause), |
| spc, flags, false); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_PROC_BIND: |
| pp_string (pp, "proc_bind("); |
| switch (OMP_CLAUSE_PROC_BIND_KIND (clause)) |
| { |
| case OMP_CLAUSE_PROC_BIND_MASTER: |
| pp_string (pp, "master"); |
| break; |
| case OMP_CLAUSE_PROC_BIND_CLOSE: |
| pp_string (pp, "close"); |
| break; |
| case OMP_CLAUSE_PROC_BIND_SPREAD: |
| pp_string (pp, "spread"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_DEVICE_TYPE: |
| pp_string (pp, "device_type("); |
| switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause)) |
| { |
| case OMP_CLAUSE_DEVICE_TYPE_HOST: |
| pp_string (pp, "host"); |
| break; |
| case OMP_CLAUSE_DEVICE_TYPE_NOHOST: |
| pp_string (pp, "nohost"); |
| break; |
| case OMP_CLAUSE_DEVICE_TYPE_ANY: |
| pp_string (pp, "any"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_SAFELEN: |
| pp_string (pp, "safelen("); |
| dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_SIMDLEN: |
| pp_string (pp, "simdlen("); |
| dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_PRIORITY: |
| pp_string (pp, "priority("); |
| dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_GRAINSIZE: |
| pp_string (pp, "grainsize("); |
| dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_NUM_TASKS: |
| pp_string (pp, "num_tasks("); |
| dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_HINT: |
| pp_string (pp, "hint("); |
| dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_DEFAULTMAP: |
| pp_string (pp, "defaultmap("); |
| switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause)) |
| { |
| case OMP_CLAUSE_DEFAULTMAP_ALLOC: |
| pp_string (pp, "alloc"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_TO: |
| pp_string (pp, "to"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_FROM: |
| pp_string (pp, "from"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_TOFROM: |
| pp_string (pp, "tofrom"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE: |
| pp_string (pp, "firstprivate"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_NONE: |
| pp_string (pp, "none"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_DEFAULT: |
| pp_string (pp, "default"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause)) |
| { |
| case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED: |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR: |
| pp_string (pp, ":scalar"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE: |
| pp_string (pp, ":aggregate"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE: |
| pp_string (pp, ":allocatable"); |
| break; |
| case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER: |
| pp_string (pp, ":pointer"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_ORDER: |
| pp_string (pp, "order(concurrent)"); |
| break; |
| |
| case OMP_CLAUSE_BIND: |
| pp_string (pp, "bind("); |
| switch (OMP_CLAUSE_BIND_KIND (clause)) |
| { |
| case OMP_CLAUSE_BIND_TEAMS: |
| pp_string (pp, "teams"); |
| break; |
| case OMP_CLAUSE_BIND_PARALLEL: |
| pp_string (pp, "parallel"); |
| break; |
| case OMP_CLAUSE_BIND_THREAD: |
| pp_string (pp, "thread"); |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE__SIMDUID_: |
| pp_string (pp, "_simduid_("); |
| dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE__SIMT_: |
| pp_string (pp, "_simt_"); |
| break; |
| |
| case OMP_CLAUSE_GANG: |
| pp_string (pp, "gang"); |
| if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE) |
| { |
| pp_string (pp, "(num: "); |
| dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause), |
| spc, flags, false); |
| } |
| if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE) |
| { |
| if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE) |
| pp_left_paren (pp); |
| else |
| pp_space (pp); |
| pp_string (pp, "static:"); |
| if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) |
| == integer_minus_one_node) |
| pp_character (pp, '*'); |
| else |
| dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause), |
| spc, flags, false); |
| } |
| if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE |
| || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE) |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE_ASYNC: |
| pp_string (pp, "async"); |
| if (OMP_CLAUSE_ASYNC_EXPR (clause)) |
| { |
| pp_character(pp, '('); |
| dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause), |
| spc, flags, false); |
| pp_character(pp, ')'); |
| } |
| break; |
| |
| case OMP_CLAUSE_AUTO: |
| case OMP_CLAUSE_SEQ: |
| pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]); |
| break; |
| |
| case OMP_CLAUSE_WAIT: |
| pp_string (pp, "wait("); |
| dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause), |
| spc, flags, false); |
| pp_character(pp, ')'); |
| break; |
| |
| case OMP_CLAUSE_WORKER: |
| pp_string (pp, "worker"); |
| if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| } |
| break; |
| |
| case OMP_CLAUSE_VECTOR: |
| pp_string (pp, "vector"); |
| if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| } |
| break; |
| |
| case OMP_CLAUSE_NUM_GANGS: |
| pp_string (pp, "num_gangs("); |
| dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause), |
| spc, flags, false); |
| pp_character (pp, ')'); |
| break; |
| |
| case OMP_CLAUSE_NUM_WORKERS: |
| pp_string (pp, "num_workers("); |
| dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause), |
| spc, flags, false); |
| pp_character (pp, ')'); |
| break; |
| |
| case OMP_CLAUSE_VECTOR_LENGTH: |
| pp_string (pp, "vector_length("); |
| dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause), |
| spc, flags, false); |
| pp_character (pp, ')'); |
| break; |
| |
| case OMP_CLAUSE_INBRANCH: |
| pp_string (pp, "inbranch"); |
| break; |
| case OMP_CLAUSE_NOTINBRANCH: |
| pp_string (pp, "notinbranch"); |
| break; |
| case OMP_CLAUSE_FOR: |
| pp_string (pp, "for"); |
| break; |
| case OMP_CLAUSE_PARALLEL: |
| pp_string (pp, "parallel"); |
| break; |
| case OMP_CLAUSE_SECTIONS: |
| pp_string (pp, "sections"); |
| break; |
| case OMP_CLAUSE_TASKGROUP: |
| pp_string (pp, "taskgroup"); |
| break; |
| case OMP_CLAUSE_NOGROUP: |
| pp_string (pp, "nogroup"); |
| break; |
| case OMP_CLAUSE_THREADS: |
| pp_string (pp, "threads"); |
| break; |
| case OMP_CLAUSE_SIMD: |
| pp_string (pp, "simd"); |
| break; |
| case OMP_CLAUSE_INDEPENDENT: |
| pp_string (pp, "independent"); |
| break; |
| case OMP_CLAUSE_TILE: |
| pp_string (pp, "tile("); |
| dump_generic_node (pp, OMP_CLAUSE_TILE_LIST (clause), |
| spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case OMP_CLAUSE__GRIDDIM_: |
| pp_string (pp, "_griddim_("); |
| pp_unsigned_wide_integer (pp, OMP_CLAUSE__GRIDDIM__DIMENSION (clause)); |
| pp_colon (pp); |
| dump_generic_node (pp, OMP_CLAUSE__GRIDDIM__SIZE (clause), spc, flags, |
| false); |
| pp_comma (pp); |
| dump_generic_node (pp, OMP_CLAUSE__GRIDDIM__GROUP (clause), spc, flags, |
| false); |
| pp_right_paren (pp); |
| break; |
| case OMP_CLAUSE_IF_PRESENT: |
| pp_string (pp, "if_present"); |
| break; |
| case OMP_CLAUSE_FINALIZE: |
| pp_string (pp, "finalize"); |
| break; |
| |
| default: |
| gcc_unreachable (); |
| } |
| } |
| |
| |
| /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in |
| dump_generic_node. */ |
| |
| void |
| dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags) |
| { |
| if (clause == NULL) |
| return; |
| |
| pp_space (pp); |
| while (1) |
| { |
| dump_omp_clause (pp, clause, spc, flags); |
| clause = OMP_CLAUSE_CHAIN (clause); |
| if (clause == NULL) |
| return; |
| pp_space (pp); |
| } |
| } |
| |
| |
| /* Dump location LOC to PP. */ |
| |
| void |
| dump_location (pretty_printer *pp, location_t loc) |
| { |
| expanded_location xloc = expand_location (loc); |
| |
| pp_left_bracket (pp); |
| if (xloc.file) |
| { |
| pp_string (pp, xloc.file); |
| pp_string (pp, ":"); |
| } |
| pp_decimal_int (pp, xloc.line); |
| pp_colon (pp); |
| pp_decimal_int (pp, xloc.column); |
| pp_string (pp, "] "); |
| } |
| |
| |
| /* Dump lexical block BLOCK. PP, SPC and FLAGS are as in |
| dump_generic_node. */ |
| |
| static void |
| dump_block_node (pretty_printer *pp, tree block, int spc, dump_flags_t flags) |
| { |
| tree t; |
| |
| pp_printf (pp, "BLOCK #%d ", BLOCK_NUMBER (block)); |
| |
| if (flags & TDF_ADDRESS) |
| pp_printf (pp, "[%p] ", (void *) block); |
| |
| if (TREE_ASM_WRITTEN (block)) |
| pp_string (pp, "[written] "); |
| |
| if (flags & TDF_SLIM) |
| return; |
| |
| if (BLOCK_SOURCE_LOCATION (block)) |
| dump_location (pp, BLOCK_SOURCE_LOCATION (block)); |
| |
| newline_and_indent (pp, spc + 2); |
| |
| if (BLOCK_SUPERCONTEXT (block)) |
| { |
| pp_string (pp, "SUPERCONTEXT: "); |
| dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0, |
| flags | TDF_SLIM, false); |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_SUBBLOCKS (block)) |
| { |
| pp_string (pp, "SUBBLOCKS: "); |
| for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) |
| { |
| dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
| pp_space (pp); |
| } |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_CHAIN (block)) |
| { |
| pp_string (pp, "SIBLINGS: "); |
| for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t)) |
| { |
| dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
| pp_space (pp); |
| } |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_VARS (block)) |
| { |
| pp_string (pp, "VARS: "); |
| for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) |
| { |
| dump_generic_node (pp, t, 0, flags, false); |
| pp_space (pp); |
| } |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0) |
| { |
| unsigned i; |
| vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block); |
| |
| pp_string (pp, "NONLOCALIZED_VARS: "); |
| FOR_EACH_VEC_ELT (*nlv, i, t) |
| { |
| dump_generic_node (pp, t, 0, flags, false); |
| pp_space (pp); |
| } |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_ABSTRACT_ORIGIN (block)) |
| { |
| pp_string (pp, "ABSTRACT_ORIGIN: "); |
| dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0, |
| flags | TDF_SLIM, false); |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_FRAGMENT_ORIGIN (block)) |
| { |
| pp_string (pp, "FRAGMENT_ORIGIN: "); |
| dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0, |
| flags | TDF_SLIM, false); |
| newline_and_indent (pp, spc + 2); |
| } |
| |
| if (BLOCK_FRAGMENT_CHAIN (block)) |
| { |
| pp_string (pp, "FRAGMENT_CHAIN: "); |
| for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t)) |
| { |
| dump_generic_node (pp, t, 0, flags | TDF_SLIM, false); |
| pp_space (pp); |
| } |
| newline_and_indent (pp, spc + 2); |
| } |
| } |
| |
| /* Dump #pragma omp atomic memory order clause. */ |
| |
| void |
| dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo) |
| { |
| switch (mo) |
| { |
| case OMP_MEMORY_ORDER_RELAXED: |
| pp_string (pp, " relaxed"); |
| break; |
| case OMP_MEMORY_ORDER_SEQ_CST: |
| pp_string (pp, " seq_cst"); |
| break; |
| case OMP_MEMORY_ORDER_ACQ_REL: |
| pp_string (pp, " acq_rel"); |
| break; |
| case OMP_MEMORY_ORDER_ACQUIRE: |
| pp_string (pp, " acquire"); |
| break; |
| case OMP_MEMORY_ORDER_RELEASE: |
| pp_string (pp, " release"); |
| break; |
| case OMP_MEMORY_ORDER_UNSPECIFIED: |
| break; |
| default: |
| gcc_unreachable (); |
| } |
| } |
| |
| /* Helper to dump a MEM_REF node. */ |
| |
| static void |
| dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags) |
| { |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "__MEM <"); |
| dump_generic_node (pp, TREE_TYPE (node), |
| spc, flags | TDF_SLIM, false); |
| if (TYPE_ALIGN (TREE_TYPE (node)) |
| != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node)))) |
| { |
| pp_string (pp, ", "); |
| pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node))); |
| } |
| pp_greater (pp); |
| pp_string (pp, " ("); |
| if (TREE_TYPE (TREE_OPERAND (node, 0)) |
| != TREE_TYPE (TREE_OPERAND (node, 1))) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)), |
| spc, flags | TDF_SLIM, false); |
| pp_right_paren (pp); |
| } |
| dump_generic_node (pp, TREE_OPERAND (node, 0), |
| spc, flags | TDF_SLIM, false); |
| if (! integer_zerop (TREE_OPERAND (node, 1))) |
| { |
| pp_string (pp, " + "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), |
| spc, flags | TDF_SLIM, false); |
| } |
| pp_right_paren (pp); |
| } |
| else if (integer_zerop (TREE_OPERAND (node, 1)) |
| /* Dump the types of INTEGER_CSTs explicitly, for we can't |
| infer them and MEM_ATTR caching will share MEM_REFs |
| with differently-typed op0s. */ |
| && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST |
| /* Released SSA_NAMES have no TREE_TYPE. */ |
| && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE |
| /* Same pointer types, but ignoring POINTER_TYPE vs. |
| REFERENCE_TYPE. */ |
| && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0))) |
| == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
| && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0))) |
| == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
| && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0))) |
| == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1)))) |
| /* Same value types ignoring qualifiers. */ |
| && (TYPE_MAIN_VARIANT (TREE_TYPE (node)) |
| == TYPE_MAIN_VARIANT |
| (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))) |
| && (!(flags & TDF_ALIAS) |
| || MR_DEPENDENCE_CLIQUE (node) == 0)) |
| { |
| if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR) |
| { |
| /* Enclose pointers to arrays in parentheses. */ |
| tree op0 = TREE_OPERAND (node, 0); |
| tree op0type = TREE_TYPE (op0); |
| if (POINTER_TYPE_P (op0type) |
| && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE) |
| pp_left_paren (pp); |
| pp_star (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| if (POINTER_TYPE_P (op0type) |
| && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE) |
| pp_right_paren (pp); |
| } |
| else |
| dump_generic_node (pp, |
| TREE_OPERAND (TREE_OPERAND (node, 0), 0), |
| spc, flags, false); |
| } |
| else |
| { |
| pp_string (pp, "MEM"); |
| |
| tree nodetype = TREE_TYPE (node); |
| tree op0 = TREE_OPERAND (node, 0); |
| tree op1 = TREE_OPERAND (node, 1); |
| tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1)); |
| |
| tree op0size = TYPE_SIZE (nodetype); |
| tree op1size = TYPE_SIZE (TREE_TYPE (op1type)); |
| |
| if (!op0size || !op1size |
| || !operand_equal_p (op0size, op1size, 0)) |
| { |
| pp_string (pp, " <"); |
| /* If the size of the type of the operand is not the same |
| as the size of the MEM_REF expression include the type |
| of the latter similar to the TDF_GIMPLE output to make |
| it clear how many bytes of memory are being accessed. */ |
| dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false); |
| pp_string (pp, "> "); |
| } |
| |
| pp_string (pp, "[("); |
| dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false); |
| pp_right_paren (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| if (!integer_zerop (op1)) |
| if (!integer_zerop (TREE_OPERAND (node, 1))) |
| { |
| pp_string (pp, " + "); |
| dump_generic_node (pp, op1, spc, flags, false); |
| } |
| if ((flags & TDF_ALIAS) |
| && MR_DEPENDENCE_CLIQUE (node) != 0) |
| { |
| pp_string (pp, " clique "); |
| pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node)); |
| pp_string (pp, " base "); |
| pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node)); |
| } |
| pp_right_bracket (pp); |
| } |
| } |
| |
| /* Dump the node NODE on the pretty_printer PP, SPC spaces of |
| indent. FLAGS specifies details to show in the dump (see TDF_* in |
| dumpfile.h). If IS_STMT is true, the object printed is considered |
| to be a statement and it is terminated by ';' if appropriate. */ |
| |
| int |
| dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags, |
| bool is_stmt) |
| { |
| tree type; |
| tree op0, op1; |
| const char *str; |
| bool is_expr; |
| enum tree_code code; |
| |
| if (node == NULL_TREE) |
| return spc; |
| |
| is_expr = EXPR_P (node); |
| |
| if (is_stmt && (flags & TDF_STMTADDR)) |
| pp_printf (pp, "<&%p> ", (void *)node); |
| |
| if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) |
| dump_location (pp, EXPR_LOCATION (node)); |
| |
| code = TREE_CODE (node); |
| switch (code) |
| { |
| case ERROR_MARK: |
| pp_string (pp, "<<< error >>>"); |
| break; |
| |
| case IDENTIFIER_NODE: |
| pp_tree_identifier (pp, node); |
| break; |
| |
| case TREE_LIST: |
| while (node && node != error_mark_node) |
| { |
| if (TREE_PURPOSE (node)) |
| { |
| dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false); |
| pp_space (pp); |
| } |
| dump_generic_node (pp, TREE_VALUE (node), spc, flags, false); |
| node = TREE_CHAIN (node); |
| if (node && TREE_CODE (node) == TREE_LIST) |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| } |
| break; |
| |
| case TREE_BINFO: |
| dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false); |
| break; |
| |
| case TREE_VEC: |
| { |
| size_t i; |
| if (TREE_VEC_LENGTH (node) > 0) |
| { |
| size_t len = TREE_VEC_LENGTH (node); |
| for (i = 0; i < len - 1; i++) |
| { |
| dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags, |
| false); |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc, |
| flags, false); |
| } |
| } |
| break; |
| |
| case VOID_TYPE: |
| case INTEGER_TYPE: |
| case REAL_TYPE: |
| case FIXED_POINT_TYPE: |
| case COMPLEX_TYPE: |
| case VECTOR_TYPE: |
| case ENUMERAL_TYPE: |
| case BOOLEAN_TYPE: |
| { |
| unsigned int quals = TYPE_QUALS (node); |
| enum tree_code_class tclass; |
| |
| if (quals & TYPE_QUAL_ATOMIC) |
| pp_string (pp, "atomic "); |
| if (quals & TYPE_QUAL_CONST) |
| pp_string (pp, "const "); |
| else if (quals & TYPE_QUAL_VOLATILE) |
| pp_string (pp, "volatile "); |
| else if (quals & TYPE_QUAL_RESTRICT) |
| pp_string (pp, "restrict "); |
| |
| if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
| { |
| pp_string (pp, "<address-space-"); |
| pp_decimal_int (pp, TYPE_ADDR_SPACE (node)); |
| pp_string (pp, "> "); |
| } |
| |
| tclass = TREE_CODE_CLASS (TREE_CODE (node)); |
| |
| if (tclass == tcc_declaration) |
| { |
| if (DECL_NAME (node)) |
| dump_decl_name (pp, node, flags); |
| else |
| pp_string (pp, "<unnamed type decl>"); |
| } |
| else if (tclass == tcc_type) |
| { |
| if (TYPE_NAME (node)) |
| { |
| if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) |
| pp_tree_identifier (pp, TYPE_NAME (node)); |
| else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL |
| && DECL_NAME (TYPE_NAME (node))) |
| dump_decl_name (pp, TYPE_NAME (node), flags); |
| else |
| pp_string (pp, "<unnamed type>"); |
| } |
| else if (TREE_CODE (node) == VECTOR_TYPE) |
| { |
| pp_string (pp, "vector"); |
| pp_left_paren (pp); |
| pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node)); |
| pp_string (pp, ") "); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| } |
| else if (TREE_CODE (node) == INTEGER_TYPE) |
| { |
| if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE) |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "unsigned char" |
| : "signed char")); |
| else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE) |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "unsigned short" |
| : "signed short")); |
| else if (TYPE_PRECISION (node) == INT_TYPE_SIZE) |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "unsigned int" |
| : "signed int")); |
| else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE) |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "unsigned long" |
| : "signed long")); |
| else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE) |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "unsigned long long" |
| : "signed long long")); |
| else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE |
| && pow2p_hwi (TYPE_PRECISION (node))) |
| { |
| pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int")); |
| pp_decimal_int (pp, TYPE_PRECISION (node)); |
| pp_string (pp, "_t"); |
| } |
| else |
| { |
| pp_string (pp, (TYPE_UNSIGNED (node) |
| ? "<unnamed-unsigned:" |
| : "<unnamed-signed:")); |
| pp_decimal_int (pp, TYPE_PRECISION (node)); |
| pp_greater (pp); |
| } |
| } |
| else if (TREE_CODE (node) == COMPLEX_TYPE) |
| { |
| pp_string (pp, "__complex__ "); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| } |
| else if (TREE_CODE (node) == REAL_TYPE) |
| { |
| pp_string (pp, "<float:"); |
| pp_decimal_int (pp, TYPE_PRECISION (node)); |
| pp_greater (pp); |
| } |
| else if (TREE_CODE (node) == FIXED_POINT_TYPE) |
| { |
| pp_string (pp, "<fixed-point-"); |
| pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:"); |
| pp_decimal_int (pp, TYPE_PRECISION (node)); |
| pp_greater (pp); |
| } |
| else if (TREE_CODE (node) == VOID_TYPE) |
| pp_string (pp, "void"); |
| else |
| pp_string (pp, "<unnamed type>"); |
| } |
| break; |
| } |
| |
| case POINTER_TYPE: |
| case REFERENCE_TYPE: |
| str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&"); |
| |
| if (TREE_TYPE (node) == NULL) |
| { |
| pp_string (pp, str); |
| pp_string (pp, "<null type>"); |
| } |
| else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) |
| { |
| tree fnode = TREE_TYPE (node); |
| |
| dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false); |
| pp_space (pp); |
| pp_left_paren (pp); |
| pp_string (pp, str); |
| if (TYPE_IDENTIFIER (node)) |
| dump_generic_node (pp, TYPE_NAME (node), spc, flags, false); |
| else if (flags & TDF_NOUID) |
| pp_printf (pp, "<Txxxx>"); |
| else |
| pp_printf (pp, "<T%x>", TYPE_UID (node)); |
| |
| pp_right_paren (pp); |
| dump_function_declaration (pp, fnode, spc, flags); |
| } |
| else |
| { |
| unsigned int quals = TYPE_QUALS (node); |
| |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_space (pp); |
| pp_string (pp, str); |
| |
| if (quals & TYPE_QUAL_CONST) |
| pp_string (pp, " const"); |
| if (quals & TYPE_QUAL_VOLATILE) |
| pp_string (pp, " volatile"); |
| if (quals & TYPE_QUAL_RESTRICT) |
| pp_string (pp, " restrict"); |
| |
| if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
| { |
| pp_string (pp, " <address-space-"); |
| pp_decimal_int (pp, TYPE_ADDR_SPACE (node)); |
| pp_greater (pp); |
| } |
| |
| if (TYPE_REF_CAN_ALIAS_ALL (node)) |
| pp_string (pp, " {ref-all}"); |
| } |
| break; |
| |
| case OFFSET_TYPE: |
| NIY; |
| break; |
| |
| case MEM_REF: |
| dump_mem_ref (pp, node, spc, flags); |
| break; |
| |
| case TARGET_MEM_REF: |
| { |
| const char *sep = ""; |
| tree tmp; |
| |
| pp_string (pp, "MEM["); |
| |
| if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR) |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "symbol: "); |
| dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0), |
| spc, flags, false); |
| } |
| else |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "base: "); |
| dump_generic_node (pp, TMR_BASE (node), spc, flags, false); |
| } |
| tmp = TMR_INDEX2 (node); |
| if (tmp) |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "base: "); |
| dump_generic_node (pp, tmp, spc, flags, false); |
| } |
| tmp = TMR_INDEX (node); |
| if (tmp) |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "index: "); |
| dump_generic_node (pp, tmp, spc, flags, false); |
| } |
| tmp = TMR_STEP (node); |
| if (tmp) |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "step: "); |
| dump_generic_node (pp, tmp, spc, flags, false); |
| } |
| tmp = TMR_OFFSET (node); |
| if (tmp) |
| { |
| pp_string (pp, sep); |
| sep = ", "; |
| pp_string (pp, "offset: "); |
| dump_generic_node (pp, tmp, spc, flags, false); |
| } |
| pp_right_bracket (pp); |
| } |
| break; |
| |
| case ARRAY_TYPE: |
| { |
| tree tmp; |
| |
| /* Print the innermost component type. */ |
| for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE; |
| tmp = TREE_TYPE (tmp)) |
| ; |
| dump_generic_node (pp, tmp, spc, flags, false); |
| |
| /* Print the dimensions. */ |
| for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp)) |
| dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags); |
| break; |
| } |
| |
| case RECORD_TYPE: |
| case UNION_TYPE: |
| case QUAL_UNION_TYPE: |
| { |
| unsigned int quals = TYPE_QUALS (node); |
| |
| if (quals & TYPE_QUAL_ATOMIC) |
| pp_string (pp, "atomic "); |
| if (quals & TYPE_QUAL_CONST) |
| pp_string (pp, "const "); |
| if (quals & TYPE_QUAL_VOLATILE) |
| pp_string (pp, "volatile "); |
| |
| /* Print the name of the structure. */ |
| if (TREE_CODE (node) == RECORD_TYPE) |
| pp_string (pp, "struct "); |
| else if (TREE_CODE (node) == UNION_TYPE) |
| pp_string (pp, "union "); |
| |
| if (TYPE_NAME (node)) |
| dump_generic_node (pp, TYPE_NAME (node), spc, flags, false); |
| else if (!(flags & TDF_SLIM)) |
| /* FIXME: If we eliminate the 'else' above and attempt |
| to show the fields for named types, we may get stuck |
| following a cycle of pointers to structs. The alleged |
| self-reference check in print_struct_decl will not detect |
| cycles involving more than one pointer or struct type. */ |
| print_struct_decl (pp, node, spc, flags); |
| break; |
| } |
| |
| case LANG_TYPE: |
| NIY; |
| break; |
| |
| case INTEGER_CST: |
| if (flags & TDF_GIMPLE |
| && (POINTER_TYPE_P (TREE_TYPE (node)) |
| || (TYPE_PRECISION (TREE_TYPE (node)) |
| < TYPE_PRECISION (integer_type_node)) |
| || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1 |
| || tree_int_cst_sgn (node) < 0)) |
| { |
| pp_string (pp, "_Literal ("); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_string (pp, ") "); |
| } |
| if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE |
| && ! (flags & TDF_GIMPLE)) |
| { |
| /* In the case of a pointer, one may want to divide by the |
| size of the pointed-to type. Unfortunately, this not |
| straightforward. The C front-end maps expressions |
| |
| (int *) 5 |
| int *p; (p + 5) |
| |
| in such a way that the two INTEGER_CST nodes for "5" have |
| different values but identical types. In the latter |
| case, the 5 is multiplied by sizeof (int) in c-common.c |
| (pointer_int_sum) to convert it to a byte address, and |
| yet the type of the node is left unchanged. Argh. What |
| is consistent though is that the number value corresponds |
| to bytes (UNITS) offset. |
| |
| NB: Neither of the following divisors can be trivially |
| used to recover the original literal: |
| |
| TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node))) |
| TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */ |
| pp_wide_integer (pp, TREE_INT_CST_LOW (node)); |
| pp_string (pp, "B"); /* pseudo-unit */ |
| } |
| else if (tree_fits_shwi_p (node)) |
| pp_wide_integer (pp, tree_to_shwi (node)); |
| else if (tree_fits_uhwi_p (node)) |
| pp_unsigned_wide_integer (pp, tree_to_uhwi (node)); |
| else |
| { |
| wide_int val = wi::to_wide (node); |
| |
| if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node)))) |
| { |
| pp_minus (pp); |
| val = -val; |
| } |
| print_hex (val, pp_buffer (pp)->digit_buffer); |
| pp_string (pp, pp_buffer (pp)->digit_buffer); |
| } |
| if ((flags & TDF_GIMPLE) |
| && ! (POINTER_TYPE_P (TREE_TYPE (node)) |
| || (TYPE_PRECISION (TREE_TYPE (node)) |
| < TYPE_PRECISION (integer_type_node)) |
| || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1)) |
| { |
| if (TYPE_UNSIGNED (TREE_TYPE (node))) |
| pp_character (pp, 'u'); |
| if (TYPE_PRECISION (TREE_TYPE (node)) |
| == TYPE_PRECISION (unsigned_type_node)) |
| ; |
| else if (TYPE_PRECISION (TREE_TYPE (node)) |
| == TYPE_PRECISION (long_unsigned_type_node)) |
| pp_character (pp, 'l'); |
| else if (TYPE_PRECISION (TREE_TYPE (node)) |
| == TYPE_PRECISION (long_long_unsigned_type_node)) |
| pp_string (pp, "ll"); |
| } |
| if (TREE_OVERFLOW (node)) |
| pp_string (pp, "(OVF)"); |
| break; |
| |
| case POLY_INT_CST: |
| pp_string (pp, "POLY_INT_CST ["); |
| dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false); |
| for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i) |
| { |
| pp_string (pp, ", "); |
| dump_generic_node (pp, POLY_INT_CST_COEFF (node, i), |
| spc, flags, false); |
| } |
| pp_string (pp, "]"); |
| break; |
| |
| case REAL_CST: |
| /* Code copied from print_node. */ |
| { |
| REAL_VALUE_TYPE d; |
| if (TREE_OVERFLOW (node)) |
| pp_string (pp, " overflow"); |
| |
| d = TREE_REAL_CST (node); |
| if (REAL_VALUE_ISINF (d)) |
| pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); |
| else if (REAL_VALUE_ISNAN (d)) |
| pp_string (pp, " Nan"); |
| else |
| { |
| char string[100]; |
| real_to_decimal (string, &d, sizeof (string), 0, 1); |
| pp_string (pp, string); |
| } |
| break; |
| } |
| |
| case FIXED_CST: |
| { |
| char string[100]; |
| fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string)); |
| pp_string (pp, string); |
| break; |
| } |
| |
| case COMPLEX_CST: |
| pp_string (pp, "__complex__ ("); |
| dump_generic_node (pp, TREE_REALPART (node), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case STRING_CST: |
| { |
| pp_string (pp, "\""); |
| if (unsigned nbytes = TREE_STRING_LENGTH (node)) |
| pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes); |
| pp_string (pp, "\""); |
| break; |
| } |
| |
| case VECTOR_CST: |
| { |
| unsigned i; |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "_Literal ("); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_string (pp, ") "); |
| } |
| pp_string (pp, "{ "); |
| unsigned HOST_WIDE_INT nunits; |
| if (!VECTOR_CST_NELTS (node).is_constant (&nunits)) |
| nunits = vector_cst_encoded_nelts (node); |
| for (i = 0; i < nunits; ++i) |
| { |
| if (i != 0) |
| pp_string (pp, ", "); |
| dump_generic_node (pp, VECTOR_CST_ELT (node, i), |
| spc, flags, false); |
| } |
| if (!VECTOR_CST_NELTS (node).is_constant ()) |
| pp_string (pp, ", ..."); |
| pp_string (pp, " }"); |
| } |
| break; |
| |
| case FUNCTION_TYPE: |
| case METHOD_TYPE: |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_space (pp); |
| if (TREE_CODE (node) == METHOD_TYPE) |
| { |
| if (TYPE_METHOD_BASETYPE (node)) |
| dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), |
| spc, flags, false); |
| else |
| pp_string (pp, "<null method basetype>"); |
| pp_colon_colon (pp); |
| } |
| if (TYPE_IDENTIFIER (node)) |
| dump_generic_node (pp, TYPE_NAME (node), spc, flags, false); |
| else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) |
| dump_decl_name (pp, TYPE_NAME (node), flags); |
| else if (flags & TDF_NOUID) |
| pp_printf (pp, "<Txxxx>"); |
| else |
| pp_printf (pp, "<T%x>", TYPE_UID (node)); |
| dump_function_declaration (pp, node, spc, flags); |
| break; |
| |
| case FUNCTION_DECL: |
| case CONST_DECL: |
| dump_decl_name (pp, node, flags); |
| break; |
| |
| case LABEL_DECL: |
| if (DECL_NAME (node)) |
| dump_decl_name (pp, node, flags); |
| else if (LABEL_DECL_UID (node) != -1) |
| { |
| if (flags & TDF_GIMPLE) |
| pp_printf (pp, "L%d", (int) LABEL_DECL_UID (node)); |
| else |
| pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node)); |
| } |
| else |
| { |
| if (flags & TDF_NOUID) |
| pp_string (pp, "<D.xxxx>"); |
| else |
| { |
| if (flags & TDF_GIMPLE) |
| pp_printf (pp, "<D%u>", DECL_UID (node)); |
| else |
| pp_printf (pp, "<D.%u>", DECL_UID (node)); |
| } |
| } |
| break; |
| |
| case TYPE_DECL: |
| if (DECL_IS_BUILTIN (node)) |
| { |
| /* Don't print the declaration of built-in types. */ |
| break; |
| } |
| if (DECL_NAME (node)) |
| dump_decl_name (pp, node, flags); |
| else if (TYPE_NAME (TREE_TYPE (node)) != node) |
| { |
| pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE |
| ? "union" : "struct ")); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| } |
| else |
| pp_string (pp, "<anon>"); |
| break; |
| |
| case VAR_DECL: |
| case PARM_DECL: |
| case FIELD_DECL: |
| case DEBUG_EXPR_DECL: |
| case NAMESPACE_DECL: |
| case NAMELIST_DECL: |
| dump_decl_name (pp, node, flags); |
| break; |
| |
| case RESULT_DECL: |
| pp_string (pp, "<retval>"); |
| break; |
| |
| case COMPONENT_REF: |
| op0 = TREE_OPERAND (node, 0); |
| str = "."; |
| if (op0 |
| && (TREE_CODE (op0) == INDIRECT_REF |
| || (TREE_CODE (op0) == MEM_REF |
| && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR |
| && integer_zerop (TREE_OPERAND (op0, 1)) |
| /* Dump the types of INTEGER_CSTs explicitly, for we |
| can't infer them and MEM_ATTR caching will share |
| MEM_REFs with differently-typed op0s. */ |
| && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST |
| /* Released SSA_NAMES have no TREE_TYPE. */ |
| && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE |
| /* Same pointer types, but ignoring POINTER_TYPE vs. |
| REFERENCE_TYPE. */ |
| && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
| == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
| && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
| == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
| && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0))) |
| == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
| /* Same value types ignoring qualifiers. */ |
| && (TYPE_MAIN_VARIANT (TREE_TYPE (op0)) |
| == TYPE_MAIN_VARIANT |
| (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))) |
| && MR_DEPENDENCE_CLIQUE (op0) == 0))) |
| { |
| op0 = TREE_OPERAND (op0, 0); |
| str = "->"; |
| } |
| if (op_prio (op0) < op_prio (node)) |
| pp_left_paren (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| if (op_prio (op0) < op_prio (node)) |
| pp_right_paren (pp); |
| pp_string (pp, str); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| op0 = component_ref_field_offset (node); |
| if (op0 && TREE_CODE (op0) != INTEGER_CST) |
| { |
| pp_string (pp, "{off: "); |
| dump_generic_node (pp, op0, spc, flags, false); |
| pp_right_brace (pp); |
| } |
| break; |
| |
| case BIT_FIELD_REF: |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "__BIT_FIELD_REF <"); |
| dump_generic_node (pp, TREE_TYPE (node), |
| spc, flags | TDF_SLIM, false); |
| if (TYPE_ALIGN (TREE_TYPE (node)) |
| != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node)))) |
| { |
| pp_string (pp, ", "); |
| pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node))); |
| } |
| pp_greater (pp); |
| pp_string (pp, " ("); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, |
| flags | TDF_SLIM, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, |
| flags | TDF_SLIM, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 2), spc, |
| flags | TDF_SLIM, false); |
| pp_right_paren (pp); |
| } |
| else |
| { |
| pp_string (pp, "BIT_FIELD_REF <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false); |
| pp_greater (pp); |
| } |
| break; |
| |
| case BIT_INSERT_EXPR: |
| pp_string (pp, "BIT_INSERT_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false); |
| pp_string (pp, " ("); |
| if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1)))) |
| pp_decimal_int (pp, |
| TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1)))); |
| else |
| dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))), |
| spc, flags, false); |
| pp_string (pp, " bits)>"); |
| break; |
| |
| case ARRAY_REF: |
| case ARRAY_RANGE_REF: |
| op0 = TREE_OPERAND (node, 0); |
| if (op_prio (op0) < op_prio (node)) |
| pp_left_paren (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| if (op_prio (op0) < op_prio (node)) |
| pp_right_paren (pp); |
| pp_left_bracket (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| if (TREE_CODE (node) == ARRAY_RANGE_REF) |
| pp_string (pp, " ..."); |
| pp_right_bracket (pp); |
| |
| op0 = array_ref_low_bound (node); |
| op1 = array_ref_element_size (node); |
| |
| if (!integer_zerop (op0) |
| || TREE_OPERAND (node, 2) |
| || TREE_OPERAND (node, 3)) |
| { |
| pp_string (pp, "{lb: "); |
| dump_generic_node (pp, op0, spc, flags, false); |
| pp_string (pp, " sz: "); |
| dump_generic_node (pp, op1, spc, flags, false); |
| pp_right_brace (pp); |
| } |
| break; |
| |
| case CONSTRUCTOR: |
| { |
| unsigned HOST_WIDE_INT ix; |
| tree field, val; |
| bool is_struct_init = false; |
| bool is_array_init = false; |
| widest_int curidx; |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "_Literal ("); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_string (pp, ") "); |
| } |
| pp_left_brace (pp); |
| if (TREE_CLOBBER_P (node)) |
| pp_string (pp, "CLOBBER"); |
| else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE |
| || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) |
| is_struct_init = true; |
| else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE |
| && TYPE_DOMAIN (TREE_TYPE (node)) |
| && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))) |
| && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))) |
| == INTEGER_CST) |
| { |
| tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))); |
| is_array_init = true; |
| curidx = wi::to_widest (minv); |
| } |
| FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) |
| { |
| if (field) |
| { |
| if (is_struct_init) |
| { |
| pp_dot (pp); |
| dump_generic_node (pp, field, spc, flags, false); |
| pp_equal (pp); |
| } |
| else if (is_array_init |
| && (TREE_CODE (field) != INTEGER_CST |
| || curidx != wi::to_widest (field))) |
| { |
| pp_left_bracket (pp); |
| if (TREE_CODE (field) == RANGE_EXPR) |
| { |
| dump_generic_node (pp, TREE_OPERAND (field, 0), spc, |
| flags, false); |
| pp_string (pp, " ... "); |
| dump_generic_node (pp, TREE_OPERAND (field, 1), spc, |
| flags, false); |
| if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST) |
| curidx = wi::to_widest (TREE_OPERAND (field, 1)); |
| } |
| else |
| dump_generic_node (pp, field, spc, flags, false); |
| if (TREE_CODE (field) == INTEGER_CST) |
| curidx = wi::to_widest (field); |
| pp_string (pp, "]="); |
| } |
| } |
| if (is_array_init) |
| curidx += 1; |
| if (val && TREE_CODE (val) == ADDR_EXPR) |
| if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) |
| val = TREE_OPERAND (val, 0); |
| if (val && TREE_CODE (val) == FUNCTION_DECL) |
| dump_decl_name (pp, val, flags); |
| else |
| dump_generic_node (pp, val, spc, flags, false); |
| if (ix != CONSTRUCTOR_NELTS (node) - 1) |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| } |
| pp_right_brace (pp); |
| } |
| break; |
| |
| case COMPOUND_EXPR: |
| { |
| tree *tp; |
| if (flags & TDF_SLIM) |
| { |
| pp_string (pp, "<COMPOUND_EXPR>"); |
| break; |
| } |
| |
| dump_generic_node (pp, TREE_OPERAND (node, 0), |
| spc, flags, !(flags & TDF_SLIM)); |
| if (flags & TDF_SLIM) |
| newline_and_indent (pp, spc); |
| else |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| |
| for (tp = &TREE_OPERAND (node, 1); |
| TREE_CODE (*tp) == COMPOUND_EXPR; |
| tp = &TREE_OPERAND (*tp, 1)) |
| { |
| dump_generic_node (pp, TREE_OPERAND (*tp, 0), |
| spc, flags, !(flags & TDF_SLIM)); |
| if (flags & TDF_SLIM) |
| newline_and_indent (pp, spc); |
| else |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| } |
| |
| dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM)); |
| } |
| break; |
| |
| case STATEMENT_LIST: |
| { |
| tree_stmt_iterator si; |
| bool first = true; |
| |
| if (flags & TDF_SLIM) |
| { |
| pp_string (pp, "<STATEMENT_LIST>"); |
| break; |
| } |
| |
| for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si)) |
| { |
| if (!first) |
| newline_and_indent (pp, spc); |
| else |
| first = false; |
| dump_generic_node (pp, tsi_stmt (si), spc, flags, true); |
| } |
| } |
| break; |
| |
| case MODIFY_EXPR: |
| case INIT_EXPR: |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, |
| false); |
| pp_space (pp); |
| pp_equal (pp); |
| pp_space (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, |
| false); |
| break; |
| |
| case TARGET_EXPR: |
| pp_string (pp, "TARGET_EXPR <"); |
| dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false); |
| pp_comma (pp); |
| pp_space (pp); |
| dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case DECL_EXPR: |
| print_declaration (pp, DECL_EXPR_DECL (node), spc, flags); |
| is_stmt = false; |
| break; |
| |
| case COND_EXPR: |
| if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node) |
| { |
| pp_string (pp, "if ("); |
| dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false); |
| pp_right_paren (pp); |
| /* The lowered cond_exprs should always be printed in full. */ |
| if (COND_EXPR_THEN (node) |
| && (IS_EMPTY_STMT (COND_EXPR_THEN (node)) |
| || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR) |
| && COND_EXPR_ELSE (node) |
| && (IS_EMPTY_STMT (COND_EXPR_ELSE (node)) |
| || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) |
| { |
| pp_space (pp); |
| dump_generic_node (pp, COND_EXPR_THEN (node), |
| 0, flags, true); |
| if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node))) |
| { |
| pp_string (pp, " else "); |
| dump_generic_node (pp, COND_EXPR_ELSE (node), |
| 0, flags, true); |
| } |
| } |
| else if (!(flags & TDF_SLIM)) |
| { |
| /* Output COND_EXPR_THEN. */ |
| if (COND_EXPR_THEN (node)) |
| { |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, COND_EXPR_THEN (node), spc+4, |
| flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| } |
| |
| /* Output COND_EXPR_ELSE. */ |
| if (COND_EXPR_ELSE (node) |
| && !IS_EMPTY_STMT (COND_EXPR_ELSE (node))) |
| { |
| newline_and_indent (pp, spc); |
| pp_string (pp, "else"); |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4, |
| flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| } |
| } |
| is_expr = false; |
| } |
| else |
| { |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_space (pp); |
| pp_question (pp); |
| pp_space (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_space (pp); |
| pp_colon (pp); |
| pp_space (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false); |
| } |
| break; |
| |
| case BIND_EXPR: |
| pp_left_brace (pp); |
| if (!(flags & TDF_SLIM)) |
| { |
| if (BIND_EXPR_VARS (node)) |
| { |
| pp_newline (pp); |
| |
| for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0)) |
| { |
| print_declaration (pp, op0, spc+2, flags); |
| pp_newline (pp); |
| } |
| } |
| |
| newline_and_indent (pp, spc+2); |
| dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true); |
| newline_and_indent (pp, spc); |
| pp_right_brace (pp); |
| } |
| is_expr = false; |
| break; |
| |
| case CALL_EXPR: |
| if (CALL_EXPR_FN (node) != NULL_TREE) |
| print_call_name (pp, CALL_EXPR_FN (node), flags); |
| else |
| { |
| pp_dot (pp); |
| pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node))); |
| } |
| |
| /* Print parameters. */ |
| pp_space (pp); |
| pp_left_paren (pp); |
| { |
| tree arg; |
| call_expr_arg_iterator iter; |
| FOR_EACH_CALL_EXPR_ARG (arg, iter, node) |
| { |
| dump_generic_node (pp, arg, spc, flags, false); |
| if (more_call_expr_args_p (&iter)) |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| } |
| } |
| if (CALL_EXPR_VA_ARG_PACK (node)) |
| { |
| if (call_expr_nargs (node) > 0) |
| { |
| pp_comma (pp); |
| pp_space (pp); |
| } |
| pp_string (pp, "__builtin_va_arg_pack ()"); |
| } |
| pp_right_paren (pp); |
| |
| op1 = CALL_EXPR_STATIC_CHAIN (node); |
| if (op1) |
| { |
| pp_string (pp, " [static-chain: "); |
| dump_generic_node (pp, op1, spc, flags, false); |
| pp_right_bracket (pp); |
| } |
| |
| if (CALL_EXPR_RETURN_SLOT_OPT (node)) |
| pp_string (pp, " [return slot optimization]"); |
| if (CALL_EXPR_TAILCALL (node)) |
| pp_string (pp, " [tail call]"); |
| break; |
| |
| case WITH_CLEANUP_EXPR: |
| NIY; |
| break; |
| |
| case CLEANUP_POINT_EXPR: |
| pp_string (pp, "<<cleanup_point "); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ">>"); |
| break; |
| |
| case PLACEHOLDER_EXPR: |
| pp_string (pp, "<PLACEHOLDER_EXPR "); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| /* Binary arithmetic and logic expressions. */ |
| case WIDEN_SUM_EXPR: |
| case WIDEN_MULT_EXPR: |
| case MULT_EXPR: |
| case MULT_HIGHPART_EXPR: |
| case PLUS_EXPR: |
| case POINTER_PLUS_EXPR: |
| case POINTER_DIFF_EXPR: |
| case MINUS_EXPR: |
| case TRUNC_DIV_EXPR: |
| case CEIL_DIV_EXPR: |
| case FLOOR_DIV_EXPR: |
| case ROUND_DIV_EXPR: |
| case TRUNC_MOD_EXPR: |
| case CEIL_MOD_EXPR: |
| case FLOOR_MOD_EXPR: |
| case ROUND_MOD_EXPR: |
| case RDIV_EXPR: |
| case EXACT_DIV_EXPR: |
| case LSHIFT_EXPR: |
| case RSHIFT_EXPR: |
| case LROTATE_EXPR: |
| case RROTATE_EXPR: |
| case WIDEN_LSHIFT_EXPR: |
| case BIT_IOR_EXPR: |
| case BIT_XOR_EXPR: |
| case BIT_AND_EXPR: |
| case TRUTH_ANDIF_EXPR: |
| case TRUTH_ORIF_EXPR: |
| case TRUTH_AND_EXPR: |
| case TRUTH_OR_EXPR: |
| case TRUTH_XOR_EXPR: |
| case LT_EXPR: |
| case LE_EXPR: |
| case GT_EXPR: |
| case GE_EXPR: |
| case EQ_EXPR: |
| case NE_EXPR: |
| case UNLT_EXPR: |
| case UNLE_EXPR: |
| case UNGT_EXPR: |
| case UNGE_EXPR: |
| case UNEQ_EXPR: |
| case LTGT_EXPR: |
| case ORDERED_EXPR: |
| case UNORDERED_EXPR: |
| { |
| const char *op = op_symbol (node); |
| op0 = TREE_OPERAND (node, 0); |
| op1 = TREE_OPERAND (node, 1); |
| |
| /* When the operands are expressions with less priority, |
| keep semantics of the tree representation. */ |
| if (op_prio (op0) <= op_prio (node)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| pp_right_paren (pp); |
| } |
| else |
| dump_generic_node (pp, op0, spc, flags, false); |
| |
| pp_space (pp); |
| pp_string (pp, op); |
| pp_space (pp); |
| |
| /* When the operands are expressions with less priority, |
| keep semantics of the tree representation. */ |
| if (op_prio (op1) <= op_prio (node)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, op1, spc, flags, false); |
| pp_right_paren (pp); |
| } |
| else |
| dump_generic_node (pp, op1, spc, flags, false); |
| } |
| break; |
| |
| /* Unary arithmetic and logic expressions. */ |
| case NEGATE_EXPR: |
| case BIT_NOT_EXPR: |
| case TRUTH_NOT_EXPR: |
| case ADDR_EXPR: |
| case PREDECREMENT_EXPR: |
| case PREINCREMENT_EXPR: |
| case INDIRECT_REF: |
| if (TREE_CODE (node) == ADDR_EXPR |
| && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST |
| || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL)) |
| ; /* Do not output '&' for strings and function pointers. */ |
| else |
| pp_string (pp, op_symbol (node)); |
| |
| if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_right_paren (pp); |
| } |
| else |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| break; |
| |
| case POSTDECREMENT_EXPR: |
| case POSTINCREMENT_EXPR: |
| if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_right_paren (pp); |
| } |
| else |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, op_symbol (node)); |
| break; |
| |
| case MIN_EXPR: |
| pp_string (pp, "MIN_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case MAX_EXPR: |
| pp_string (pp, "MAX_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case ABS_EXPR: |
| pp_string (pp, "ABS_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case ABSU_EXPR: |
| pp_string (pp, "ABSU_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case RANGE_EXPR: |
| NIY; |
| break; |
| |
| case ADDR_SPACE_CONVERT_EXPR: |
| case FIXED_CONVERT_EXPR: |
| case FIX_TRUNC_EXPR: |
| case FLOAT_EXPR: |
| CASE_CONVERT: |
| type = TREE_TYPE (node); |
| op0 = TREE_OPERAND (node, 0); |
| if (type != TREE_TYPE (op0)) |
| { |
| pp_left_paren (pp); |
| dump_generic_node (pp, type, spc, flags, false); |
| pp_string (pp, ") "); |
| } |
| if (op_prio (op0) < op_prio (node)) |
| pp_left_paren (pp); |
| dump_generic_node (pp, op0, spc, flags, false); |
| if (op_prio (op0) < op_prio (node)) |
| pp_right_paren (pp); |
| break; |
| |
| case VIEW_CONVERT_EXPR: |
| if (flags & TDF_GIMPLE) |
| pp_string (pp, "__VIEW_CONVERT <"); |
| else |
| pp_string (pp, "VIEW_CONVERT_EXPR<"); |
| dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); |
| pp_string (pp, ">("); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_right_paren (pp); |
| break; |
| |
| case PAREN_EXPR: |
| pp_string (pp, "(("); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, "))"); |
| break; |
| |
| case NON_LVALUE_EXPR: |
| pp_string (pp, "NON_LVALUE_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case SAVE_EXPR: |
| pp_string (pp, "SAVE_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case COMPLEX_EXPR: |
| pp_string (pp, "COMPLEX_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_string (pp, ", "); |
| dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case CONJ_EXPR: |
| pp_string (pp, "CONJ_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case REALPART_EXPR: |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "__real "); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| } |
| else |
| { |
| pp_string (pp, "REALPART_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| } |
| break; |
| |
| case IMAGPART_EXPR: |
| if (flags & TDF_GIMPLE) |
| { |
| pp_string (pp, "__imag "); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| } |
| else |
| { |
| pp_string (pp, "IMAGPART_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| } |
| break; |
| |
| case VA_ARG_EXPR: |
| pp_string (pp, "VA_ARG_EXPR <"); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); |
| pp_greater (pp); |
| break; |
| |
| case TRY_FINALLY_EXPR: |
| case TRY_CATCH_EXPR: |
| pp_string (pp, "try"); |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| newline_and_indent (pp, spc); |
| if (TREE_CODE (node) == TRY_CATCH_EXPR) |
| { |
| node = TREE_OPERAND (node, 1); |
| pp_string (pp, "catch"); |
| } |
| else |
| { |
| gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR); |
| node = TREE_OPERAND (node, 1); |
| pp_string (pp, "finally"); |
| if (TREE_CODE (node) == EH_ELSE_EXPR) |
| { |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, |
| flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| newline_and_indent (pp, spc); |
| node = TREE_OPERAND (node, 1); |
| pp_string (pp, "else"); |
| } |
| } |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, node, spc+4, flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| is_expr = false; |
| break; |
| |
| case CATCH_EXPR: |
| pp_string (pp, "catch ("); |
| dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false); |
| pp_right_paren (pp); |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| is_expr = false; |
| break; |
| |
| case EH_FILTER_EXPR: |
| pp_string (pp, "<<<eh_filter ("); |
| dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false); |
| pp_string (pp, ")>>>"); |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| is_expr = false; |
| break; |
| |
| case LABEL_EXPR: |
| op0 = TREE_OPERAND (node, 0); |
| /* If this is for break or continue, don't bother printing it. */ |
| if (DECL_NAME (op0)) |
| { |
| const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); |
| if (strcmp (name, "break") == 0 |
| || strcmp (name, "continue") == 0) |
| break; |
| } |
| dump_generic_node (pp, op0, spc, flags, false); |
| pp_colon (pp); |
| if (DECL_NONLOCAL (op0)) |
| pp_string (pp, " [non-local]"); |
| break; |
| |
| case LOOP_EXPR: |
| pp_string (pp, "while (1)"); |
| if (!(flags & TDF_SLIM)) |
| { |
| newline_and_indent (pp, spc+2); |
| pp_left_brace (pp); |
| newline_and_indent (pp, spc+4); |
| dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true); |
| newline_and_indent (pp, spc+2); |
| pp_right_brace (pp); |
| |