Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-pretty-print.c @ 132:d34655255c78

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc-8.2
author mir3636
date Thu, 25 Oct 2018 10:21:07 +0900
parents 84e7813d76e9
children 1830386684a0
comparison
equal deleted inserted replaced
130:e108057fa461 132:d34655255c78
1 /* Pretty formatting of GENERIC trees in C syntax. 1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc. 2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com> 3 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
4 4
5 This file is part of GCC. 5 This file is part of GCC.
6 6
7 GCC is free software; you can redistribute it and/or modify it under 7 GCC is free software; you can redistribute it and/or modify it under
35 #include "gomp-constants.h" 35 #include "gomp-constants.h"
36 #include "gimple.h" 36 #include "gimple.h"
37 37
38 /* Local functions, macros and variables. */ 38 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree); 39 static const char *op_symbol (const_tree);
40 static void pretty_print_string (pretty_printer *, const char*); 40 static void pretty_print_string (pretty_printer *, const char*, unsigned);
41 static void newline_and_indent (pretty_printer *, int); 41 static void newline_and_indent (pretty_printer *, int);
42 static void maybe_init_pretty_print (FILE *); 42 static void maybe_init_pretty_print (FILE *);
43 static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t); 43 static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t);
44 static void do_niy (pretty_printer *, const_tree, dump_flags_t); 44 static void do_niy (pretty_printer *, const_tree, dump_flags_t);
45 45
158 print_generic_expr (FILE *file, tree t, dump_flags_t flags) 158 print_generic_expr (FILE *file, tree t, dump_flags_t flags)
159 { 159 {
160 maybe_init_pretty_print (file); 160 maybe_init_pretty_print (file);
161 dump_generic_node (tree_pp, t, 0, flags, false); 161 dump_generic_node (tree_pp, t, 0, flags, false);
162 pp_flush (tree_pp); 162 pp_flush (tree_pp);
163 }
164
165 /* Print a single expression T to string, and return it. */
166
167 char *
168 print_generic_expr_to_str (tree t)
169 {
170 pretty_printer pp;
171 dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false);
172 return xstrdup (pp_formatted_text (&pp));
163 } 173 }
164 174
165 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences 175 /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
166 in it are replaced with Dxxxx, as long as they are at the start or 176 in it are replaced with Dxxxx, as long as they are at the start or
167 preceded by $ and at the end or followed by $. See make_fancy_name 177 preceded by $ and at the end or followed by $. See make_fancy_name
245 in FLAGS. */ 255 in FLAGS. */
246 256
247 static void 257 static void
248 dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags) 258 dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
249 { 259 {
250 if (DECL_NAME (node)) 260 tree name = DECL_NAME (node);
261 if (name)
251 { 262 {
252 if ((flags & TDF_ASMNAME) 263 if ((flags & TDF_ASMNAME)
253 && HAS_DECL_ASSEMBLER_NAME_P (node) 264 && HAS_DECL_ASSEMBLER_NAME_P (node)
254 && DECL_ASSEMBLER_NAME_SET_P (node)) 265 && DECL_ASSEMBLER_NAME_SET_P (node))
255 pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node)); 266 pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node));
267 /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
268 -g might have created more fancy names and their indexes
269 could get out of sync. Usually those should be DECL_IGNORED_P
270 too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
271 names, let's hope those never get out of sync after doing the
272 dump_fancy_name sanitization. */
273 else if ((flags & TDF_COMPARE_DEBUG)
274 && DECL_NAMELESS (node)
275 && DECL_IGNORED_P (node))
276 name = NULL_TREE;
256 /* For DECL_NAMELESS names look for embedded uids in the 277 /* For DECL_NAMELESS names look for embedded uids in the
257 names and sanitize them for TDF_NOUID. */ 278 names and sanitize them for TDF_NOUID. */
258 else if ((flags & TDF_NOUID) && DECL_NAMELESS (node)) 279 else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
259 dump_fancy_name (pp, DECL_NAME (node)); 280 dump_fancy_name (pp, name);
260 else 281 else
261 pp_tree_identifier (pp, DECL_NAME (node)); 282 pp_tree_identifier (pp, name);
262 } 283 }
263 char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.'; 284 char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
264 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE) 285 if ((flags & TDF_UID) || name == NULL_TREE)
265 { 286 {
266 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) 287 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
267 pp_printf (pp, "L%c%d", uid_sep, (int) LABEL_DECL_UID (node)); 288 pp_printf (pp, "L%c%d", uid_sep, (int) LABEL_DECL_UID (node));
268 else if (TREE_CODE (node) == DEBUG_EXPR_DECL) 289 else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
269 { 290 {
464 dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause), 485 dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
465 spc, flags, false); 486 spc, flags, false);
466 pp_right_paren (pp); 487 pp_right_paren (pp);
467 break; 488 break;
468 489
469 case OMP_CLAUSE__CILK_FOR_COUNT_:
470 pp_string (pp, "_Cilk_for_count_(");
471 dump_generic_node (pp, OMP_CLAUSE_OPERAND (clause, 0),
472 spc, flags, false);
473 pp_right_paren (pp);
474 break;
475
476 case OMP_CLAUSE_NOWAIT: 490 case OMP_CLAUSE_NOWAIT:
477 pp_string (pp, "nowait"); 491 pp_string (pp, "nowait");
478 break; 492 break;
479 case OMP_CLAUSE_ORDERED: 493 case OMP_CLAUSE_ORDERED:
480 pp_string (pp, "ordered"); 494 pp_string (pp, "ordered");
547 case OMP_CLAUSE_SCHEDULE_RUNTIME: 561 case OMP_CLAUSE_SCHEDULE_RUNTIME:
548 pp_string (pp, "runtime"); 562 pp_string (pp, "runtime");
549 break; 563 break;
550 case OMP_CLAUSE_SCHEDULE_AUTO: 564 case OMP_CLAUSE_SCHEDULE_AUTO:
551 pp_string (pp, "auto"); 565 pp_string (pp, "auto");
552 break;
553 case OMP_CLAUSE_SCHEDULE_CILKFOR:
554 pp_string (pp, "cilk-for grain");
555 break; 566 break;
556 default: 567 default:
557 gcc_unreachable (); 568 gcc_unreachable ();
558 } 569 }
559 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) 570 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
1042 pp_comma (pp); 1053 pp_comma (pp);
1043 dump_generic_node (pp, OMP_CLAUSE__GRIDDIM__GROUP (clause), spc, flags, 1054 dump_generic_node (pp, OMP_CLAUSE__GRIDDIM__GROUP (clause), spc, flags,
1044 false); 1055 false);
1045 pp_right_paren (pp); 1056 pp_right_paren (pp);
1046 break; 1057 break;
1058 case OMP_CLAUSE_IF_PRESENT:
1059 pp_string (pp, "if_present");
1060 break;
1061 case OMP_CLAUSE_FINALIZE:
1062 pp_string (pp, "finalize");
1063 break;
1047 1064
1048 default: 1065 default:
1049 /* Should never happen. */ 1066 /* Should never happen. */
1050 dump_generic_node (pp, clause, spc, flags, false); 1067 dump_generic_node (pp, clause, spc, flags, false);
1051 break; 1068 break;
1104 1121
1105 pp_printf (pp, "BLOCK #%d ", BLOCK_NUMBER (block)); 1122 pp_printf (pp, "BLOCK #%d ", BLOCK_NUMBER (block));
1106 1123
1107 if (flags & TDF_ADDRESS) 1124 if (flags & TDF_ADDRESS)
1108 pp_printf (pp, "[%p] ", (void *) block); 1125 pp_printf (pp, "[%p] ", (void *) block);
1109
1110 if (BLOCK_ABSTRACT (block))
1111 pp_string (pp, "[abstract] ");
1112 1126
1113 if (TREE_ASM_WRITTEN (block)) 1127 if (TREE_ASM_WRITTEN (block))
1114 pp_string (pp, "[written] "); 1128 pp_string (pp, "[written] ");
1115 1129
1116 if (flags & TDF_SLIM) 1130 if (flags & TDF_SLIM)
1282 } 1296 }
1283 } 1297 }
1284 break; 1298 break;
1285 1299
1286 case VOID_TYPE: 1300 case VOID_TYPE:
1287 case POINTER_BOUNDS_TYPE:
1288 case INTEGER_TYPE: 1301 case INTEGER_TYPE:
1289 case REAL_TYPE: 1302 case REAL_TYPE:
1290 case FIXED_POINT_TYPE: 1303 case FIXED_POINT_TYPE:
1291 case COMPLEX_TYPE: 1304 case COMPLEX_TYPE:
1292 case VECTOR_TYPE: 1305 case VECTOR_TYPE:
1420 1433
1421 dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false); 1434 dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
1422 pp_space (pp); 1435 pp_space (pp);
1423 pp_left_paren (pp); 1436 pp_left_paren (pp);
1424 pp_string (pp, str); 1437 pp_string (pp, str);
1425 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) 1438 if (TYPE_IDENTIFIER (node))
1426 dump_decl_name (pp, TYPE_NAME (node), flags); 1439 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1427 else if (flags & TDF_NOUID) 1440 else if (flags & TDF_NOUID)
1428 pp_printf (pp, "<Txxxx>"); 1441 pp_printf (pp, "<Txxxx>");
1429 else 1442 else
1430 pp_printf (pp, "<T%x>", TYPE_UID (node)); 1443 pp_printf (pp, "<T%x>", TYPE_UID (node));
1431 1444
1742 } 1755 }
1743 if (TREE_OVERFLOW (node)) 1756 if (TREE_OVERFLOW (node))
1744 pp_string (pp, "(OVF)"); 1757 pp_string (pp, "(OVF)");
1745 break; 1758 break;
1746 1759
1760 case POLY_INT_CST:
1761 pp_string (pp, "POLY_INT_CST [");
1762 dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
1763 for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
1764 {
1765 pp_string (pp, ", ");
1766 dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
1767 spc, flags, false);
1768 }
1769 pp_string (pp, "]");
1770 break;
1771
1747 case REAL_CST: 1772 case REAL_CST:
1748 /* Code copied from print_node. */ 1773 /* Code copied from print_node. */
1749 { 1774 {
1750 REAL_VALUE_TYPE d; 1775 REAL_VALUE_TYPE d;
1751 if (TREE_OVERFLOW (node)) 1776 if (TREE_OVERFLOW (node))
1780 dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false); 1805 dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
1781 pp_right_paren (pp); 1806 pp_right_paren (pp);
1782 break; 1807 break;
1783 1808
1784 case STRING_CST: 1809 case STRING_CST:
1785 pp_string (pp, "\""); 1810 {
1786 pretty_print_string (pp, TREE_STRING_POINTER (node)); 1811 pp_string (pp, "\"");
1787 pp_string (pp, "\""); 1812 if (unsigned nbytes = TREE_STRING_LENGTH (node))
1788 break; 1813 pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
1814 pp_string (pp, "\"");
1815 break;
1816 }
1789 1817
1790 case VECTOR_CST: 1818 case VECTOR_CST:
1791 { 1819 {
1792 unsigned i; 1820 unsigned i;
1793 pp_string (pp, "{ "); 1821 pp_string (pp, "{ ");
1794 for (i = 0; i < VECTOR_CST_NELTS (node); ++i) 1822 unsigned HOST_WIDE_INT nunits;
1823 if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
1824 nunits = vector_cst_encoded_nelts (node);
1825 for (i = 0; i < nunits; ++i)
1795 { 1826 {
1796 if (i != 0) 1827 if (i != 0)
1797 pp_string (pp, ", "); 1828 pp_string (pp, ", ");
1798 dump_generic_node (pp, VECTOR_CST_ELT (node, i), 1829 dump_generic_node (pp, VECTOR_CST_ELT (node, i),
1799 spc, flags, false); 1830 spc, flags, false);
1800 } 1831 }
1832 if (!VECTOR_CST_NELTS (node).is_constant ())
1833 pp_string (pp, ", ...");
1801 pp_string (pp, " }"); 1834 pp_string (pp, " }");
1802 } 1835 }
1803 break; 1836 break;
1804 1837
1805 case FUNCTION_TYPE: 1838 case FUNCTION_TYPE:
1807 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); 1840 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1808 pp_space (pp); 1841 pp_space (pp);
1809 if (TREE_CODE (node) == METHOD_TYPE) 1842 if (TREE_CODE (node) == METHOD_TYPE)
1810 { 1843 {
1811 if (TYPE_METHOD_BASETYPE (node)) 1844 if (TYPE_METHOD_BASETYPE (node))
1812 dump_decl_name (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), 1845 dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1813 flags); 1846 spc, flags, false);
1814 else 1847 else
1815 pp_string (pp, "<null method basetype>"); 1848 pp_string (pp, "<null method basetype>");
1816 pp_colon_colon (pp); 1849 pp_colon_colon (pp);
1817 } 1850 }
1818 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) 1851 if (TYPE_IDENTIFIER (node))
1852 dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1853 else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1819 dump_decl_name (pp, TYPE_NAME (node), flags); 1854 dump_decl_name (pp, TYPE_NAME (node), flags);
1820 else if (flags & TDF_NOUID) 1855 else if (flags & TDF_NOUID)
1821 pp_printf (pp, "<Txxxx>"); 1856 pp_printf (pp, "<Txxxx>");
1822 else 1857 else
1823 pp_printf (pp, "<T%x>", TYPE_UID (node)); 1858 pp_printf (pp, "<T%x>", TYPE_UID (node));
2240 2275
2241 case CALL_EXPR: 2276 case CALL_EXPR:
2242 if (CALL_EXPR_FN (node) != NULL_TREE) 2277 if (CALL_EXPR_FN (node) != NULL_TREE)
2243 print_call_name (pp, CALL_EXPR_FN (node), flags); 2278 print_call_name (pp, CALL_EXPR_FN (node), flags);
2244 else 2279 else
2245 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node))); 2280 {
2281 pp_dot (pp);
2282 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2283 }
2246 2284
2247 /* Print parameters. */ 2285 /* Print parameters. */
2248 pp_space (pp); 2286 pp_space (pp);
2249 pp_left_paren (pp); 2287 pp_left_paren (pp);
2250 { 2288 {
2306 case WIDEN_MULT_EXPR: 2344 case WIDEN_MULT_EXPR:
2307 case MULT_EXPR: 2345 case MULT_EXPR:
2308 case MULT_HIGHPART_EXPR: 2346 case MULT_HIGHPART_EXPR:
2309 case PLUS_EXPR: 2347 case PLUS_EXPR:
2310 case POINTER_PLUS_EXPR: 2348 case POINTER_PLUS_EXPR:
2349 case POINTER_DIFF_EXPR:
2311 case MINUS_EXPR: 2350 case MINUS_EXPR:
2312 case TRUNC_DIV_EXPR: 2351 case TRUNC_DIV_EXPR:
2313 case CEIL_DIV_EXPR: 2352 case CEIL_DIV_EXPR:
2314 case FLOOR_DIV_EXPR: 2353 case FLOOR_DIV_EXPR:
2315 case ROUND_DIV_EXPR: 2354 case ROUND_DIV_EXPR:
2437 pp_string (pp, "ABS_EXPR <"); 2476 pp_string (pp, "ABS_EXPR <");
2438 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 2477 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2439 pp_greater (pp); 2478 pp_greater (pp);
2440 break; 2479 break;
2441 2480
2481 case ABSU_EXPR:
2482 pp_string (pp, "ABSU_EXPR <");
2483 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2484 pp_greater (pp);
2485 break;
2486
2442 case RANGE_EXPR: 2487 case RANGE_EXPR:
2443 NIY; 2488 NIY;
2444 break; 2489 break;
2445 2490
2446 case ADDR_SPACE_CONVERT_EXPR: 2491 case ADDR_SPACE_CONVERT_EXPR:
2630 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1))) 2675 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2631 { 2676 {
2632 case annot_expr_ivdep_kind: 2677 case annot_expr_ivdep_kind:
2633 pp_string (pp, ", ivdep"); 2678 pp_string (pp, ", ivdep");
2634 break; 2679 break;
2680 case annot_expr_unroll_kind:
2681 pp_printf (pp, ", unroll %d",
2682 (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
2683 break;
2635 case annot_expr_no_vector_kind: 2684 case annot_expr_no_vector_kind:
2636 pp_string (pp, ", no-vector"); 2685 pp_string (pp, ", no-vector");
2637 break; 2686 break;
2638 case annot_expr_vector_kind: 2687 case annot_expr_vector_kind:
2639 pp_string (pp, ", vector"); 2688 pp_string (pp, ", vector");
2689 break;
2690 case annot_expr_parallel_kind:
2691 pp_string (pp, ", parallel");
2640 break; 2692 break;
2641 default: 2693 default:
2642 gcc_unreachable (); 2694 gcc_unreachable ();
2643 } 2695 }
2644 pp_greater (pp); 2696 pp_greater (pp);
2675 if (SWITCH_BODY (node)) 2727 if (SWITCH_BODY (node))
2676 { 2728 {
2677 newline_and_indent (pp, spc+4); 2729 newline_and_indent (pp, spc+4);
2678 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags, 2730 dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2679 true); 2731 true);
2680 }
2681 else
2682 {
2683 tree vec = SWITCH_LABELS (node);
2684 size_t i, n = TREE_VEC_LENGTH (vec);
2685 for (i = 0; i < n; ++i)
2686 {
2687 tree elt = TREE_VEC_ELT (vec, i);
2688 newline_and_indent (pp, spc+4);
2689 if (elt)
2690 {
2691 dump_generic_node (pp, elt, spc+4, flags, false);
2692 pp_string (pp, " goto ");
2693 dump_generic_node (pp, CASE_LABEL (elt), spc+4,
2694 flags, true);
2695 pp_semicolon (pp);
2696 }
2697 else
2698 pp_string (pp, "case ???: goto ???;");
2699 }
2700 } 2732 }
2701 newline_and_indent (pp, spc+2); 2733 newline_and_indent (pp, spc+2);
2702 pp_right_brace (pp); 2734 pp_right_brace (pp);
2703 } 2735 }
2704 is_expr = false; 2736 is_expr = false;
2758 2790
2759 case OBJ_TYPE_REF: 2791 case OBJ_TYPE_REF:
2760 pp_string (pp, "OBJ_TYPE_REF("); 2792 pp_string (pp, "OBJ_TYPE_REF(");
2761 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false); 2793 dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2762 pp_semicolon (pp); 2794 pp_semicolon (pp);
2763 if (!(flags & TDF_SLIM) && virtual_method_call_p (node)) 2795 /* We omit the class type for -fcompare-debug because we may
2796 drop TYPE_BINFO early depending on debug info, and then
2797 virtual_method_call_p would return false, whereas when
2798 TYPE_BINFO is preserved it may still return true and then
2799 we'd print the class type. Compare tree and rtl dumps for
2800 libstdc++-prettyprinters/shared_ptr.cc with and without -g,
2801 for example, at occurrences of OBJ_TYPE_REF. */
2802 if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
2803 && virtual_method_call_p (node))
2764 { 2804 {
2765 pp_string (pp, "("); 2805 pp_string (pp, "(");
2766 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false); 2806 dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2767 pp_string (pp, ")"); 2807 pp_string (pp, ")");
2768 } 2808 }
2883 pp_string (pp, ", "); 2923 pp_string (pp, ", ");
2884 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false); 2924 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2885 pp_string (pp, " > "); 2925 pp_string (pp, " > ");
2886 break; 2926 break;
2887 2927
2888 case FMA_EXPR:
2889 pp_string (pp, " FMA_EXPR < ");
2890 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2891 pp_string (pp, ", ");
2892 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2893 pp_string (pp, ", ");
2894 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2895 pp_string (pp, " > ");
2896 break;
2897
2898 case OACC_PARALLEL: 2928 case OACC_PARALLEL:
2899 pp_string (pp, "#pragma acc parallel"); 2929 pp_string (pp, "#pragma acc parallel");
2900 goto dump_omp_clauses_body; 2930 goto dump_omp_clauses_body;
2901 2931
2902 case OACC_KERNELS: 2932 case OACC_KERNELS:
2971 3001
2972 case OMP_SIMD: 3002 case OMP_SIMD:
2973 pp_string (pp, "#pragma omp simd"); 3003 pp_string (pp, "#pragma omp simd");
2974 goto dump_omp_loop; 3004 goto dump_omp_loop;
2975 3005
2976 case CILK_SIMD:
2977 pp_string (pp, "#pragma simd");
2978 goto dump_omp_loop;
2979
2980 case CILK_FOR:
2981 /* This label points one line after dumping the clauses.
2982 For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2983 parameters are printed out. */
2984 goto dump_omp_loop_cilk_for;
2985
2986 case OMP_DISTRIBUTE: 3006 case OMP_DISTRIBUTE:
2987 pp_string (pp, "#pragma omp distribute"); 3007 pp_string (pp, "#pragma omp distribute");
2988 goto dump_omp_loop; 3008 goto dump_omp_loop;
2989 3009
2990 case OMP_TASKLOOP: 3010 case OMP_TASKLOOP:
3028 is_expr = false; 3048 is_expr = false;
3029 break; 3049 break;
3030 3050
3031 dump_omp_loop: 3051 dump_omp_loop:
3032 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags); 3052 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3033
3034 dump_omp_loop_cilk_for:
3035 if (!(flags & TDF_SLIM)) 3053 if (!(flags & TDF_SLIM))
3036 { 3054 {
3037 int i; 3055 int i;
3038 3056
3039 if (OMP_FOR_PRE_BODY (node)) 3057 if (OMP_FOR_PRE_BODY (node))
3040 { 3058 {
3041 if (TREE_CODE (node) == CILK_FOR) 3059 newline_and_indent (pp, spc + 2);
3042 pp_string (pp, " ");
3043 else
3044 newline_and_indent (pp, spc + 2);
3045 pp_left_brace (pp); 3060 pp_left_brace (pp);
3046 spc += 4; 3061 spc += 4;
3047 newline_and_indent (pp, spc); 3062 newline_and_indent (pp, spc);
3048 dump_generic_node (pp, OMP_FOR_PRE_BODY (node), 3063 dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3049 spc, flags, false); 3064 spc, flags, false);
3052 { 3067 {
3053 spc -= 2; 3068 spc -= 2;
3054 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++) 3069 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3055 { 3070 {
3056 spc += 2; 3071 spc += 2;
3057 if (TREE_CODE (node) != CILK_FOR || OMP_FOR_PRE_BODY (node)) 3072 newline_and_indent (pp, spc);
3058 newline_and_indent (pp, spc); 3073 pp_string (pp, "for (");
3059 if (TREE_CODE (node) == CILK_FOR)
3060 pp_string (pp, "_Cilk_for (");
3061 else
3062 pp_string (pp, "for (");
3063 dump_generic_node (pp, 3074 dump_generic_node (pp,
3064 TREE_VEC_ELT (OMP_FOR_INIT (node), i), 3075 TREE_VEC_ELT (OMP_FOR_INIT (node), i),
3065 spc, flags, false); 3076 spc, flags, false);
3066 pp_string (pp, "; "); 3077 pp_string (pp, "; ");
3067 dump_generic_node (pp, 3078 dump_generic_node (pp,
3071 dump_generic_node (pp, 3082 dump_generic_node (pp,
3072 TREE_VEC_ELT (OMP_FOR_INCR (node), i), 3083 TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3073 spc, flags, false); 3084 spc, flags, false);
3074 pp_right_paren (pp); 3085 pp_right_paren (pp);
3075 } 3086 }
3076 if (TREE_CODE (node) == CILK_FOR)
3077 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3078 } 3087 }
3079 if (OMP_FOR_BODY (node)) 3088 if (OMP_FOR_BODY (node))
3080 { 3089 {
3081 newline_and_indent (pp, spc + 2); 3090 newline_and_indent (pp, spc + 2);
3082 pp_left_brace (pp); 3091 pp_left_brace (pp);
3195 pp_right_brace (pp); 3204 pp_right_brace (pp);
3196 } 3205 }
3197 is_expr = false; 3206 is_expr = false;
3198 break; 3207 break;
3199 3208
3200 case REDUC_MAX_EXPR: 3209 case VEC_SERIES_EXPR:
3201 pp_string (pp, " REDUC_MAX_EXPR < ");
3202 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3203 pp_string (pp, " > ");
3204 break;
3205
3206 case REDUC_MIN_EXPR:
3207 pp_string (pp, " REDUC_MIN_EXPR < ");
3208 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3209 pp_string (pp, " > ");
3210 break;
3211
3212 case REDUC_PLUS_EXPR:
3213 pp_string (pp, " REDUC_PLUS_EXPR < ");
3214 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3215 pp_string (pp, " > ");
3216 break;
3217
3218 case VEC_WIDEN_MULT_HI_EXPR: 3210 case VEC_WIDEN_MULT_HI_EXPR:
3219 case VEC_WIDEN_MULT_LO_EXPR: 3211 case VEC_WIDEN_MULT_LO_EXPR:
3220 case VEC_WIDEN_MULT_EVEN_EXPR: 3212 case VEC_WIDEN_MULT_EVEN_EXPR:
3221 case VEC_WIDEN_MULT_ODD_EXPR: 3213 case VEC_WIDEN_MULT_ODD_EXPR:
3222 case VEC_WIDEN_LSHIFT_HI_EXPR: 3214 case VEC_WIDEN_LSHIFT_HI_EXPR:
3229 pp_string (pp, ", "); 3221 pp_string (pp, ", ");
3230 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); 3222 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3231 pp_string (pp, " > "); 3223 pp_string (pp, " > ");
3232 break; 3224 break;
3233 3225
3226 case VEC_DUPLICATE_EXPR:
3227 pp_space (pp);
3228 for (str = get_tree_code_name (code); *str; str++)
3229 pp_character (pp, TOUPPER (*str));
3230 pp_string (pp, " < ");
3231 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3232 pp_string (pp, " > ");
3233 break;
3234
3234 case VEC_UNPACK_HI_EXPR: 3235 case VEC_UNPACK_HI_EXPR:
3235 pp_string (pp, " VEC_UNPACK_HI_EXPR < "); 3236 pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3236 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 3237 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3237 pp_string (pp, " > "); 3238 pp_string (pp, " > ");
3238 break; 3239 break;
3249 pp_string (pp, " > "); 3250 pp_string (pp, " > ");
3250 break; 3251 break;
3251 3252
3252 case VEC_UNPACK_FLOAT_LO_EXPR: 3253 case VEC_UNPACK_FLOAT_LO_EXPR:
3253 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < "); 3254 pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3255 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3256 pp_string (pp, " > ");
3257 break;
3258
3259 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3260 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3261 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3262 pp_string (pp, " > ");
3263 break;
3264
3265 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3266 pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3254 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 3267 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3255 pp_string (pp, " > "); 3268 pp_string (pp, " > ");
3256 break; 3269 break;
3257 3270
3258 case VEC_PACK_TRUNC_EXPR: 3271 case VEC_PACK_TRUNC_EXPR:
3277 pp_string (pp, ", "); 3290 pp_string (pp, ", ");
3278 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); 3291 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3279 pp_string (pp, " > "); 3292 pp_string (pp, " > ");
3280 break; 3293 break;
3281 3294
3295 case VEC_PACK_FLOAT_EXPR:
3296 pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
3297 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3298 pp_string (pp, ", ");
3299 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3300 pp_string (pp, " > ");
3301 break;
3302
3282 case BLOCK: 3303 case BLOCK:
3283 dump_block_node (pp, node, spc, flags); 3304 dump_block_node (pp, node, spc, flags);
3284 break; 3305 break;
3285 3306
3286 case CILK_SPAWN_STMT: 3307 case DEBUG_BEGIN_STMT:
3287 pp_string (pp, "_Cilk_spawn "); 3308 pp_string (pp, "# DEBUG BEGIN STMT");
3288 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3289 break;
3290
3291 case CILK_SYNC_STMT:
3292 pp_string (pp, "_Cilk_sync");
3293 break; 3309 break;
3294 3310
3295 default: 3311 default:
3296 NIY; 3312 NIY;
3297 } 3313 }
3385 if (DECL_INITIAL (t)) 3401 if (DECL_INITIAL (t))
3386 { 3402 {
3387 pp_space (pp); 3403 pp_space (pp);
3388 pp_equal (pp); 3404 pp_equal (pp);
3389 pp_space (pp); 3405 pp_space (pp);
3390 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false); 3406 if (!(flags & TDF_SLIM))
3407 dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3408 else
3409 pp_string (pp, "<<< omitted >>>");
3391 } 3410 }
3392 } 3411 }
3393 3412
3394 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t)) 3413 if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
3395 { 3414 {
3417 pp_string (pp, "struct "); 3436 pp_string (pp, "struct ");
3418 else if ((TREE_CODE (node) == UNION_TYPE 3437 else if ((TREE_CODE (node) == UNION_TYPE
3419 || TREE_CODE (node) == QUAL_UNION_TYPE)) 3438 || TREE_CODE (node) == QUAL_UNION_TYPE))
3420 pp_string (pp, "union "); 3439 pp_string (pp, "union ");
3421 3440
3422 dump_generic_node (pp, TYPE_NAME (node), spc, 0, false); 3441 dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
3423 } 3442 }
3424 3443
3425 /* Print the contents of the structure. */ 3444 /* Print the contents of the structure. */
3426 pp_newline (pp); 3445 pp_newline (pp);
3427 INDENT (spc); 3446 INDENT (spc);
3540 return 11; 3559 return 11;
3541 3560
3542 case WIDEN_SUM_EXPR: 3561 case WIDEN_SUM_EXPR:
3543 case PLUS_EXPR: 3562 case PLUS_EXPR:
3544 case POINTER_PLUS_EXPR: 3563 case POINTER_PLUS_EXPR:
3564 case POINTER_DIFF_EXPR:
3545 case MINUS_EXPR: 3565 case MINUS_EXPR:
3546 return 12; 3566 return 12;
3547 3567
3548 case VEC_WIDEN_MULT_HI_EXPR: 3568 case VEC_WIDEN_MULT_HI_EXPR:
3549 case VEC_WIDEN_MULT_LO_EXPR: 3569 case VEC_WIDEN_MULT_LO_EXPR:
3561 case EXACT_DIV_EXPR: 3581 case EXACT_DIV_EXPR:
3562 case TRUNC_MOD_EXPR: 3582 case TRUNC_MOD_EXPR:
3563 case CEIL_MOD_EXPR: 3583 case CEIL_MOD_EXPR:
3564 case FLOOR_MOD_EXPR: 3584 case FLOOR_MOD_EXPR:
3565 case ROUND_MOD_EXPR: 3585 case ROUND_MOD_EXPR:
3566 case FMA_EXPR:
3567 return 13; 3586 return 13;
3568 3587
3569 case TRUTH_NOT_EXPR: 3588 case TRUTH_NOT_EXPR:
3570 case BIT_NOT_EXPR: 3589 case BIT_NOT_EXPR:
3571 case POSTINCREMENT_EXPR: 3590 case POSTINCREMENT_EXPR:
3591 case MIN_EXPR: 3610 case MIN_EXPR:
3592 case MAX_EXPR: 3611 case MAX_EXPR:
3593 case ABS_EXPR: 3612 case ABS_EXPR:
3594 case REALPART_EXPR: 3613 case REALPART_EXPR:
3595 case IMAGPART_EXPR: 3614 case IMAGPART_EXPR:
3596 case REDUC_MAX_EXPR:
3597 case REDUC_MIN_EXPR:
3598 case REDUC_PLUS_EXPR:
3599 case VEC_UNPACK_HI_EXPR: 3615 case VEC_UNPACK_HI_EXPR:
3600 case VEC_UNPACK_LO_EXPR: 3616 case VEC_UNPACK_LO_EXPR:
3601 case VEC_UNPACK_FLOAT_HI_EXPR: 3617 case VEC_UNPACK_FLOAT_HI_EXPR:
3602 case VEC_UNPACK_FLOAT_LO_EXPR: 3618 case VEC_UNPACK_FLOAT_LO_EXPR:
3619 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3620 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3603 case VEC_PACK_TRUNC_EXPR: 3621 case VEC_PACK_TRUNC_EXPR:
3604 case VEC_PACK_SAT_EXPR: 3622 case VEC_PACK_SAT_EXPR:
3605 return 16; 3623 return 16;
3606 3624
3607 default: 3625 default:
3712 return "+"; 3730 return "+";
3713 3731
3714 case PLUS_EXPR: 3732 case PLUS_EXPR:
3715 return "+"; 3733 return "+";
3716 3734
3717 case REDUC_PLUS_EXPR:
3718 return "r+";
3719
3720 case WIDEN_SUM_EXPR: 3735 case WIDEN_SUM_EXPR:
3721 return "w+"; 3736 return "w+";
3722 3737
3723 case WIDEN_MULT_EXPR: 3738 case WIDEN_MULT_EXPR:
3724 return "w*"; 3739 return "w*";
3726 case MULT_HIGHPART_EXPR: 3741 case MULT_HIGHPART_EXPR:
3727 return "h*"; 3742 return "h*";
3728 3743
3729 case NEGATE_EXPR: 3744 case NEGATE_EXPR:
3730 case MINUS_EXPR: 3745 case MINUS_EXPR:
3746 case POINTER_DIFF_EXPR:
3731 return "-"; 3747 return "-";
3732 3748
3733 case BIT_NOT_EXPR: 3749 case BIT_NOT_EXPR:
3734 return "~"; 3750 return "~";
3735 3751
3857 default: 3873 default:
3858 NIY; 3874 NIY;
3859 } 3875 }
3860 } 3876 }
3861 3877
3862 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */ 3878 /* Print the first N characters in the array STR, replacing non-printable
3879 characters (including embedded nuls) with unambiguous escape sequences. */
3863 3880
3864 static void 3881 static void
3865 pretty_print_string (pretty_printer *pp, const char *str) 3882 pretty_print_string (pretty_printer *pp, const char *str, unsigned n)
3866 { 3883 {
3867 if (str == NULL) 3884 if (str == NULL)
3868 return; 3885 return;
3869 3886
3870 while (*str) 3887 for ( ; n; --n, ++str)
3871 { 3888 {
3872 switch (str[0]) 3889 switch (str[0])
3873 { 3890 {
3874 case '\b': 3891 case '\b':
3875 pp_string (pp, "\\b"); 3892 pp_string (pp, "\\b");
3905 3922
3906 case '\'': 3923 case '\'':
3907 pp_string (pp, "\\'"); 3924 pp_string (pp, "\\'");
3908 break; 3925 break;
3909 3926
3910 /* No need to handle \0; the loop terminates on \0. */
3911
3912 case '\1':
3913 pp_string (pp, "\\1");
3914 break;
3915
3916 case '\2':
3917 pp_string (pp, "\\2");
3918 break;
3919
3920 case '\3':
3921 pp_string (pp, "\\3");
3922 break;
3923
3924 case '\4':
3925 pp_string (pp, "\\4");
3926 break;
3927
3928 case '\5':
3929 pp_string (pp, "\\5");
3930 break;
3931
3932 case '\6':
3933 pp_string (pp, "\\6");
3934 break;
3935
3936 case '\7':
3937 pp_string (pp, "\\7");
3938 break;
3939
3940 default: 3927 default:
3941 if (!ISPRINT (str[0])) 3928 if (str[0] || n > 1)
3942 { 3929 {
3943 char buf[5]; 3930 if (!ISPRINT (str[0]))
3944 sprintf (buf, "\\x%x", (unsigned char)str[0]); 3931 {
3945 pp_string (pp, buf); 3932 char buf[5];
3933 sprintf (buf, "\\x%02x", (unsigned char)str[0]);
3934 pp_string (pp, buf);
3935 }
3936 else
3937 pp_character (pp, str[0]);
3938 break;
3946 } 3939 }
3947 else 3940 }
3948 pp_character (pp, str[0]);
3949 break;
3950 }
3951 str++;
3952 } 3941 }
3953 } 3942 }
3954 3943
3955 static void 3944 static void
3956 maybe_init_pretty_print (FILE *file) 3945 maybe_init_pretty_print (FILE *file)
3972 INDENT (spc); 3961 INDENT (spc);
3973 } 3962 }
3974 3963
3975 /* Handle the %K format for TEXT. Separate from default_tree_printer 3964 /* Handle the %K format for TEXT. Separate from default_tree_printer
3976 so it can also be used in front ends. 3965 so it can also be used in front ends.
3977 Argument is a statement from which EXPR_LOCATION and TREE_BLOCK will 3966 The location LOC and BLOCK are expected to be extracted by the caller
3978 be recorded. */ 3967 from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg). */
3979 3968
3980 void 3969 void
3981 percent_K_format (text_info *text, tree t) 3970 percent_K_format (text_info *text, location_t loc, tree block)
3982 { 3971 {
3983 text->set_location (0, EXPR_LOCATION (t), true); 3972 text->set_location (0, loc, SHOW_RANGE_WITH_CARET);
3984 gcc_assert (pp_ti_abstract_origin (text) != NULL); 3973 gcc_assert (pp_ti_abstract_origin (text) != NULL);
3985 tree block = TREE_BLOCK (t);
3986 *pp_ti_abstract_origin (text) = NULL; 3974 *pp_ti_abstract_origin (text) = NULL;
3987
3988 if (in_lto_p)
3989 {
3990 /* ??? LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3991 representing the outermost block of an inlined function.
3992 So walk the BLOCK tree until we hit such a scope. */
3993 while (block
3994 && TREE_CODE (block) == BLOCK)
3995 {
3996 if (inlined_function_outer_scope_p (block))
3997 {
3998 *pp_ti_abstract_origin (text) = block;
3999 break;
4000 }
4001 block = BLOCK_SUPERCONTEXT (block);
4002 }
4003 return;
4004 }
4005 3975
4006 while (block 3976 while (block
4007 && TREE_CODE (block) == BLOCK 3977 && TREE_CODE (block) == BLOCK
4008 && BLOCK_ABSTRACT_ORIGIN (block)) 3978 && BLOCK_ABSTRACT_ORIGIN (block))
4009 { 3979 {
4010 tree ao = BLOCK_ABSTRACT_ORIGIN (block); 3980 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
4011
4012 while (TREE_CODE (ao) == BLOCK
4013 && BLOCK_ABSTRACT_ORIGIN (ao)
4014 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
4015 ao = BLOCK_ABSTRACT_ORIGIN (ao);
4016
4017 if (TREE_CODE (ao) == FUNCTION_DECL) 3981 if (TREE_CODE (ao) == FUNCTION_DECL)
4018 { 3982 {
4019 *pp_ti_abstract_origin (text) = block; 3983 *pp_ti_abstract_origin (text) = block;
4020 break; 3984 break;
4021 } 3985 }
4060 dname, aname, fun->funcdef_no); 4024 dname, aname, fun->funcdef_no);
4061 if (!(flags & TDF_NOUID)) 4025 if (!(flags & TDF_NOUID))
4062 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl)); 4026 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4063 if (node) 4027 if (node)
4064 { 4028 {
4065 fprintf (dump_file, ", cgraph_uid=%d", node->uid); 4029 fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
4066 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order, 4030 fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4067 node->frequency == NODE_FREQUENCY_HOT 4031 node->frequency == NODE_FREQUENCY_HOT
4068 ? " (hot)" 4032 ? " (hot)"
4069 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED 4033 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4070 ? " (unlikely executed)" 4034 ? " (unlikely executed)"