Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple-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 GIMPLE statements and expressions. 1 /* Pretty formatting of GIMPLE statements and expressions.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc. 2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3 Contributed by Aldy Hernandez <aldyh@redhat.com> and 3 Contributed by Aldy Hernandez <aldyh@redhat.com> and
4 Diego Novillo <dnovillo@google.com> 4 Diego Novillo <dnovillo@google.com>
5 5
6 This file is part of GCC. 6 This file is part of GCC.
7 7
80 /* Return formatted string of a VALUE probability 80 /* Return formatted string of a VALUE probability
81 (biased by REG_BR_PROB_BASE). Returned string is allocated 81 (biased by REG_BR_PROB_BASE). Returned string is allocated
82 by xstrdup_for_dump. */ 82 by xstrdup_for_dump. */
83 83
84 static const char * 84 static const char *
85 dump_profile (int frequency, profile_count &count) 85 dump_profile (profile_count &count)
86 { 86 {
87 float minimum = 0.01f; 87 char *buf = NULL;
88 88 if (!count.initialized_p ())
89 gcc_assert (0 <= frequency && frequency <= REG_BR_PROB_BASE); 89 return "";
90 float fvalue = frequency * 100.0f / REG_BR_PROB_BASE; 90 if (count.ipa_p ())
91 if (fvalue < minimum && frequency > 0) 91 buf = xasprintf ("[count: %" PRId64 "]",
92 return "[0.01%]";
93
94 char *buf;
95 if (count.initialized_p ())
96 buf = xasprintf ("[%.2f%%] [count: %" PRId64 "]", fvalue,
97 count.to_gcov_type ()); 92 count.to_gcov_type ());
98 else 93 else if (count.initialized_p ())
99 buf = xasprintf ("[%.2f%%] [count: INV]", fvalue); 94 buf = xasprintf ("[local count: %" PRId64 "]",
95 count.to_gcov_type ());
100 96
101 const char *ret = xstrdup_for_dump (buf); 97 const char *ret = xstrdup_for_dump (buf);
102 free (buf); 98 free (buf);
103 99
104 return ret; 100 return ret;
155 } 151 }
156 152
157 DEBUG_FUNCTION void 153 DEBUG_FUNCTION void
158 debug (gimple &ref) 154 debug (gimple &ref)
159 { 155 {
160 print_gimple_stmt (stderr, &ref, 0, 0); 156 print_gimple_stmt (stderr, &ref, 0, TDF_NONE);
161 } 157 }
162 158
163 DEBUG_FUNCTION void 159 DEBUG_FUNCTION void
164 debug (gimple *ptr) 160 debug (gimple *ptr)
165 { 161 {
360 dump_generic_node (buffer, rhs, spc, flags, false); 356 dump_generic_node (buffer, rhs, spc, flags, false);
361 pp_string (buffer, "))"); 357 pp_string (buffer, "))");
362 break; 358 break;
363 359
364 case ABS_EXPR: 360 case ABS_EXPR:
361 case ABSU_EXPR:
365 if (flags & TDF_GIMPLE) 362 if (flags & TDF_GIMPLE)
366 { 363 {
367 pp_string (buffer, "__ABS "); 364 pp_string (buffer,
365 rhs_code == ABS_EXPR ? "__ABS " : "__ABSU ");
368 dump_generic_node (buffer, rhs, spc, flags, false); 366 dump_generic_node (buffer, rhs, spc, flags, false);
369 } 367 }
370 else 368 else
371 { 369 {
372 pp_string (buffer, "ABS_EXPR <"); 370 pp_string (buffer,
371 rhs_code == ABS_EXPR ? "ABS_EXPR <" : "ABSU_EXPR <");
373 dump_generic_node (buffer, rhs, spc, flags, false); 372 dump_generic_node (buffer, rhs, spc, flags, false);
374 pp_greater (buffer); 373 pp_greater (buffer);
375 } 374 }
376 break; 375 break;
377 376
431 case VEC_WIDEN_MULT_EVEN_EXPR: 430 case VEC_WIDEN_MULT_EVEN_EXPR:
432 case VEC_WIDEN_MULT_ODD_EXPR: 431 case VEC_WIDEN_MULT_ODD_EXPR:
433 case VEC_PACK_TRUNC_EXPR: 432 case VEC_PACK_TRUNC_EXPR:
434 case VEC_PACK_SAT_EXPR: 433 case VEC_PACK_SAT_EXPR:
435 case VEC_PACK_FIX_TRUNC_EXPR: 434 case VEC_PACK_FIX_TRUNC_EXPR:
435 case VEC_PACK_FLOAT_EXPR:
436 case VEC_WIDEN_LSHIFT_HI_EXPR: 436 case VEC_WIDEN_LSHIFT_HI_EXPR:
437 case VEC_WIDEN_LSHIFT_LO_EXPR: 437 case VEC_WIDEN_LSHIFT_LO_EXPR:
438 case VEC_SERIES_EXPR:
438 for (p = get_tree_code_name (code); *p; p++) 439 for (p = get_tree_code_name (code); *p; p++)
439 pp_character (buffer, TOUPPER (*p)); 440 pp_character (buffer, TOUPPER (*p));
440 pp_string (buffer, " <"); 441 pp_string (buffer, " <");
441 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 442 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
442 pp_string (buffer, ", "); 443 pp_string (buffer, ", ");
489 pp_string (buffer, ", "); 490 pp_string (buffer, ", ");
490 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 491 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
491 pp_string (buffer, ", "); 492 pp_string (buffer, ", ");
492 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 493 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
493 pp_greater (buffer); 494 pp_greater (buffer);
494 break;
495
496 case FMA_EXPR:
497 if (flags & TDF_GIMPLE)
498 {
499 pp_string (buffer, "__FMA (");
500 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
501 pp_comma (buffer);
502 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
503 pp_comma (buffer);
504 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
505 pp_right_paren (buffer);
506 }
507 else
508 {
509 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
510 pp_string (buffer, " * ");
511 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
512 pp_string (buffer, " + ");
513 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
514 }
515 break; 495 break;
516 496
517 case DOT_PROD_EXPR: 497 case DOT_PROD_EXPR:
518 pp_string (buffer, "DOT_PROD_EXPR <"); 498 pp_string (buffer, "DOT_PROD_EXPR <");
519 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 499 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
663 643
664 static void 644 static void
665 dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc, 645 dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc,
666 dump_flags_t flags) 646 dump_flags_t flags)
667 { 647 {
668 tree t, t2; 648 tree t;
669 649
670 t = gimple_return_retval (gs); 650 t = gimple_return_retval (gs);
671 t2 = gimple_return_retbnd (gs); 651 if (flags & TDF_RAW)
672 if (flags & TDF_RAW) 652 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
673 dump_gimple_fmt (buffer, spc, flags, "%G <%T %T>", gs, t, t2);
674 else 653 else
675 { 654 {
676 pp_string (buffer, "return"); 655 pp_string (buffer, "return");
677 if (t) 656 if (t)
678 { 657 {
679 pp_space (buffer); 658 pp_space (buffer);
680 dump_generic_node (buffer, t, spc, flags, false); 659 dump_generic_node (buffer, t, spc, flags, false);
681 }
682 if (t2)
683 {
684 pp_string (buffer, ", ");
685 dump_generic_node (buffer, t2, spc, flags, false);
686 } 660 }
687 pp_semicolon (buffer); 661 pp_semicolon (buffer);
688 } 662 }
689 } 663 }
690 664
875 } 849 }
876 850
877 if (flags & TDF_RAW) 851 if (flags & TDF_RAW)
878 { 852 {
879 if (gimple_call_internal_p (gs)) 853 if (gimple_call_internal_p (gs))
880 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs, 854 dump_gimple_fmt (buffer, spc, flags, "%G <.%s, %T", gs,
881 internal_fn_name (gimple_call_internal_fn (gs)), lhs); 855 internal_fn_name (gimple_call_internal_fn (gs)), lhs);
882 else 856 else
883 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs); 857 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs);
884 if (gimple_call_num_args (gs) > 0) 858 if (gimple_call_num_args (gs) > 0)
885 { 859 {
899 pp_string (buffer, "{v}"); 873 pp_string (buffer, "{v}");
900 874
901 pp_space (buffer); 875 pp_space (buffer);
902 } 876 }
903 if (gimple_call_internal_p (gs)) 877 if (gimple_call_internal_p (gs))
904 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs))); 878 {
879 pp_dot (buffer);
880 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
881 }
905 else 882 else
906 print_call_name (buffer, fn, flags); 883 print_call_name (buffer, fn, flags);
907 pp_string (buffer, " ("); 884 pp_string (buffer, " (");
908 dump_gimple_call_args (buffer, gs, flags); 885 dump_gimple_call_args (buffer, gs, flags);
909 pp_right_paren (buffer); 886 pp_right_paren (buffer);
932 if (TREE_CODE (fn) == ADDR_EXPR) 909 if (TREE_CODE (fn) == ADDR_EXPR)
933 fn = TREE_OPERAND (fn, 0); 910 fn = TREE_OPERAND (fn, 0);
934 if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn)) 911 if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn))
935 pp_string (buffer, " [tm-clone]"); 912 pp_string (buffer, " [tm-clone]");
936 if (TREE_CODE (fn) == FUNCTION_DECL 913 if (TREE_CODE (fn) == FUNCTION_DECL
937 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL 914 && fndecl_built_in_p (fn, BUILT_IN_TM_START)
938 && DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_START
939 && gimple_call_num_args (gs) > 0) 915 && gimple_call_num_args (gs) > 0)
940 { 916 {
941 tree t = gimple_call_arg (gs, 0); 917 tree t = gimple_call_arg (gs, 0);
942 unsigned HOST_WIDE_INT props; 918 unsigned HOST_WIDE_INT props;
943 gcc_assert (TREE_CODE (t) == INTEGER_CST); 919 gcc_assert (TREE_CODE (t) == INTEGER_CST);
1013 tree label = CASE_LABEL (case_label); 989 tree label = CASE_LABEL (case_label);
1014 dump_generic_node (buffer, label, spc, flags, false); 990 dump_generic_node (buffer, label, spc, flags, false);
1015 991
1016 if (cfun && cfun->cfg) 992 if (cfun && cfun->cfg)
1017 { 993 {
1018 basic_block dest = label_to_block (label); 994 basic_block dest = label_to_block (cfun, label);
1019 if (dest) 995 if (dest)
1020 { 996 {
1021 edge label_edge = find_edge (gimple_bb (gs), dest); 997 edge label_edge = find_edge (gimple_bb (gs), dest);
1022 if (label_edge && !(flags & TDF_GIMPLE)) 998 if (label_edge && !(flags & TDF_GIMPLE))
1023 dump_edge_probability (buffer, label_edge); 999 dump_edge_probability (buffer, label_edge);
1365 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T", 1341 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T",
1366 gimple_debug_source_bind_get_var (gs), 1342 gimple_debug_source_bind_get_var (gs),
1367 gimple_debug_source_bind_get_value (gs)); 1343 gimple_debug_source_bind_get_value (gs));
1368 break; 1344 break;
1369 1345
1346 case GIMPLE_DEBUG_BEGIN_STMT:
1347 if (flags & TDF_RAW)
1348 dump_gimple_fmt (buffer, spc, flags, "%G BEGIN_STMT", gs);
1349 else
1350 dump_gimple_fmt (buffer, spc, flags, "# DEBUG BEGIN_STMT");
1351 break;
1352
1353 case GIMPLE_DEBUG_INLINE_ENTRY:
1354 if (flags & TDF_RAW)
1355 dump_gimple_fmt (buffer, spc, flags, "%G INLINE_ENTRY %T", gs,
1356 gimple_block (gs)
1357 ? block_ultimate_origin (gimple_block (gs))
1358 : NULL_TREE);
1359 else
1360 dump_gimple_fmt (buffer, spc, flags, "# DEBUG INLINE_ENTRY %T",
1361 gimple_block (gs)
1362 ? block_ultimate_origin (gimple_block (gs))
1363 : NULL_TREE);
1364 break;
1365
1370 default: 1366 default:
1371 gcc_unreachable (); 1367 gcc_unreachable ();
1372 } 1368 }
1373 } 1369 }
1374 1370
1391 kind = " distribute"; 1387 kind = " distribute";
1392 break; 1388 break;
1393 case GF_OMP_FOR_KIND_TASKLOOP: 1389 case GF_OMP_FOR_KIND_TASKLOOP:
1394 kind = " taskloop"; 1390 kind = " taskloop";
1395 break; 1391 break;
1396 case GF_OMP_FOR_KIND_CILKFOR:
1397 kind = " _Cilk_for";
1398 break;
1399 case GF_OMP_FOR_KIND_OACC_LOOP: 1392 case GF_OMP_FOR_KIND_OACC_LOOP:
1400 kind = " oacc_loop"; 1393 kind = " oacc_loop";
1401 break; 1394 break;
1402 case GF_OMP_FOR_KIND_SIMD: 1395 case GF_OMP_FOR_KIND_SIMD:
1403 kind = " simd"; 1396 kind = " simd";
1404 break;
1405 case GF_OMP_FOR_KIND_CILKSIMD:
1406 kind = " cilksimd";
1407 break; 1397 break;
1408 default: 1398 default:
1409 gcc_unreachable (); 1399 gcc_unreachable ();
1410 } 1400 }
1411 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, 1401 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1434 pp_string (buffer, "#pragma omp distribute"); 1424 pp_string (buffer, "#pragma omp distribute");
1435 break; 1425 break;
1436 case GF_OMP_FOR_KIND_TASKLOOP: 1426 case GF_OMP_FOR_KIND_TASKLOOP:
1437 pp_string (buffer, "#pragma omp taskloop"); 1427 pp_string (buffer, "#pragma omp taskloop");
1438 break; 1428 break;
1439 case GF_OMP_FOR_KIND_CILKFOR:
1440 break;
1441 case GF_OMP_FOR_KIND_OACC_LOOP: 1429 case GF_OMP_FOR_KIND_OACC_LOOP:
1442 pp_string (buffer, "#pragma acc loop"); 1430 pp_string (buffer, "#pragma acc loop");
1443 break; 1431 break;
1444 case GF_OMP_FOR_KIND_SIMD: 1432 case GF_OMP_FOR_KIND_SIMD:
1445 pp_string (buffer, "#pragma omp simd"); 1433 pp_string (buffer, "#pragma omp simd");
1446 break; 1434 break;
1447 case GF_OMP_FOR_KIND_CILKSIMD:
1448 pp_string (buffer, "#pragma simd");
1449 break;
1450 case GF_OMP_FOR_KIND_GRID_LOOP: 1435 case GF_OMP_FOR_KIND_GRID_LOOP:
1451 pp_string (buffer, "#pragma omp for grid_loop"); 1436 pp_string (buffer, "#pragma omp for grid_loop");
1452 break; 1437 break;
1453 default: 1438 default:
1454 gcc_unreachable (); 1439 gcc_unreachable ();
1455 } 1440 }
1456 if (gimple_omp_for_kind (gs) != GF_OMP_FOR_KIND_CILKFOR) 1441 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1457 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1458 for (i = 0; i < gimple_omp_for_collapse (gs); i++) 1442 for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1459 { 1443 {
1460 if (i) 1444 if (i)
1461 spc += 2; 1445 spc += 2;
1462 if (gimple_omp_for_kind (gs) == GF_OMP_FOR_KIND_CILKFOR) 1446 newline_and_indent (buffer, spc);
1463 pp_string (buffer, "_Cilk_for ("); 1447 pp_string (buffer, "for (");
1464 else
1465 {
1466 newline_and_indent (buffer, spc);
1467 pp_string (buffer, "for (");
1468 }
1469 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, 1448 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1470 flags, false); 1449 flags, false);
1471 pp_string (buffer, " = "); 1450 pp_string (buffer, " = ");
1472 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc, 1451 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc,
1473 flags, false); 1452 flags, false);
1509 pp_right_paren (buffer); 1488 pp_right_paren (buffer);
1510 } 1489 }
1511 1490
1512 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1491 if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1513 { 1492 {
1514 if (gimple_omp_for_kind (gs) == GF_OMP_FOR_KIND_CILKFOR)
1515 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1516 newline_and_indent (buffer, spc + 2); 1493 newline_and_indent (buffer, spc + 2);
1517 pp_left_brace (buffer); 1494 pp_left_brace (buffer);
1518 pp_newline (buffer); 1495 pp_newline (buffer);
1519 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1496 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1520 newline_and_indent (buffer, spc + 2); 1497 newline_and_indent (buffer, spc + 2);
2144 2121
2145 if (!POINTER_TYPE_P (TREE_TYPE (node)) 2122 if (!POINTER_TYPE_P (TREE_TYPE (node))
2146 && SSA_NAME_RANGE_INFO (node)) 2123 && SSA_NAME_RANGE_INFO (node))
2147 { 2124 {
2148 wide_int min, max, nonzero_bits; 2125 wide_int min, max, nonzero_bits;
2149 value_range_type range_type = get_range_info (node, &min, &max); 2126 value_range_kind range_type = get_range_info (node, &min, &max);
2150 2127
2151 if (range_type == VR_VARYING) 2128 if (range_type == VR_VARYING)
2152 pp_printf (buffer, "# RANGE VR_VARYING"); 2129 pp_printf (buffer, "# RANGE VR_VARYING");
2153 else if (range_type == VR_RANGE || range_type == VR_ANTI_RANGE) 2130 else if (range_type == VR_RANGE || range_type == VR_ANTI_RANGE)
2154 { 2131 {
2693 { 2670 {
2694 if (flags & TDF_GIMPLE) 2671 if (flags & TDF_GIMPLE)
2695 fprintf (outf, "%*sbb_%d:\n", indent, "", bb->index); 2672 fprintf (outf, "%*sbb_%d:\n", indent, "", bb->index);
2696 else 2673 else
2697 fprintf (outf, "%*s<bb %d> %s:\n", 2674 fprintf (outf, "%*s<bb %d> %s:\n",
2698 indent, "", bb->index, dump_profile (bb->frequency, 2675 indent, "", bb->index, dump_profile (bb->count));
2699 bb->count));
2700 } 2676 }
2701 } 2677 }
2702 2678
2703 2679
2704 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT 2680 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2908 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); 2884 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2909 } 2885 }
2910 2886
2911 2887
2912 /* Handle the %G format for TEXT. Same as %K in handle_K_format in 2888 /* Handle the %G format for TEXT. Same as %K in handle_K_format in
2913 tree-pretty-print.c but with a Gimple call statement as an argument. */ 2889 tree-pretty-print.c but with a Gimple statement as an argument. */
2914 2890
2915 void 2891 void
2916 percent_G_format (text_info *text) 2892 percent_G_format (text_info *text)
2917 { 2893 {
2918 gcall *stmt = va_arg (*text->args_ptr, gcall*); 2894 gimple *stmt = va_arg (*text->args_ptr, gimple*);
2919 2895
2920 /* Build a call expression from the Gimple call statement and 2896 tree block = gimple_block (stmt);
2921 pass it to the K formatter that knows how to format it. */ 2897 percent_K_format (text, gimple_location (stmt), block);
2922 tree exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3); 2898 }
2923 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2924 TREE_TYPE (exp) = gimple_call_return_type (stmt);
2925 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2926 SET_EXPR_LOCATION (exp, gimple_location (stmt));
2927
2928 percent_K_format (text, exp);
2929 }