Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-pretty-print.c @ 145:1830386684a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc-9.2.0
author anatofuz
date Thu, 13 Feb 2020 11:34:05 +0900
parents 84e7813d76e9
children
comparison
equal deleted inserted replaced
131:84e7813d76e9 145:1830386684a0
1 /* Pretty formatting of GENERIC trees in C syntax. 1 /* Pretty formatting of GENERIC trees in C syntax.
2 Copyright (C) 2001-2018 Free Software Foundation, Inc. 2 Copyright (C) 2001-2020 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
32 #include "tree-iterator.h" 32 #include "tree-iterator.h"
33 #include "dumpfile.h" 33 #include "dumpfile.h"
34 #include "internal-fn.h" 34 #include "internal-fn.h"
35 #include "gomp-constants.h" 35 #include "gomp-constants.h"
36 #include "gimple.h" 36 #include "gimple.h"
37 #include "fold-const.h"
38
39 /* Disable warnings about quoting issues in the pp_xxx calls below
40 that (intentionally) don't follow GCC diagnostic conventions. */
41 #if __GNUC__ >= 10
42 # pragma GCC diagnostic push
43 # pragma GCC diagnostic ignored "-Wformat-diag"
44 #endif
37 45
38 /* Local functions, macros and variables. */ 46 /* Local functions, macros and variables. */
39 static const char *op_symbol (const_tree); 47 static const char *op_symbol (const_tree);
40 static void pretty_print_string (pretty_printer *, const char*, unsigned); 48 static void pretty_print_string (pretty_printer *, const char*, unsigned);
41 static void newline_and_indent (pretty_printer *, int); 49 static void newline_and_indent (pretty_printer *, int);
390 pp_string (pp, "<unknown>"); 398 pp_string (pp, "<unknown>");
391 pp_right_bracket (pp); 399 pp_right_bracket (pp);
392 } 400 }
393 401
394 402
403 /* Dump OpenMP iterators ITER. */
404
405 static void
406 dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags)
407 {
408 pp_string (pp, "iterator(");
409 for (tree it = iter; it; it = TREE_CHAIN (it))
410 {
411 if (it != iter)
412 pp_string (pp, ", ");
413 dump_generic_node (pp, TREE_TYPE (TREE_VEC_ELT (it, 0)), spc, flags,
414 false);
415 pp_space (pp);
416 dump_generic_node (pp, TREE_VEC_ELT (it, 0), spc, flags, false);
417 pp_equal (pp);
418 dump_generic_node (pp, TREE_VEC_ELT (it, 1), spc, flags, false);
419 pp_colon (pp);
420 dump_generic_node (pp, TREE_VEC_ELT (it, 2), spc, flags, false);
421 pp_colon (pp);
422 dump_generic_node (pp, TREE_VEC_ELT (it, 3), spc, flags, false);
423 }
424 pp_right_paren (pp);
425 }
426
427
395 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in 428 /* Dump OpenMP clause CLAUSE. PP, CLAUSE, SPC and FLAGS are as in
396 dump_generic_node. */ 429 dump_generic_node. */
397 430
398 static void 431 static void
399 dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags) 432 dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
400 { 433 {
401 const char *name; 434 const char *name;
402 435 const char *modifier = NULL;
403 switch (OMP_CLAUSE_CODE (clause)) 436 switch (OMP_CLAUSE_CODE (clause))
404 { 437 {
405 case OMP_CLAUSE_PRIVATE: 438 case OMP_CLAUSE_PRIVATE:
406 name = "private"; 439 name = "private";
407 goto print_remap; 440 goto print_remap;
411 case OMP_CLAUSE_FIRSTPRIVATE: 444 case OMP_CLAUSE_FIRSTPRIVATE:
412 name = "firstprivate"; 445 name = "firstprivate";
413 goto print_remap; 446 goto print_remap;
414 case OMP_CLAUSE_LASTPRIVATE: 447 case OMP_CLAUSE_LASTPRIVATE:
415 name = "lastprivate"; 448 name = "lastprivate";
449 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause))
450 modifier = "conditional:";
416 goto print_remap; 451 goto print_remap;
417 case OMP_CLAUSE_COPYIN: 452 case OMP_CLAUSE_COPYIN:
418 name = "copyin"; 453 name = "copyin";
419 goto print_remap; 454 goto print_remap;
420 case OMP_CLAUSE_COPYPRIVATE: 455 case OMP_CLAUSE_COPYPRIVATE:
423 case OMP_CLAUSE_UNIFORM: 458 case OMP_CLAUSE_UNIFORM:
424 name = "uniform"; 459 name = "uniform";
425 goto print_remap; 460 goto print_remap;
426 case OMP_CLAUSE_USE_DEVICE_PTR: 461 case OMP_CLAUSE_USE_DEVICE_PTR:
427 name = "use_device_ptr"; 462 name = "use_device_ptr";
463 if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause))
464 modifier = "if_present:";
465 goto print_remap;
466 case OMP_CLAUSE_USE_DEVICE_ADDR:
467 name = "use_device_addr";
428 goto print_remap; 468 goto print_remap;
429 case OMP_CLAUSE_IS_DEVICE_PTR: 469 case OMP_CLAUSE_IS_DEVICE_PTR:
430 name = "is_device_ptr"; 470 name = "is_device_ptr";
431 goto print_remap; 471 goto print_remap;
472 case OMP_CLAUSE_INCLUSIVE:
473 name = "inclusive";
474 goto print_remap;
475 case OMP_CLAUSE_EXCLUSIVE:
476 name = "exclusive";
477 goto print_remap;
432 case OMP_CLAUSE__LOOPTEMP_: 478 case OMP_CLAUSE__LOOPTEMP_:
433 name = "_looptemp_"; 479 name = "_looptemp_";
480 goto print_remap;
481 case OMP_CLAUSE__REDUCTEMP_:
482 name = "_reductemp_";
483 goto print_remap;
484 case OMP_CLAUSE__CONDTEMP_:
485 name = "_condtemp_";
486 goto print_remap;
487 case OMP_CLAUSE__SCANTEMP_:
488 name = "_scantemp_";
434 goto print_remap; 489 goto print_remap;
435 case OMP_CLAUSE_TO_DECLARE: 490 case OMP_CLAUSE_TO_DECLARE:
436 name = "to"; 491 name = "to";
437 goto print_remap; 492 goto print_remap;
438 case OMP_CLAUSE_LINK: 493 case OMP_CLAUSE_LINK:
439 name = "link"; 494 name = "link";
440 goto print_remap; 495 goto print_remap;
496 case OMP_CLAUSE_NONTEMPORAL:
497 name = "nontemporal";
498 goto print_remap;
441 print_remap: 499 print_remap:
442 pp_string (pp, name); 500 pp_string (pp, name);
443 pp_left_paren (pp); 501 pp_left_paren (pp);
502 if (modifier)
503 pp_string (pp, modifier);
444 dump_generic_node (pp, OMP_CLAUSE_DECL (clause), 504 dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
445 spc, flags, false); 505 spc, flags, false);
446 pp_right_paren (pp); 506 pp_right_paren (pp);
447 break; 507 break;
448 508
509 case OMP_CLAUSE_TASK_REDUCTION:
510 case OMP_CLAUSE_IN_REDUCTION:
511 pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION
512 ? "in_" : "task_");
513 /* FALLTHRU */
449 case OMP_CLAUSE_REDUCTION: 514 case OMP_CLAUSE_REDUCTION:
450 pp_string (pp, "reduction("); 515 pp_string (pp, "reduction(");
516 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
517 {
518 if (OMP_CLAUSE_REDUCTION_TASK (clause))
519 pp_string (pp, "task,");
520 else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
521 pp_string (pp, "inscan,");
522 }
451 if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK) 523 if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
452 { 524 {
453 pp_string (pp, 525 pp_string (pp,
454 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); 526 op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
455 pp_colon (pp); 527 pp_colon (pp);
462 case OMP_CLAUSE_IF: 534 case OMP_CLAUSE_IF:
463 pp_string (pp, "if("); 535 pp_string (pp, "if(");
464 switch (OMP_CLAUSE_IF_MODIFIER (clause)) 536 switch (OMP_CLAUSE_IF_MODIFIER (clause))
465 { 537 {
466 case ERROR_MARK: break; 538 case ERROR_MARK: break;
539 case VOID_CST: pp_string (pp, "cancel:"); break;
467 case OMP_PARALLEL: pp_string (pp, "parallel:"); break; 540 case OMP_PARALLEL: pp_string (pp, "parallel:"); break;
541 case OMP_SIMD: pp_string (pp, "simd:"); break;
468 case OMP_TASK: pp_string (pp, "task:"); break; 542 case OMP_TASK: pp_string (pp, "task:"); break;
469 case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break; 543 case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break;
470 case OMP_TARGET_DATA: pp_string (pp, "target data:"); break; 544 case OMP_TARGET_DATA: pp_string (pp, "target data:"); break;
471 case OMP_TARGET: pp_string (pp, "target:"); break; 545 case OMP_TARGET: pp_string (pp, "target:"); break;
472 case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break; 546 case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break;
641 715
642 case OMP_CLAUSE_DEPEND: 716 case OMP_CLAUSE_DEPEND:
643 pp_string (pp, "depend("); 717 pp_string (pp, "depend(");
644 switch (OMP_CLAUSE_DEPEND_KIND (clause)) 718 switch (OMP_CLAUSE_DEPEND_KIND (clause))
645 { 719 {
720 case OMP_CLAUSE_DEPEND_DEPOBJ:
721 name = "depobj";
722 break;
646 case OMP_CLAUSE_DEPEND_IN: 723 case OMP_CLAUSE_DEPEND_IN:
647 pp_string (pp, "in"); 724 name = "in";
648 break; 725 break;
649 case OMP_CLAUSE_DEPEND_OUT: 726 case OMP_CLAUSE_DEPEND_OUT:
650 pp_string (pp, "out"); 727 name = "out";
651 break; 728 break;
652 case OMP_CLAUSE_DEPEND_INOUT: 729 case OMP_CLAUSE_DEPEND_INOUT:
653 pp_string (pp, "inout"); 730 name = "inout";
731 break;
732 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
733 name = "mutexinoutset";
654 break; 734 break;
655 case OMP_CLAUSE_DEPEND_SOURCE: 735 case OMP_CLAUSE_DEPEND_SOURCE:
656 pp_string (pp, "source)"); 736 pp_string (pp, "source)");
657 return; 737 return;
738 case OMP_CLAUSE_DEPEND_LAST:
739 name = "__internal__";
740 break;
658 case OMP_CLAUSE_DEPEND_SINK: 741 case OMP_CLAUSE_DEPEND_SINK:
659 pp_string (pp, "sink:"); 742 pp_string (pp, "sink:");
660 for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t)) 743 for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t))
661 if (TREE_CODE (t) == TREE_LIST) 744 if (TREE_CODE (t) == TREE_LIST)
662 { 745 {
678 pp_right_paren (pp); 761 pp_right_paren (pp);
679 return; 762 return;
680 default: 763 default:
681 gcc_unreachable (); 764 gcc_unreachable ();
682 } 765 }
683 pp_colon (pp); 766 {
684 dump_generic_node (pp, OMP_CLAUSE_DECL (clause), 767 tree t = OMP_CLAUSE_DECL (clause);
685 spc, flags, false); 768 if (TREE_CODE (t) == TREE_LIST
686 pp_right_paren (pp); 769 && TREE_PURPOSE (t)
770 && TREE_CODE (TREE_PURPOSE (t)) == TREE_VEC)
771 {
772 dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
773 pp_colon (pp);
774 t = TREE_VALUE (t);
775 }
776 pp_string (pp, name);
777 pp_colon (pp);
778 dump_generic_node (pp, t, spc, flags, false);
779 pp_right_paren (pp);
780 }
687 break; 781 break;
688 782
689 case OMP_CLAUSE_MAP: 783 case OMP_CLAUSE_MAP:
690 pp_string (pp, "map("); 784 pp_string (pp, "map(");
691 switch (OMP_CLAUSE_MAP_KIND (clause)) 785 switch (OMP_CLAUSE_MAP_KIND (clause))
692 { 786 {
693 case GOMP_MAP_ALLOC: 787 case GOMP_MAP_ALLOC:
694 case GOMP_MAP_POINTER: 788 case GOMP_MAP_POINTER:
695 pp_string (pp, "alloc"); 789 pp_string (pp, "alloc");
696 break; 790 break;
791 case GOMP_MAP_IF_PRESENT:
792 pp_string (pp, "no_alloc");
793 break;
697 case GOMP_MAP_TO: 794 case GOMP_MAP_TO:
698 case GOMP_MAP_TO_PSET: 795 case GOMP_MAP_TO_PSET:
699 pp_string (pp, "to"); 796 pp_string (pp, "to");
700 break; 797 break;
701 case GOMP_MAP_FROM: 798 case GOMP_MAP_FROM:
752 case GOMP_MAP_DEVICE_RESIDENT: 849 case GOMP_MAP_DEVICE_RESIDENT:
753 pp_string (pp, "device_resident"); 850 pp_string (pp, "device_resident");
754 break; 851 break;
755 case GOMP_MAP_LINK: 852 case GOMP_MAP_LINK:
756 pp_string (pp, "link"); 853 pp_string (pp, "link");
854 break;
855 case GOMP_MAP_ATTACH:
856 pp_string (pp, "attach");
857 break;
858 case GOMP_MAP_DETACH:
859 pp_string (pp, "detach");
860 break;
861 case GOMP_MAP_FORCE_DETACH:
862 pp_string (pp, "force_detach");
863 break;
864 case GOMP_MAP_ATTACH_DETACH:
865 pp_string (pp, "attach_detach");
757 break; 866 break;
758 default: 867 default:
759 gcc_unreachable (); 868 gcc_unreachable ();
760 } 869 }
761 pp_colon (pp); 870 pp_colon (pp);
774 pp_string (pp, " [pointer assign, bias: "); 883 pp_string (pp, " [pointer assign, bias: ");
775 break; 884 break;
776 case GOMP_MAP_TO_PSET: 885 case GOMP_MAP_TO_PSET:
777 pp_string (pp, " [pointer set, len: "); 886 pp_string (pp, " [pointer set, len: ");
778 break; 887 break;
888 case GOMP_MAP_ATTACH:
889 case GOMP_MAP_DETACH:
890 case GOMP_MAP_FORCE_DETACH:
891 case GOMP_MAP_ATTACH_DETACH:
892 pp_string (pp, " [bias: ");
893 break;
779 default: 894 default:
780 pp_string (pp, " [len: "); 895 pp_string (pp, " [len: ");
781 break; 896 break;
782 } 897 }
783 dump_generic_node (pp, OMP_CLAUSE_SIZE (clause), 898 dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
855 gcc_unreachable (); 970 gcc_unreachable ();
856 } 971 }
857 pp_right_paren (pp); 972 pp_right_paren (pp);
858 break; 973 break;
859 974
975 case OMP_CLAUSE_DEVICE_TYPE:
976 pp_string (pp, "device_type(");
977 switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause))
978 {
979 case OMP_CLAUSE_DEVICE_TYPE_HOST:
980 pp_string (pp, "host");
981 break;
982 case OMP_CLAUSE_DEVICE_TYPE_NOHOST:
983 pp_string (pp, "nohost");
984 break;
985 case OMP_CLAUSE_DEVICE_TYPE_ANY:
986 pp_string (pp, "any");
987 break;
988 default:
989 gcc_unreachable ();
990 }
991 pp_right_paren (pp);
992 break;
993
860 case OMP_CLAUSE_SAFELEN: 994 case OMP_CLAUSE_SAFELEN:
861 pp_string (pp, "safelen("); 995 pp_string (pp, "safelen(");
862 dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause), 996 dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
863 spc, flags, false); 997 spc, flags, false);
864 pp_right_paren (pp); 998 pp_right_paren (pp);
898 spc, flags, false); 1032 spc, flags, false);
899 pp_right_paren (pp); 1033 pp_right_paren (pp);
900 break; 1034 break;
901 1035
902 case OMP_CLAUSE_DEFAULTMAP: 1036 case OMP_CLAUSE_DEFAULTMAP:
903 pp_string (pp, "defaultmap(tofrom:scalar)"); 1037 pp_string (pp, "defaultmap(");
1038 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause))
1039 {
1040 case OMP_CLAUSE_DEFAULTMAP_ALLOC:
1041 pp_string (pp, "alloc");
1042 break;
1043 case OMP_CLAUSE_DEFAULTMAP_TO:
1044 pp_string (pp, "to");
1045 break;
1046 case OMP_CLAUSE_DEFAULTMAP_FROM:
1047 pp_string (pp, "from");
1048 break;
1049 case OMP_CLAUSE_DEFAULTMAP_TOFROM:
1050 pp_string (pp, "tofrom");
1051 break;
1052 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE:
1053 pp_string (pp, "firstprivate");
1054 break;
1055 case OMP_CLAUSE_DEFAULTMAP_NONE:
1056 pp_string (pp, "none");
1057 break;
1058 case OMP_CLAUSE_DEFAULTMAP_DEFAULT:
1059 pp_string (pp, "default");
1060 break;
1061 default:
1062 gcc_unreachable ();
1063 }
1064 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause))
1065 {
1066 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
1067 break;
1068 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
1069 pp_string (pp, ":scalar");
1070 break;
1071 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
1072 pp_string (pp, ":aggregate");
1073 break;
1074 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE:
1075 pp_string (pp, ":allocatable");
1076 break;
1077 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
1078 pp_string (pp, ":pointer");
1079 break;
1080 default:
1081 gcc_unreachable ();
1082 }
1083 pp_right_paren (pp);
1084 break;
1085
1086 case OMP_CLAUSE_ORDER:
1087 pp_string (pp, "order(concurrent)");
1088 break;
1089
1090 case OMP_CLAUSE_BIND:
1091 pp_string (pp, "bind(");
1092 switch (OMP_CLAUSE_BIND_KIND (clause))
1093 {
1094 case OMP_CLAUSE_BIND_TEAMS:
1095 pp_string (pp, "teams");
1096 break;
1097 case OMP_CLAUSE_BIND_PARALLEL:
1098 pp_string (pp, "parallel");
1099 break;
1100 case OMP_CLAUSE_BIND_THREAD:
1101 pp_string (pp, "thread");
1102 break;
1103 default:
1104 gcc_unreachable ();
1105 }
1106 pp_right_paren (pp);
904 break; 1107 break;
905 1108
906 case OMP_CLAUSE__SIMDUID_: 1109 case OMP_CLAUSE__SIMDUID_:
907 pp_string (pp, "_simduid_("); 1110 pp_string (pp, "_simduid_(");
908 dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause), 1111 dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
1061 case OMP_CLAUSE_FINALIZE: 1264 case OMP_CLAUSE_FINALIZE:
1062 pp_string (pp, "finalize"); 1265 pp_string (pp, "finalize");
1063 break; 1266 break;
1064 1267
1065 default: 1268 default:
1066 /* Should never happen. */ 1269 gcc_unreachable ();
1067 dump_generic_node (pp, clause, spc, flags, false);
1068 break;
1069 } 1270 }
1070 } 1271 }
1071 1272
1072 1273
1073 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in 1274 /* Dump the list of OpenMP clauses. PP, SPC and FLAGS are as in
1216 } 1417 }
1217 newline_and_indent (pp, spc + 2); 1418 newline_and_indent (pp, spc + 2);
1218 } 1419 }
1219 } 1420 }
1220 1421
1422 /* Dump #pragma omp atomic memory order clause. */
1423
1424 void
1425 dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo)
1426 {
1427 switch (mo)
1428 {
1429 case OMP_MEMORY_ORDER_RELAXED:
1430 pp_string (pp, " relaxed");
1431 break;
1432 case OMP_MEMORY_ORDER_SEQ_CST:
1433 pp_string (pp, " seq_cst");
1434 break;
1435 case OMP_MEMORY_ORDER_ACQ_REL:
1436 pp_string (pp, " acq_rel");
1437 break;
1438 case OMP_MEMORY_ORDER_ACQUIRE:
1439 pp_string (pp, " acquire");
1440 break;
1441 case OMP_MEMORY_ORDER_RELEASE:
1442 pp_string (pp, " release");
1443 break;
1444 case OMP_MEMORY_ORDER_UNSPECIFIED:
1445 break;
1446 default:
1447 gcc_unreachable ();
1448 }
1449 }
1450
1451 /* Helper to dump a MEM_REF node. */
1452
1453 static void
1454 dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
1455 {
1456 if (flags & TDF_GIMPLE)
1457 {
1458 pp_string (pp, "__MEM <");
1459 dump_generic_node (pp, TREE_TYPE (node),
1460 spc, flags | TDF_SLIM, false);
1461 if (TYPE_ALIGN (TREE_TYPE (node))
1462 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
1463 {
1464 pp_string (pp, ", ");
1465 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
1466 }
1467 pp_greater (pp);
1468 pp_string (pp, " (");
1469 if (TREE_TYPE (TREE_OPERAND (node, 0))
1470 != TREE_TYPE (TREE_OPERAND (node, 1)))
1471 {
1472 pp_left_paren (pp);
1473 dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
1474 spc, flags | TDF_SLIM, false);
1475 pp_right_paren (pp);
1476 }
1477 dump_generic_node (pp, TREE_OPERAND (node, 0),
1478 spc, flags | TDF_SLIM, false);
1479 if (! integer_zerop (TREE_OPERAND (node, 1)))
1480 {
1481 pp_string (pp, " + ");
1482 dump_generic_node (pp, TREE_OPERAND (node, 1),
1483 spc, flags | TDF_SLIM, false);
1484 }
1485 pp_right_paren (pp);
1486 }
1487 else if (integer_zerop (TREE_OPERAND (node, 1))
1488 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1489 infer them and MEM_ATTR caching will share MEM_REFs
1490 with differently-typed op0s. */
1491 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1492 /* Released SSA_NAMES have no TREE_TYPE. */
1493 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1494 /* Same pointer types, but ignoring POINTER_TYPE vs.
1495 REFERENCE_TYPE. */
1496 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1497 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1498 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1499 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1500 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1501 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1502 /* Same value types ignoring qualifiers. */
1503 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1504 == TYPE_MAIN_VARIANT
1505 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1506 && (!(flags & TDF_ALIAS)
1507 || MR_DEPENDENCE_CLIQUE (node) == 0))
1508 {
1509 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1510 {
1511 /* Enclose pointers to arrays in parentheses. */
1512 tree op0 = TREE_OPERAND (node, 0);
1513 tree op0type = TREE_TYPE (op0);
1514 if (POINTER_TYPE_P (op0type)
1515 && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
1516 pp_left_paren (pp);
1517 pp_star (pp);
1518 dump_generic_node (pp, op0, spc, flags, false);
1519 if (POINTER_TYPE_P (op0type)
1520 && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
1521 pp_right_paren (pp);
1522 }
1523 else
1524 dump_generic_node (pp,
1525 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1526 spc, flags, false);
1527 }
1528 else
1529 {
1530 pp_string (pp, "MEM");
1531
1532 tree nodetype = TREE_TYPE (node);
1533 tree op0 = TREE_OPERAND (node, 0);
1534 tree op1 = TREE_OPERAND (node, 1);
1535 tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
1536
1537 tree op0size = TYPE_SIZE (nodetype);
1538 tree op1size = TYPE_SIZE (TREE_TYPE (op1type));
1539
1540 if (!op0size || !op1size
1541 || !operand_equal_p (op0size, op1size, 0))
1542 {
1543 pp_string (pp, " <");
1544 /* If the size of the type of the operand is not the same
1545 as the size of the MEM_REF expression include the type
1546 of the latter similar to the TDF_GIMPLE output to make
1547 it clear how many bytes of memory are being accessed. */
1548 dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
1549 pp_string (pp, "> ");
1550 }
1551
1552 pp_string (pp, "[(");
1553 dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false);
1554 pp_right_paren (pp);
1555 dump_generic_node (pp, op0, spc, flags, false);
1556 if (!integer_zerop (op1))
1557 if (!integer_zerop (TREE_OPERAND (node, 1)))
1558 {
1559 pp_string (pp, " + ");
1560 dump_generic_node (pp, op1, spc, flags, false);
1561 }
1562 if ((flags & TDF_ALIAS)
1563 && MR_DEPENDENCE_CLIQUE (node) != 0)
1564 {
1565 pp_string (pp, " clique ");
1566 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1567 pp_string (pp, " base ");
1568 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1569 }
1570 pp_right_bracket (pp);
1571 }
1572 }
1221 1573
1222 /* Dump the node NODE on the pretty_printer PP, SPC spaces of 1574 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1223 indent. FLAGS specifies details to show in the dump (see TDF_* in 1575 indent. FLAGS specifies details to show in the dump (see TDF_* in
1224 dumpfile.h). If IS_STMT is true, the object printed is considered 1576 dumpfile.h). If IS_STMT is true, the object printed is considered
1225 to be a statement and it is terminated by ';' if appropriate. */ 1577 to be a statement and it is terminated by ';' if appropriate. */
1475 case OFFSET_TYPE: 1827 case OFFSET_TYPE:
1476 NIY; 1828 NIY;
1477 break; 1829 break;
1478 1830
1479 case MEM_REF: 1831 case MEM_REF:
1480 { 1832 dump_mem_ref (pp, node, spc, flags);
1481 if (flags & TDF_GIMPLE) 1833 break;
1482 {
1483 pp_string (pp, "__MEM <");
1484 dump_generic_node (pp, TREE_TYPE (node),
1485 spc, flags | TDF_SLIM, false);
1486 if (TYPE_ALIGN (TREE_TYPE (node))
1487 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
1488 {
1489 pp_string (pp, ", ");
1490 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
1491 }
1492 pp_greater (pp);
1493 pp_string (pp, " (");
1494 if (TREE_TYPE (TREE_OPERAND (node, 0))
1495 != TREE_TYPE (TREE_OPERAND (node, 1)))
1496 {
1497 pp_left_paren (pp);
1498 dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
1499 spc, flags | TDF_SLIM, false);
1500 pp_right_paren (pp);
1501 }
1502 dump_generic_node (pp, TREE_OPERAND (node, 0),
1503 spc, flags | TDF_SLIM, false);
1504 if (! integer_zerop (TREE_OPERAND (node, 1)))
1505 {
1506 pp_string (pp, " + ");
1507 dump_generic_node (pp, TREE_OPERAND (node, 1),
1508 spc, flags | TDF_SLIM, false);
1509 }
1510 pp_right_paren (pp);
1511 }
1512 else if (integer_zerop (TREE_OPERAND (node, 1))
1513 /* Dump the types of INTEGER_CSTs explicitly, for we can't
1514 infer them and MEM_ATTR caching will share MEM_REFs
1515 with differently-typed op0s. */
1516 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1517 /* Released SSA_NAMES have no TREE_TYPE. */
1518 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1519 /* Same pointer types, but ignoring POINTER_TYPE vs.
1520 REFERENCE_TYPE. */
1521 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1522 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1523 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1524 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1525 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1526 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1527 /* Same value types ignoring qualifiers. */
1528 && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1529 == TYPE_MAIN_VARIANT
1530 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1531 && (!(flags & TDF_ALIAS)
1532 || MR_DEPENDENCE_CLIQUE (node) == 0))
1533 {
1534 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1535 {
1536 pp_star (pp);
1537 dump_generic_node (pp, TREE_OPERAND (node, 0),
1538 spc, flags, false);
1539 }
1540 else
1541 dump_generic_node (pp,
1542 TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1543 spc, flags, false);
1544 }
1545 else
1546 {
1547 tree ptype;
1548
1549 pp_string (pp, "MEM[");
1550 pp_left_paren (pp);
1551 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
1552 dump_generic_node (pp, ptype,
1553 spc, flags | TDF_SLIM, false);
1554 pp_right_paren (pp);
1555 dump_generic_node (pp, TREE_OPERAND (node, 0),
1556 spc, flags, false);
1557 if (!integer_zerop (TREE_OPERAND (node, 1)))
1558 {
1559 pp_string (pp, " + ");
1560 dump_generic_node (pp, TREE_OPERAND (node, 1),
1561 spc, flags, false);
1562 }
1563 if ((flags & TDF_ALIAS)
1564 && MR_DEPENDENCE_CLIQUE (node) != 0)
1565 {
1566 pp_string (pp, " clique ");
1567 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1568 pp_string (pp, " base ");
1569 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1570 }
1571 pp_right_bracket (pp);
1572 }
1573 break;
1574 }
1575 1834
1576 case TARGET_MEM_REF: 1835 case TARGET_MEM_REF:
1577 { 1836 {
1578 const char *sep = ""; 1837 const char *sep = "";
1579 tree tmp; 1838 tree tmp;
1685 case INTEGER_CST: 1944 case INTEGER_CST:
1686 if (flags & TDF_GIMPLE 1945 if (flags & TDF_GIMPLE
1687 && (POINTER_TYPE_P (TREE_TYPE (node)) 1946 && (POINTER_TYPE_P (TREE_TYPE (node))
1688 || (TYPE_PRECISION (TREE_TYPE (node)) 1947 || (TYPE_PRECISION (TREE_TYPE (node))
1689 < TYPE_PRECISION (integer_type_node)) 1948 < TYPE_PRECISION (integer_type_node))
1690 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1)) 1949 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
1950 || tree_int_cst_sgn (node) < 0))
1691 { 1951 {
1692 pp_string (pp, "_Literal ("); 1952 pp_string (pp, "_Literal (");
1693 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); 1953 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1694 pp_string (pp, ") "); 1954 pp_string (pp, ") ");
1695 } 1955 }
1816 } 2076 }
1817 2077
1818 case VECTOR_CST: 2078 case VECTOR_CST:
1819 { 2079 {
1820 unsigned i; 2080 unsigned i;
2081 if (flags & TDF_GIMPLE)
2082 {
2083 pp_string (pp, "_Literal (");
2084 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2085 pp_string (pp, ") ");
2086 }
1821 pp_string (pp, "{ "); 2087 pp_string (pp, "{ ");
1822 unsigned HOST_WIDE_INT nunits; 2088 unsigned HOST_WIDE_INT nunits;
1823 if (!VECTOR_CST_NELTS (node).is_constant (&nunits)) 2089 if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
1824 nunits = vector_cst_encoded_nelts (node); 2090 nunits = vector_cst_encoded_nelts (node);
1825 for (i = 0; i < nunits; ++i) 2091 for (i = 0; i < nunits; ++i)
1965 pp_right_brace (pp); 2231 pp_right_brace (pp);
1966 } 2232 }
1967 break; 2233 break;
1968 2234
1969 case BIT_FIELD_REF: 2235 case BIT_FIELD_REF:
1970 pp_string (pp, "BIT_FIELD_REF <"); 2236 if (flags & TDF_GIMPLE)
1971 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 2237 {
1972 pp_string (pp, ", "); 2238 pp_string (pp, "__BIT_FIELD_REF <");
1973 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); 2239 dump_generic_node (pp, TREE_TYPE (node),
1974 pp_string (pp, ", "); 2240 spc, flags | TDF_SLIM, false);
1975 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false); 2241 if (TYPE_ALIGN (TREE_TYPE (node))
1976 pp_greater (pp); 2242 != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2243 {
2244 pp_string (pp, ", ");
2245 pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2246 }
2247 pp_greater (pp);
2248 pp_string (pp, " (");
2249 dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
2250 flags | TDF_SLIM, false);
2251 pp_string (pp, ", ");
2252 dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
2253 flags | TDF_SLIM, false);
2254 pp_string (pp, ", ");
2255 dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
2256 flags | TDF_SLIM, false);
2257 pp_right_paren (pp);
2258 }
2259 else
2260 {
2261 pp_string (pp, "BIT_FIELD_REF <");
2262 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2263 pp_string (pp, ", ");
2264 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2265 pp_string (pp, ", ");
2266 dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2267 pp_greater (pp);
2268 }
1977 break; 2269 break;
1978 2270
1979 case BIT_INSERT_EXPR: 2271 case BIT_INSERT_EXPR:
1980 pp_string (pp, "BIT_INSERT_EXPR <"); 2272 pp_string (pp, "BIT_INSERT_EXPR <");
1981 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 2273 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2027 unsigned HOST_WIDE_INT ix; 2319 unsigned HOST_WIDE_INT ix;
2028 tree field, val; 2320 tree field, val;
2029 bool is_struct_init = false; 2321 bool is_struct_init = false;
2030 bool is_array_init = false; 2322 bool is_array_init = false;
2031 widest_int curidx; 2323 widest_int curidx;
2324 if (flags & TDF_GIMPLE)
2325 {
2326 pp_string (pp, "_Literal (");
2327 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2328 pp_string (pp, ") ");
2329 }
2032 pp_left_brace (pp); 2330 pp_left_brace (pp);
2033 if (TREE_CLOBBER_P (node)) 2331 if (TREE_CLOBBER_P (node))
2034 pp_string (pp, "CLOBBER"); 2332 pp_string (pp, "CLOBBER");
2035 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE 2333 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
2036 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) 2334 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
2507 if (op_prio (op0) < op_prio (node)) 2805 if (op_prio (op0) < op_prio (node))
2508 pp_right_paren (pp); 2806 pp_right_paren (pp);
2509 break; 2807 break;
2510 2808
2511 case VIEW_CONVERT_EXPR: 2809 case VIEW_CONVERT_EXPR:
2512 pp_string (pp, "VIEW_CONVERT_EXPR<"); 2810 if (flags & TDF_GIMPLE)
2811 pp_string (pp, "__VIEW_CONVERT <");
2812 else
2813 pp_string (pp, "VIEW_CONVERT_EXPR<");
2513 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); 2814 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2514 pp_string (pp, ">("); 2815 pp_string (pp, ">(");
2515 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 2816 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2516 pp_right_paren (pp); 2817 pp_right_paren (pp);
2517 break; 2818 break;
2590 newline_and_indent (pp, spc+4); 2891 newline_and_indent (pp, spc+4);
2591 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true); 2892 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2592 newline_and_indent (pp, spc+2); 2893 newline_and_indent (pp, spc+2);
2593 pp_right_brace (pp); 2894 pp_right_brace (pp);
2594 newline_and_indent (pp, spc); 2895 newline_and_indent (pp, spc);
2595 pp_string (pp, 2896 if (TREE_CODE (node) == TRY_CATCH_EXPR)
2596 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally"); 2897 {
2898 node = TREE_OPERAND (node, 1);
2899 pp_string (pp, "catch");
2900 }
2901 else
2902 {
2903 gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
2904 node = TREE_OPERAND (node, 1);
2905 pp_string (pp, "finally");
2906 if (TREE_CODE (node) == EH_ELSE_EXPR)
2907 {
2908 newline_and_indent (pp, spc+2);
2909 pp_left_brace (pp);
2910 newline_and_indent (pp, spc+4);
2911 dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
2912 flags, true);
2913 newline_and_indent (pp, spc+2);
2914 pp_right_brace (pp);
2915 newline_and_indent (pp, spc);
2916 node = TREE_OPERAND (node, 1);
2917 pp_string (pp, "else");
2918 }
2919 }
2597 newline_and_indent (pp, spc+2); 2920 newline_and_indent (pp, spc+2);
2598 pp_left_brace (pp); 2921 pp_left_brace (pp);
2599 newline_and_indent (pp, spc+4); 2922 newline_and_indent (pp, spc+4);
2600 dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true); 2923 dump_generic_node (pp, node, spc+4, flags, true);
2601 newline_and_indent (pp, spc+2); 2924 newline_and_indent (pp, spc+2);
2602 pp_right_brace (pp); 2925 pp_right_brace (pp);
2603 is_expr = false; 2926 is_expr = false;
2604 break; 2927 break;
2605 2928
2931 3254
2932 case OACC_KERNELS: 3255 case OACC_KERNELS:
2933 pp_string (pp, "#pragma acc kernels"); 3256 pp_string (pp, "#pragma acc kernels");
2934 goto dump_omp_clauses_body; 3257 goto dump_omp_clauses_body;
2935 3258
3259 case OACC_SERIAL:
3260 pp_string (pp, "#pragma acc serial");
3261 goto dump_omp_clauses_body;
3262
2936 case OACC_DATA: 3263 case OACC_DATA:
2937 pp_string (pp, "#pragma acc data"); 3264 pp_string (pp, "#pragma acc data");
2938 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags); 3265 dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2939 goto dump_omp_body; 3266 goto dump_omp_body;
2940 3267
2989 } 3316 }
2990 is_expr = false; 3317 is_expr = false;
2991 break; 3318 break;
2992 3319
2993 case OMP_TASK: 3320 case OMP_TASK:
2994 pp_string (pp, "#pragma omp task"); 3321 pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
3322 : "#pragma omp taskwait");
2995 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags); 3323 dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2996 goto dump_omp_body; 3324 goto dump_omp_body;
2997 3325
2998 case OMP_FOR: 3326 case OMP_FOR:
2999 pp_string (pp, "#pragma omp for"); 3327 pp_string (pp, "#pragma omp for");
3007 pp_string (pp, "#pragma omp distribute"); 3335 pp_string (pp, "#pragma omp distribute");
3008 goto dump_omp_loop; 3336 goto dump_omp_loop;
3009 3337
3010 case OMP_TASKLOOP: 3338 case OMP_TASKLOOP:
3011 pp_string (pp, "#pragma omp taskloop"); 3339 pp_string (pp, "#pragma omp taskloop");
3340 goto dump_omp_loop;
3341
3342 case OMP_LOOP:
3343 pp_string (pp, "#pragma omp loop");
3012 goto dump_omp_loop; 3344 goto dump_omp_loop;
3013 3345
3014 case OACC_LOOP: 3346 case OACC_LOOP:
3015 pp_string (pp, "#pragma acc loop"); 3347 pp_string (pp, "#pragma acc loop");
3016 goto dump_omp_loop; 3348 goto dump_omp_loop;
3114 3446
3115 case OMP_SECTION: 3447 case OMP_SECTION:
3116 pp_string (pp, "#pragma omp section"); 3448 pp_string (pp, "#pragma omp section");
3117 goto dump_omp_body; 3449 goto dump_omp_body;
3118 3450
3451 case OMP_SCAN:
3452 if (OMP_SCAN_CLAUSES (node))
3453 {
3454 pp_string (pp, "#pragma omp scan");
3455 dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
3456 }
3457 goto dump_omp_body;
3458
3119 case OMP_MASTER: 3459 case OMP_MASTER:
3120 pp_string (pp, "#pragma omp master"); 3460 pp_string (pp, "#pragma omp master");
3121 goto dump_omp_body; 3461 goto dump_omp_body;
3122 3462
3123 case OMP_TASKGROUP: 3463 case OMP_TASKGROUP:
3124 pp_string (pp, "#pragma omp taskgroup"); 3464 pp_string (pp, "#pragma omp taskgroup");
3465 dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
3125 goto dump_omp_body; 3466 goto dump_omp_body;
3126 3467
3127 case OMP_ORDERED: 3468 case OMP_ORDERED:
3128 pp_string (pp, "#pragma omp ordered"); 3469 pp_string (pp, "#pragma omp ordered");
3129 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags); 3470 dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3142 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags); 3483 dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3143 goto dump_omp_body; 3484 goto dump_omp_body;
3144 3485
3145 case OMP_ATOMIC: 3486 case OMP_ATOMIC:
3146 pp_string (pp, "#pragma omp atomic"); 3487 pp_string (pp, "#pragma omp atomic");
3147 if (OMP_ATOMIC_SEQ_CST (node)) 3488 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3148 pp_string (pp, " seq_cst");
3149 newline_and_indent (pp, spc + 2); 3489 newline_and_indent (pp, spc + 2);
3150 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 3490 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3151 pp_space (pp); 3491 pp_space (pp);
3152 pp_equal (pp); 3492 pp_equal (pp);
3153 pp_space (pp); 3493 pp_space (pp);
3154 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false); 3494 dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3155 break; 3495 break;
3156 3496
3157 case OMP_ATOMIC_READ: 3497 case OMP_ATOMIC_READ:
3158 pp_string (pp, "#pragma omp atomic read"); 3498 pp_string (pp, "#pragma omp atomic read");
3159 if (OMP_ATOMIC_SEQ_CST (node)) 3499 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3160 pp_string (pp, " seq_cst");
3161 newline_and_indent (pp, spc + 2); 3500 newline_and_indent (pp, spc + 2);
3162 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 3501 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3163 pp_space (pp); 3502 pp_space (pp);
3164 break; 3503 break;
3165 3504
3166 case OMP_ATOMIC_CAPTURE_OLD: 3505 case OMP_ATOMIC_CAPTURE_OLD:
3167 case OMP_ATOMIC_CAPTURE_NEW: 3506 case OMP_ATOMIC_CAPTURE_NEW:
3168 pp_string (pp, "#pragma omp atomic capture"); 3507 pp_string (pp, "#pragma omp atomic capture");
3169 if (OMP_ATOMIC_SEQ_CST (node)) 3508 dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3170 pp_string (pp, " seq_cst");
3171 newline_and_indent (pp, spc + 2); 3509 newline_and_indent (pp, spc + 2);
3172 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false); 3510 dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3173 pp_space (pp); 3511 pp_space (pp);
3174 pp_equal (pp); 3512 pp_equal (pp);
3175 pp_space (pp); 3513 pp_space (pp);
4065 HOST_WIDE_INT_PRINT_DOUBLE_HEX, 4403 HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4066 (unsigned HOST_WIDE_INT) high, low); 4404 (unsigned HOST_WIDE_INT) high, low);
4067 pp_string (pp, pp_buffer (pp)->digit_buffer); 4405 pp_string (pp, pp_buffer (pp)->digit_buffer);
4068 } 4406 }
4069 } 4407 }
4408
4409 #if __GNUC__ >= 10
4410 # pragma GCC diagnostic pop
4411 #endif