FANDOM


目次

  1. contents

このページを編集する際は,編集に関する方針に従ってください. 編集

概要 編集

引数 編集

実装 編集

 249 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
 250    FLAGS specifies details to show in the dump (see TDF_* in tree.h).  If
 251    IS_STMT is true, the object printed is considered to be a statement
 252    and it is terminated by ';' if appropriate.  */
253 
254 int
255 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
256                    bool is_stmt)
257 {
258   tree type;
259   tree op0, op1;
260   const char *str;
261   bool is_expr;
262 
263   if (node == NULL_TREE)
264     return spc;
265 
266   is_expr = EXPR_P (node);
267 
268   if (TREE_CODE (node) != [[ERROR_MARK>enum tree_code]]
269       && is_gimple_stmt (node)
270       && (flags & TDF_VOPS)
271       && stmt_ann (node)
272       && TREE_CODE (node) != [[PHI_NODE>enum tree_code]])
273     dump_vops (buffer, node, spc, flags);
274 
275   if (is_stmt && (flags & TDF_STMTADDR))
276     pp_printf (buffer, "<&%p> ", (void *)node);
277 

*dumping_stmtsはgcc-4.1.0/gcc/tree-pretty-print.cにてstatic boolとして宣言されている

278   if (dumping_stmts
279       && (flags & TDF_LINENO)
280       && EXPR_HAS_LOCATION (node))
281     {
282       expanded_location xloc = expand_location (EXPR_LOCATION (node));
283       pp_character (buffer, '[');
284       if (xloc.file)
285         {
286           pp_string (buffer, xloc.file);
287           pp_string (buffer, " : ");
288         }
289       pp_decimal_int (buffer, xloc.line);
290       pp_string (buffer, "] ");
291     }
292 

== *長いswitch  ==

293   switch (TREE_CODE (node))
294     {

== **case ERROR_MARK  ==

295     case [[ERROR_MARK>enum tree_code]]:
296       pp_string (buffer, "<<< error >>>");
297       break;
298 

== **case IDENTIFIER_NODE  ==

299     case [[IDENTIFIER_NODE>enum tree_code]]:
300       pp_tree_identifier (buffer, node);
301       break;
302 

== **case TREE_LIST  ==

303     case [[TREE_LIST>enum tree_code]]:
304       while (node && node != error_mark_node)
305         {
306           if (TREE_PURPOSE (node))
307             {
308               dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
309               pp_space (buffer);
310             }
311           dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
312           node = TREE_CHAIN (node);
313           if (node && TREE_CODE (node) == [[TREE_LIST>enum tree_code]])
314             {
315               pp_character (buffer, ',');
316               pp_space (buffer);
317             }
318         }
319       break;
320
== **case TREE_BINFO  ==

321     case [[TREE_BINFO>enum tree_code]]:
322       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
323
== **case TREE_VEC  ==

324     case [[TREE_VEC>enum tree_code]]:
325       {
326         size_t i;
327         if (TREE_VEC_LENGTH (node) > 0)
328           {
329             size_t len = TREE_VEC_LENGTH (node);
330             for (i = 0; i < len - 1; i++)
331               {     
332                 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
333                                    false);
334                 pp_character (buffer, ',');
335                 pp_space (buffer);
336               }
337             dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, 
338                                flags, false);
339           }
340       }
341       break;
342 

== **case BLOCK  ==

343     case [[BLOCK>enum tree_code]]:
344       NIY;
345       break;
346 

== **case VOID_TYPE, INTEGER_TYPE, REAL_TYPE, COMPLEX_TYPE, VECTOR_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, CHAR_TYPE  ==

347     case [[VOID_TYPE>enum tree_code]]:
348     case [[INTEGER_TYPE>enum tree_code]]:
349     case [[REAL_TYPE>enum tree_code]]:
350     case [[COMPLEX_TYPE>enum tree_code]]:
351     case [[VECTOR_TYPE>enum tree_code]]:
352     case [[ENUMERAL_TYPE>enum tree_code]]:
353     case [[BOOLEAN_TYPE>enum tree_code]]:
354     case [[CHAR_TYPE>enum tree_code]]:
355       {
356         unsigned int quals = TYPE_QUALS (node);
357         enum tree_code_class class;
358 
359         if (quals & TYPE_QUAL_CONST)
360           pp_string (buffer, "const ");
361         else if (quals & TYPE_QUAL_VOLATILE)
362           pp_string (buffer, "volatile ");
363         else if (quals & TYPE_QUAL_RESTRICT)
364           pp_string (buffer, "restrict ");
365 
366         class = TREE_CODE_CLASS (TREE_CODE (node));
367 
368         if (class == [[tcc_declaration>enum tree_code_class]])
369           {
370             if (DECL_NAME (node))
371               dump_decl_name (buffer, node, flags);
372             else
373               pp_string (buffer, "<unnamed type decl>");
374           }
375         else if (class == [[tcc_type>enum tree_code_class]])
376           {
377             if (TYPE_NAME (node))
378               {
379                 if (TREE_CODE (TYPE_NAME (node)) == [[IDENTIFIER_NODE>enum tree_code]])
380                   pp_tree_identifier (buffer, TYPE_NAME (node));
381                 else if (TREE_CODE (TYPE_NAME (node)) == [[TYPE_DECL>enum tree_code]]
382                          && DECL_NAME (TYPE_NAME (node)))
383                   dump_decl_name (buffer, TYPE_NAME (node), flags);
384                 else
385                   pp_string (buffer, "<unnamed type>");
386               }
387             else if (TREE_CODE (node) == [[VECTOR_TYPE>enum tree_code]])
388               {
389                 pp_string (buffer, "vector ");
390                 dump_generic_node (buffer, TREE_TYPE (node), 
391                                    spc, flags, false);
392               }
393             else
394               pp_string (buffer, "<unnamed type>");
395           }
396         break;
397       }
398
== **case POINTER_TYPE, REFRENCE_TYPE  ==

399     case [[POINTER_TYPE>enum tree_code]]:
400     case [[REFERENCE_TYPE>enum tree_code]]:
401       str = (TREE_CODE (node) == [[POINTER_TYPE>enum tree_code]] ? "*" : "&");
402 
403       if (TREE_CODE (TREE_TYPE (node)) == [[FUNCTION_TYPE>enum tree_code]])
404         {
405           tree fnode = TREE_TYPE (node);
406 
407           dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
408           pp_space (buffer);
409           pp_character (buffer, '(');
410           pp_string (buffer, str);
411           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
412             dump_decl_name (buffer, TYPE_NAME (node), flags);
413           else
414             pp_printf (buffer, "<T%x>", TYPE_UID (node));
415 
416           pp_character (buffer, ')');
417           dump_function_declaration (buffer, fnode, spc, flags);
418         }
419       else
420         {
421           unsigned int quals = TYPE_QUALS (node);
422 
423           dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
424           pp_space (buffer);
425           pp_string (buffer, str);
426 
427           if (quals & TYPE_QUAL_CONST)
428             pp_string (buffer, " const");
429           else if (quals & TYPE_QUAL_VOLATILE)
430             pp_string (buffer,  "volatile");
431           else if (quals & TYPE_QUAL_RESTRICT)
432             pp_string (buffer, " restrict");
433 
434           if (TYPE_REF_CAN_ALIAS_ALL (node))
435             pp_string (buffer, " {ref-all}");
436         }
437       break;
438
== **case OFFSET_TYPE  ==

439     case [[OFFSET_TYPE>enum tree_code]]:
440       NIY;
441       break;
442
== **case METHOD_TYPE  ==

443     case [[METHOD_TYPE>enum tree_code]]:
444       dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
445       pp_string (buffer, "::");
446       break;
447
== **case TARGET_MEM_REF  ==

448     case [[TARGET_MEM_REF>enum tree_code]]:
449       {
450         const char *sep = "";
451         tree tmp;
452 
453         pp_string (buffer, "MEM[");
454 
455         tmp = TMR_SYMBOL (node);
456         if (tmp)
457           {
458             pp_string (buffer, sep);
459             sep = ", ";
460             pp_string (buffer, "symbol: ");
461             dump_generic_node (buffer, tmp, spc, flags, false);
462           }
463         tmp = TMR_BASE (node);
464         if (tmp)
465           {
466             pp_string (buffer, sep);
467             sep = ", ";
468             pp_string (buffer, "base: ");
469             dump_generic_node (buffer, tmp, spc, flags, false);
470           }
471         tmp = TMR_INDEX (node);
472         if (tmp)
473           {
474             pp_string (buffer, sep);
475             sep = ", ";
476             pp_string (buffer, "index: ");
477             dump_generic_node (buffer, tmp, spc, flags, false);
478           }
479         tmp = TMR_STEP (node);
480         if (tmp)
481           {
482             pp_string (buffer, sep);
483             sep = ", ";
484             pp_string (buffer, "step: ");
485             dump_generic_node (buffer, tmp, spc, flags, false);
486           }
487         tmp = TMR_OFFSET (node);
488         if (tmp)
489           {
490             pp_string (buffer, sep);
491             sep = ", ";
492             pp_string (buffer, "offset: ");
493             dump_generic_node (buffer, tmp, spc, flags, false);
494           }
495         pp_string (buffer, "]");
496         if (flags & TDF_DETAILS)
497           {
498             pp_string (buffer, "{");
499             dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
500                                false);
501             pp_string (buffer, "}");
502           }
503       }
504       break;
505
== **case ARRAY_TYPE  ==

506     case [[ARRAY_TYPE>enum tree_code]]:
507       {
508         tree tmp;
509 
 510         /* Print the innermost component type.  */
511         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == [[ARRAY_TYPE>enum tree_code]];
512              tmp = TREE_TYPE (tmp))
513           ;
514         dump_generic_node (buffer, tmp, spc, flags, false);
515 
 516         /* Print the dimensions.  */
517         for (tmp = node; TREE_CODE (tmp) == [[ARRAY_TYPE>enum tree_code]]; tmp = TREE_TYPE (tmp))
518           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
519         break;
520       }
521
== **case RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE  ==

522     case [[RECORD_TYPE>enum tree_code]]:
523     case [[UNION_TYPE>enum tree_code]]:
524     case [[QUAL_UNION_TYPE>enum tree_code]]:
 525       /* Print the name of the structure.  */
526       if (TREE_CODE (node) == [[RECORD_TYPE>enum tree_code]])
527         pp_string (buffer, "struct ");
528       else if (TREE_CODE (node) == [[UNION_TYPE>enum tree_code]])
529         pp_string (buffer, "union ");
530 
531       if (TYPE_NAME (node))
532         dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
533       else
534         print_struct_decl (buffer, node, spc, flags);
535       break;
536
== **case LANG_TYPE  ==

537     case [[LANG_TYPE>enum tree_code]]:
538       NIY;
539       break;
540
== **case INTEGER_CST  ==

541     case [[INTEGER_CST>enum tree_code]]:
542       if (TREE_CODE (TREE_TYPE (node)) == [[POINTER_TYPE>enum tree_code]])
543         {
 544           /* In the case of a pointer, one may want to divide by the
 545              size of the pointed-to type.  Unfortunately, this not
 546              straightforward.  The C front-end maps expressions
 547 
 548              (int *) 5
 549              int *p; (p + 5)
 550 
 551              in such a way that the two INTEGER_CST nodes for "5" have
 552              different values but identical types.  In the latter
 553              case, the 5 is multiplied by sizeof (int) in c-common.c
 554              (pointer_int_sum) to convert it to a byte address, and
 555              yet the type of the node is left unchanged.  Argh.  What
 556              is consistent though is that the number value corresponds
 557              to bytes (UNITS) offset.
 558 
 559              NB: Neither of the following divisors can be trivially
 560              used to recover the original literal:
 561 
 562              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
 563              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
564           pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
565           pp_string (buffer, "B"); /* pseudo-unit */
566         }
567       else if (! host_integerp (node, 0))
568         {
569           tree val = node;
570 
571           if (tree_int_cst_sgn (val) < 0)
572             {
573               pp_character (buffer, '-');
574               val = build_int_cst_wide (NULL_TREE,
575                                         -TREE_INT_CST_LOW (val),
576                                         ~TREE_INT_CST_HIGH (val)
577                                         + !TREE_INT_CST_LOW (val));
578             }
 579           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
 580              systems?  */
581           {
582             static char format[10]; /* "%x%09999x\0" */
583             if (!format[0])

*HOST_BITS_PER_INTはconfigureなりmakeで生成される模様

584               sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
585             sprintf (pp_buffer (buffer)->digit_buffer, format,
586                      TREE_INT_CST_HIGH (val),
587                      TREE_INT_CST_LOW (val));
588             pp_string (buffer, pp_buffer (buffer)->digit_buffer);
589           }
590         }
591       else
592         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
593       break;
594
== **case REAL_CST  ==

595     case [[REAL_CST>enum tree_code]]:
 596       /* Code copied from print_node.  */
597       {
598         REAL_VALUE_TYPE d;
599         if (TREE_OVERFLOW (node))
600           pp_string (buffer, " overflow");
601 
602 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
603         d = TREE_REAL_CST (node);
604         if (REAL_VALUE_ISINF (d))
605           pp_string (buffer, " Inf");
606         else if (REAL_VALUE_ISNAN (d))
607           pp_string (buffer, " Nan");
608         else
609           {
610             char string[100];
611             real_to_decimal (string, &d, sizeof (string), 0, 1);
612             pp_string (buffer, string);
613           }
614 #else
615         {
616           HOST_WIDE_INT i;
617           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
618           pp_string (buffer, "0x");
619           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
620             output_formatted_integer (buffer, "%02x", *p++);
621         }
622 #endif
623         break;
624       }
625
== **case COMPLEX_CST  ==

626     case [[COMPLEX_CST>enum tree_code]]:
627       pp_string (buffer, "__complex__ (");
628       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
629       pp_string (buffer, ", ");
630       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
631       pp_string (buffer, ")");
632       break;
633 

== **case STRING_CST  ==

634     case [[STRING_CST>enum tree_code]]:
635       pp_string (buffer, "\"");
636       pretty_print_string (buffer, TREE_STRING_POINTER (node));
637       pp_string (buffer, "\"");
638       break;
639 

== **case VECTOR_CST  ==

640     case [[VECTOR_CST>enum tree_code]]:
641       {
642         tree elt;
643         pp_string (buffer, "{ ");
644         for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
645           {
646             dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
647             if (TREE_CHAIN (elt))
648               pp_string (buffer, ", ");
649           }
650         pp_string (buffer, " }");
651       }
652       break;
653 

== **case FUNCTION_TYPE  ==

654     case [[FUNCTION_TYPE>enum tree_code]]:
655       break;
656 

== **case FUNCTION_DECL, CONST_DECL  ==

657     case [[FUNCTION_DECL>enum tree_code]]:
658     case [[CONST_DECL>enum tree_code]]:
659       dump_decl_name (buffer, node, flags);
660       break;
661 

== **case LABEL_DECL  ==

662     case [[LABEL_DECL>enum tree_code]]:
663       if (DECL_NAME (node))
664         dump_decl_name (buffer, node, flags);
665       else if (LABEL_DECL_UID (node) != -1)
666         pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
667                    LABEL_DECL_UID (node));
668       else
669         pp_printf (buffer, "<D%u>", DECL_UID (node));
670       break;
671 

== **case TYPE_DECL  ==

672     case [[TYPE_DECL>enum tree_code]]:
673       if (DECL_IS_BUILTIN (node))
674         {
 675           /* Don't print the declaration of built-in types.  */
676           break;
677         }
678       if (DECL_NAME (node))
679         dump_decl_name (buffer, node, flags);
680       else
681         {
682           if ((TREE_CODE (TREE_TYPE (node)) == [[RECORD_TYPE>enum tree_code]]
683                || TREE_CODE (TREE_TYPE (node)) == [[UNION_TYPE>enum tree_code]])
684               && TYPE_METHODS (TREE_TYPE (node)))
685             {
 686               /* The type is a c++ class: all structures have at least
 687                  4 methods.  */
688               pp_string (buffer, "class ");
689               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
690             }
691           else
692             {
693               pp_string (buffer,
694                          (TREE_CODE (TREE_TYPE (node)) == [[UNION_TYPE>enum tree_code]]
695                           ? "union" : "struct "));
696               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
697             }
698         }
699       break;
700
== **case VAR_DECL, PARM_DECL, FIELD_DECL, NAMESPACE_DECL  ==

701     case [[VAR_DECL>enum tree_code]]:
702     case [[PARM_DECL>enum tree_code]]:
703     case [[FIELD_DECL>enum tree_code]]:
704     case [[NAMESPACE_DECL>enum tree_code]]:
705       dump_decl_name (buffer, node, flags);
706       break;
707 

== **case RESULT_DECL  ==

708     case [[RESULT_DECL>enum tree_code]]:
709       pp_string (buffer, "<retval>");
710       break;
711 

== **case COMPONENT_REF  ==

712     case [[COMPONENT_REF>enum tree_code]]:
713       op0 = TREE_OPERAND (node, 0);
714       str = ".";
715       if (TREE_CODE (op0) == [[INDIRECT_REF>enum tree_code]])
716         {
717           op0 = TREE_OPERAND (op0, 0);
718           str = "->";
719         }
720       if (op_prio (op0) < op_prio (node))
721         pp_character (buffer, '(');
722       dump_generic_node (buffer, op0, spc, flags, false);
723       if (op_prio (op0) < op_prio (node))
724         pp_character (buffer, ')');
725       pp_string (buffer, str);
726       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
727 
728       if (TREE_CODE (op0) != [[VALUE_HANDLE>enum tree_code]])
729         {
730           op0 = component_ref_field_offset (node);
731           if (op0 && TREE_CODE (op0) != [[INTEGER_CST>enum tree_code]])
732             {
733               pp_string (buffer, "{off: ");
734               dump_generic_node (buffer, op0, spc, flags, false);
735               pp_character (buffer, '}');
736             }
737         }
738       break;
739 

== **case BIT_FIELD_REF  ==

740     case [[BIT_FIELD_REF>enum tree_code]]:
741       pp_string (buffer, "BIT_FIELD_REF <");
742       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
743       pp_string (buffer, ", ");
744       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
745       pp_string (buffer, ", ");
746       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
747       pp_string (buffer, ">");
748       break;
749 

== **case ARRAY_REF, ARRAY_RANGE_REF  ==

750     case [[ARRAY_REF>enum tree_code]]:
751     case [[ARRAY_RANGE_REF>enum tree_code]]:
752       op0 = TREE_OPERAND (node, 0);
753       if (op_prio (op0) < op_prio (node))
754         pp_character (buffer, '(');
755       dump_generic_node (buffer, op0, spc, flags, false);
756       if (op_prio (op0) < op_prio (node))
757         pp_character (buffer, ')');
758       pp_character (buffer, '[');
759       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
760       if (TREE_CODE (node) == [[ARRAY_RANGE_REF>enum tree_code]])
761         pp_string (buffer, " ...");
762       pp_character (buffer, ']');
763 
764       op0 = array_ref_low_bound (node);
765       op1 = array_ref_element_size (node);
766 
767       if (!integer_zerop (op0)
768           || (TYPE_SIZE_UNIT (TREE_TYPE (node))
769               && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
770         {
771           pp_string (buffer, "{lb: ");
772           dump_generic_node (buffer, op0, spc, flags, false);
773           pp_string (buffer, " sz: ");
774           dump_generic_node (buffer, op1, spc, flags, false);
775           pp_character (buffer, '}');
776         }
777       break;
778 

== **[]  ==

779     case CONSTRUCTOR:
780       {
781         unsigned HOST_WIDE_INT ix;
782         tree field, val;
783         bool is_struct_init = FALSE;
784         pp_character (buffer, '{');
785         if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
786             || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
787           is_struct_init = TRUE;
788         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
789           {
790             if (field && is_struct_init)
791               {
792                 pp_character (buffer, '.');
793                 dump_generic_node (buffer, field, spc, flags, false);
794                 pp_string (buffer, "=");
795               }
796             if (val && TREE_CODE (val) == ADDR_EXPR)
797               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
798                 val = TREE_OPERAND (val, 0);
799             if (val && TREE_CODE (val) == FUNCTION_DECL)
800                 dump_decl_name (buffer, val, flags);
801             else
802                 dump_generic_node (buffer, val, spc, flags, false);
803             if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
804               {
805                 pp_character (buffer, ',');
806                 pp_space (buffer);
807               }
808           }
809         pp_character (buffer, '}');
810       }
811       break;
812 
813     case COMPOUND_EXPR:
814       {
815         tree *tp;
816         if (flags & TDF_SLIM)
817           {
818             pp_string (buffer, "<COMPOUND_EXPR>");
819             break;
820           }
821 
822         dump_generic_node (buffer, TREE_OPERAND (node, 0),
823                            spc, flags, dumping_stmts);
824         if (dumping_stmts)
825           newline_and_indent (buffer, spc);
826         else
827           {
828             pp_character (buffer, ',');
829             pp_space (buffer);
830           }
831 
832         for (tp = &TREE_OPERAND (node, 1);
833              TREE_CODE (*tp) == COMPOUND_EXPR;
834              tp = &TREE_OPERAND (*tp, 1))
835           {
836             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
837                                spc, flags, dumping_stmts);
838             if (dumping_stmts)
839               newline_and_indent (buffer, spc);
840             else
841               {
842                 pp_character (buffer, ',');
843                 pp_space (buffer);
844               }
845           }
846 
847         dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
848       }
849       break;
850 
851     case STATEMENT_LIST:
852       {
853         tree_stmt_iterator si;
854         bool first = true;
855 
856         if ((flags & TDF_SLIM) || !dumping_stmts)
857           {
858             pp_string (buffer, "<STATEMENT_LIST>");
859             break;
860           }
861 
862         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
863           {
864             if (!first)
865               newline_and_indent (buffer, spc);
866             else
867               first = false;
868             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
869           }
870       }
871       break;
872 
873     case MODIFY_EXPR:
874     case INIT_EXPR:
875       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
876       pp_space (buffer);
877       pp_character (buffer, '=');
878       pp_space (buffer);
879       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
880       break;
881 
882     case TARGET_EXPR:
883       pp_string (buffer, "TARGET_EXPR <");
884       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
885       pp_character (buffer, ',');
886       pp_space (buffer);
887       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
888       pp_character (buffer, '>');
889       break;
890 
891     case DECL_EXPR:
892       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
893       is_stmt = false;
894       break;
895 
896     case COND_EXPR:
897       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
898         {
899           pp_string (buffer, "if (");
900           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
901           pp_character (buffer, ')');
 902           /* The lowered cond_exprs should always be printed in full.  */
903           if (COND_EXPR_THEN (node)
904               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
905                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
906               && COND_EXPR_ELSE (node)
907               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
908                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
909             {
910               pp_space (buffer);
911               dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
912               pp_string (buffer, " else ");
913               dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
914             }
915           else if (!(flags & TDF_SLIM))
916             {
917               /* Output COND_EXPR_THEN.  */
918               if (COND_EXPR_THEN (node))
919                 {
920                   newline_and_indent (buffer, spc+2);
921                   pp_character (buffer, '{');
922                   newline_and_indent (buffer, spc+4);
923                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
924                                      flags, true);
925                   newline_and_indent (buffer, spc+2);
926                   pp_character (buffer, '}');
927                 }
928 
 929               /* Output COND_EXPR_ELSE.  */
930               if (COND_EXPR_ELSE (node))
931                 {
932                   newline_and_indent (buffer, spc);
933                   pp_string (buffer, "else");
934                   newline_and_indent (buffer, spc+2);
935                   pp_character (buffer, '{');
936                   newline_and_indent (buffer, spc+4);
937                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
938                                      flags, true);
939                   newline_and_indent (buffer, spc+2);
940                   pp_character (buffer, '}');
941                 }
942             }
943           is_expr = false;
944         }
945       else
946         {
947           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
948           pp_space (buffer);
949           pp_character (buffer, '?');
950           pp_space (buffer);
951           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
952           pp_space (buffer);
953           pp_character (buffer, ':');
954           pp_space (buffer);
955           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
956         }
957       break;
958 
959     case BIND_EXPR:
960       pp_character (buffer, '{');
961       if (!(flags & TDF_SLIM))
962         {
963           if (BIND_EXPR_VARS (node))
964             {
965               pp_newline (buffer);
966 
967               for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
968                 {
969                   print_declaration (buffer, op0, spc+2, flags);
970                   pp_newline (buffer);
971                 }
972             }
973 
974           newline_and_indent (buffer, spc+2);
975           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
976           newline_and_indent (buffer, spc);
977           pp_character (buffer, '}');
978         }
979       is_expr = false;
980       break;
981 
982     case CALL_EXPR:
983       print_call_name (buffer, node);
984 
 985       /* Print parameters.  */
986       pp_space (buffer);
987       pp_character (buffer, '(');
988       op1 = TREE_OPERAND (node, 1);
989       if (op1)
990         dump_generic_node (buffer, op1, spc, flags, false);
991       pp_character (buffer, ')');
992 
993       op1 = TREE_OPERAND (node, 2);
994       if (op1)
995         {
996           pp_string (buffer, " [static-chain: ");
997           dump_generic_node (buffer, op1, spc, flags, false);
998           pp_character (buffer, ']');
999         }
1000 
1001       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1002         pp_string (buffer, " [return slot optimization]");
1003       if (CALL_EXPR_TAILCALL (node))
1004         pp_string (buffer, " [tail call]");
1005       break;
1006 
1007     case WITH_CLEANUP_EXPR:
1008       NIY;
1009       break;
1010 
1011     case CLEANUP_POINT_EXPR:
1012       pp_string (buffer, "<<cleanup_point ");
1013       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1014       pp_string (buffer, ">>");
1015       break;
1016 
1017     case PLACEHOLDER_EXPR:
1018       pp_string (buffer, "<PLACEHOLDER_EXPR ");
1019       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1020       pp_character (buffer, '>');
1021       break;
1022 
 1023       /* Binary arithmetic and logic expressions.  */
1024     case MULT_EXPR:
1025     case PLUS_EXPR:
1026     case MINUS_EXPR:
1027     case TRUNC_DIV_EXPR:
1028     case CEIL_DIV_EXPR:
1029     case FLOOR_DIV_EXPR:
1030     case ROUND_DIV_EXPR:
1031     case TRUNC_MOD_EXPR:
1032     case CEIL_MOD_EXPR:
1033     case FLOOR_MOD_EXPR:
1034     case ROUND_MOD_EXPR:
1035     case RDIV_EXPR:
1036     case EXACT_DIV_EXPR:
1037     case LSHIFT_EXPR:
1038     case RSHIFT_EXPR:
1039     case LROTATE_EXPR:
1040     case RROTATE_EXPR:
1041     case VEC_LSHIFT_EXPR:
1042     case VEC_RSHIFT_EXPR:
1043     case BIT_IOR_EXPR:
1044     case BIT_XOR_EXPR:
1045     case BIT_AND_EXPR:
1046     case TRUTH_ANDIF_EXPR:
1047     case TRUTH_ORIF_EXPR:
1048     case TRUTH_AND_EXPR:
1049     case TRUTH_OR_EXPR:
1050     case TRUTH_XOR_EXPR:
1051     case LT_EXPR:
1052     case LE_EXPR:
1053     case GT_EXPR:
1054     case GE_EXPR:
1055     case EQ_EXPR:
1056     case NE_EXPR:
1057     case UNLT_EXPR:
1058     case UNLE_EXPR:
1059     case UNGT_EXPR:
1060     case UNGE_EXPR:
1061     case UNEQ_EXPR:
1062     case LTGT_EXPR:
1063     case ORDERED_EXPR:
1064     case UNORDERED_EXPR:
1065       {
1066         const char *op = op_symbol (node);
1067         op0 = TREE_OPERAND (node, 0);
1068         op1 = TREE_OPERAND (node, 1);
1069 
 1070         /* When the operands are expressions with less priority,
 1071            keep semantics of the tree representation.  */
1072         if (op_prio (op0) < op_prio (node))
1073           {
1074             pp_character (buffer, '(');
1075             dump_generic_node (buffer, op0, spc, flags, false);
1076             pp_character (buffer, ')');
1077           }
1078         else
1079           dump_generic_node (buffer, op0, spc, flags, false);
1080 
1081         pp_space (buffer);
1082         pp_string (buffer, op);
1083         pp_space (buffer);
1084 
 1085         /* When the operands are expressions with less priority,
 1086            keep semantics of the tree representation.  */
1087         if (op_prio (op1) < op_prio (node))
1088           {
1089             pp_character (buffer, '(');
1090             dump_generic_node (buffer, op1, spc, flags, false);
1091             pp_character (buffer, ')');
1092           }
1093         else
1094           dump_generic_node (buffer, op1, spc, flags, false);
1095       }
1096       break;
1097 
 1098       /* Unary arithmetic and logic expressions.  */
1099     case NEGATE_EXPR:
1100     case BIT_NOT_EXPR:
1101     case TRUTH_NOT_EXPR:
1102     case ADDR_EXPR:
1103     case PREDECREMENT_EXPR:
1104     case PREINCREMENT_EXPR:
1105     case ALIGN_INDIRECT_REF:
1106     case MISALIGNED_INDIRECT_REF:
1107     case INDIRECT_REF:
1108       if (TREE_CODE (node) == ADDR_EXPR
1109           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1110               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1111         ;       /* Do not output '&' for strings and function pointers.  */
1112       else
1113         pp_string (buffer, op_symbol (node));
1114 
1115       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1116         {
1117           pp_character (buffer, '(');
1118           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1119           pp_character (buffer, ')');
1120         }
1121       else
1122         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1123 
1124       if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1125         {
1126           pp_string (buffer, "{misalignment: ");
1127           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1128           pp_character (buffer, '}');
1129         }
1130       break;
1131 
1132     case POSTDECREMENT_EXPR:
1133     case POSTINCREMENT_EXPR:
1134       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1135         {
1136           pp_character (buffer, '(');
1137           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1138           pp_character (buffer, ')');
1139         }
1140       else
1141         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1142       pp_string (buffer, op_symbol (node));
1143       break;
1144 
1145     case MIN_EXPR:
1146       pp_string (buffer, "MIN_EXPR <");
1147       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1148       pp_string (buffer, ", ");
1149       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1150       pp_character (buffer, '>');
1151       break;
1152 
1153     case MAX_EXPR:
1154       pp_string (buffer, "MAX_EXPR <");
1155       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1156       pp_string (buffer, ", ");
1157       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1158       pp_character (buffer, '>');
1159       break;
1160 
1161     case ABS_EXPR:
1162       pp_string (buffer, "ABS_EXPR <");
1163       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1164       pp_character (buffer, '>');
1165       break;
1166 
1167     case RANGE_EXPR:
1168       NIY;
1169       break;
1170 
1171     case FIX_TRUNC_EXPR:
1172     case FIX_CEIL_EXPR:
1173     case FIX_FLOOR_EXPR:
1174     case FIX_ROUND_EXPR:
1175     case FLOAT_EXPR:
1176     case CONVERT_EXPR:
1177     case NOP_EXPR:
1178       type = TREE_TYPE (node);
1179       op0 = TREE_OPERAND (node, 0);
1180       if (type != TREE_TYPE (op0))
1181         {
1182           pp_character (buffer, '(');
1183           dump_generic_node (buffer, type, spc, flags, false);
1184           pp_string (buffer, ") ");
1185         }
1186       if (op_prio (op0) < op_prio (node))
1187         pp_character (buffer, '(');
1188       dump_generic_node (buffer, op0, spc, flags, false);
1189       if (op_prio (op0) < op_prio (node))
1190         pp_character (buffer, ')');
1191       break;
1192 
1193     case VIEW_CONVERT_EXPR:
1194       pp_string (buffer, "VIEW_CONVERT_EXPR<");
1195       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1196       pp_string (buffer, ">(");
1197       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1198       pp_character (buffer, ')');
1199       break;
1200 
1201     case NON_LVALUE_EXPR:
1202       pp_string (buffer, "NON_LVALUE_EXPR <");
1203       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1204       pp_character (buffer, '>');
1205       break;
1206 
1207     case SAVE_EXPR:
1208       pp_string (buffer, "SAVE_EXPR <");
1209       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1210       pp_character (buffer, '>');
1211       break;
1212 
1213     case COMPLEX_EXPR:
1214       pp_string (buffer, "COMPLEX_EXPR <");
1215       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1216       pp_string (buffer, ", ");
1217       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1218       pp_string (buffer, ">");
1219       break;
1220 
1221     case CONJ_EXPR:
1222       pp_string (buffer, "CONJ_EXPR <");
1223       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1224       pp_string (buffer, ">");
1225       break;
1226 
1227     case REALPART_EXPR:
1228       pp_string (buffer, "REALPART_EXPR <");
1229       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1230       pp_string (buffer, ">");
1231       break;
1232 
1233     case IMAGPART_EXPR:
1234       pp_string (buffer, "IMAGPART_EXPR <");
1235       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1236       pp_string (buffer, ">");
1237       break;
1238 
1239     case VA_ARG_EXPR:
1240       pp_string (buffer, "VA_ARG_EXPR <");
1241       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1242       pp_string (buffer, ">");
1243       break;
1244 
1245     case TRY_FINALLY_EXPR:
1246     case TRY_CATCH_EXPR:
1247       pp_string (buffer, "try");
1248       newline_and_indent (buffer, spc+2);
1249       pp_string (buffer, "{");
1250       newline_and_indent (buffer, spc+4);
1251       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1252       newline_and_indent (buffer, spc+2);
1253       pp_string (buffer, "}");
1254       newline_and_indent (buffer, spc);
1255       pp_string (buffer,
1256                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1257       newline_and_indent (buffer, spc+2);
1258       pp_string (buffer, "{");
1259       newline_and_indent (buffer, spc+4);
1260       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1261       newline_and_indent (buffer, spc+2);
1262       pp_string (buffer, "}");
1263       is_expr = false;
1264       break;
1265 
1266     case CATCH_EXPR:
1267       pp_string (buffer, "catch (");
1268       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1269       pp_string (buffer, ")");
1270       newline_and_indent (buffer, spc+2);
1271       pp_string (buffer, "{");
1272       newline_and_indent (buffer, spc+4);
1273       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1274       newline_and_indent (buffer, spc+2);
1275       pp_string (buffer, "}");
1276       is_expr = false;
1277       break;
1278 
1279     case EH_FILTER_EXPR:
1280       pp_string (buffer, "<<<eh_filter (");
1281       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1282       pp_string (buffer, ")>>>");
1283       newline_and_indent (buffer, spc+2);
1284       pp_string (buffer, "{");
1285       newline_and_indent (buffer, spc+4);
1286       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1287       newline_and_indent (buffer, spc+2);
1288       pp_string (buffer, "}");
1289       is_expr = false;
1290       break;
1291 
1292     case LABEL_EXPR:
1293       op0 = TREE_OPERAND (node, 0);
 1294       /* If this is for break or continue, don't bother printing it.  */
1295       if (DECL_NAME (op0))
1296         {
1297           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1298           if (strcmp (name, "break") == 0
1299               || strcmp (name, "continue") == 0)
1300             break;
1301         }
1302       dump_generic_node (buffer, op0, spc, flags, false);
1303       pp_character (buffer, ':');
1304       if (DECL_NONLOCAL (op0))
1305         pp_string (buffer, " [non-local]");
1306       break;
1307 
1308     case EXC_PTR_EXPR:
1309       pp_string (buffer, "<<<exception object>>>");
1310       break;
1311 
1312     case FILTER_EXPR:
1313       pp_string (buffer, "<<<filter object>>>");
1314       break;
1315 
1316     case LOOP_EXPR:
1317       pp_string (buffer, "while (1)");
1318       if (!(flags & TDF_SLIM))
1319         {
1320           newline_and_indent (buffer, spc+2);
1321           pp_character (buffer, '{');
1322           newline_and_indent (buffer, spc+4);
1323           dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1324           newline_and_indent (buffer, spc+2);
1325           pp_character (buffer, '}');
1326         }
1327       is_expr = false;
1328       break;
1329 
1330     case RETURN_EXPR:
1331       pp_string (buffer, "return");
1332       op0 = TREE_OPERAND (node, 0);
1333       if (op0)
1334         {
1335           pp_space (buffer);
1336           if (TREE_CODE (op0) == MODIFY_EXPR)
1337             dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1338           else
1339             dump_generic_node (buffer, op0, spc, flags, false);
1340         }
1341       break;
1342 
1343     case EXIT_EXPR:
1344       pp_string (buffer, "if (");
1345       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1346       pp_string (buffer, ") break");
1347       break;
1348 
1349     case SWITCH_EXPR:
1350       pp_string (buffer, "switch (");
1351       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1352       pp_character (buffer, ')');
1353       if (!(flags & TDF_SLIM))
1354         {
1355           newline_and_indent (buffer, spc+2);
1356           pp_character (buffer, '{');
1357           if (SWITCH_BODY (node))
1358             {
1359               newline_and_indent (buffer, spc+4);
1360               dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1361             }
1362           else
1363             {
1364               tree vec = SWITCH_LABELS (node);
1365               size_t i, n = TREE_VEC_LENGTH (vec);
1366               for (i = 0; i < n; ++i)
1367                 {
1368                   tree elt = TREE_VEC_ELT (vec, i);
1369                   newline_and_indent (buffer, spc+4);
1370                   dump_generic_node (buffer, elt, spc+4, flags, false);
1371                   pp_string (buffer, " goto ");
1372                   dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1373                   pp_semicolon (buffer);
1374                 }
1375             }
1376           newline_and_indent (buffer, spc+2);
1377           pp_character (buffer, '}');
1378         }
1379       is_expr = false;
1380       break;
1381 
1382     case GOTO_EXPR:
1383       op0 = GOTO_DESTINATION (node);
1384       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1385         {
1386           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1387           if (strcmp (name, "break") == 0
1388               || strcmp (name, "continue") == 0)
1389             {
1390               pp_string (buffer, name);
1391               break;
1392             }
1393         }
1394       pp_string (buffer, "goto ");
1395       dump_generic_node (buffer, op0, spc, flags, false);
1396       break;
1397 
1398     case RESX_EXPR:
1399       pp_string (buffer, "resx");
1400       /* ??? Any sensible way to present the eh region?  */
1401       break;
1402 
1403     case ASM_EXPR:
1404       pp_string (buffer, "__asm__");
1405       if (ASM_VOLATILE_P (node))
1406         pp_string (buffer, " __volatile__");
1407       pp_character (buffer, '(');
1408       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1409       pp_character (buffer, ':');
1410       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1411       pp_character (buffer, ':');
1412       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1413       if (ASM_CLOBBERS (node))
1414         {
1415           pp_character (buffer, ':');
1416           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1417         }
1418       pp_string (buffer, ")");
1419       break;
1420 
1421     case CASE_LABEL_EXPR:
1422       if (CASE_LOW (node) && CASE_HIGH (node))
1423         {
1424           pp_string (buffer, "case ");
1425           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1426           pp_string (buffer, " ... ");
1427           dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1428         }
1429       else if (CASE_LOW (node))
1430         {
1431           pp_string (buffer, "case ");
1432           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1433         }
1434       else
1435         pp_string (buffer, "default ");
1436       pp_character (buffer, ':');
1437       break;
1438 
1439     case OBJ_TYPE_REF:
1440       pp_string (buffer, "OBJ_TYPE_REF(");
1441       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1442       pp_character (buffer, ';');
1443       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1444       pp_character (buffer, '-');
1445       pp_character (buffer, '>');
1446       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1447       pp_character (buffer, ')');
1448       break;
1449 
1450     case PHI_NODE:
1451       {
1452         int i;
1453 
1454         dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1455         pp_string (buffer, " = PHI <");
1456         for (i = 0; i < PHI_NUM_ARGS (node); i++)
1457           {
1458             dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1459             pp_string (buffer, "(");
1460             pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1461             pp_string (buffer, ")");
1462             if (i < PHI_NUM_ARGS (node) - 1)
1463               pp_string (buffer, ", ");
1464           }
1465         pp_string (buffer, ">;");
1466       }
1467       break;
1468 
1469     case SSA_NAME:
1470       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1471       pp_string (buffer, "_");
1472       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1473       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1474         pp_string (buffer, "(ab)");
1475       break;
1476 
1477     case WITH_SIZE_EXPR:
1478       pp_string (buffer, "WITH_SIZE_EXPR <");
1479       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1480       pp_string (buffer, ", ");
1481       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1482       pp_string (buffer, ">");
1483       break;
1484 
1485     case VALUE_HANDLE:
1486       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1487       break;
1488 
1489     case ASSERT_EXPR:
1490       pp_string (buffer, "ASSERT_EXPR <");
1491       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1492       pp_string (buffer, ", ");
1493       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1494       pp_string (buffer, ">");
1495       break;
1496 
1497     case SCEV_KNOWN:
1498       pp_string (buffer, "scev_known");
1499       break;
1500 
1501     case SCEV_NOT_KNOWN:
1502       pp_string (buffer, "scev_not_known");
1503       break;
1504 
1505     case POLYNOMIAL_CHREC:
1506       pp_string (buffer, "{");
1507       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1508       pp_string (buffer, ", +, ");
1509       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1510       pp_string (buffer, "}_");
1511       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1512       is_stmt = false;
1513       break;
1514 
1515     case REALIGN_LOAD_EXPR:
1516       pp_string (buffer, "REALIGN_LOAD <");
1517       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1518       pp_string (buffer, ", ");
1519       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1520       pp_string (buffer, ", ");
1521       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1522       pp_string (buffer, ">");
1523       break;
1524       
1525     case VEC_COND_EXPR:
1526       pp_string (buffer, " VEC_COND_EXPR < ");
1527       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1528       pp_string (buffer, " , ");
1529       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1530       pp_string (buffer, " , ");
1531       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1532       pp_string (buffer, " > ");
1533       break;
1534 
1535     case REDUC_MAX_EXPR:
1536       pp_string (buffer, " REDUC_MAX_EXPR < ");
1537       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1538       pp_string (buffer, " > ");
1539       break;
1540 
1541     case REDUC_MIN_EXPR:
1542       pp_string (buffer, " REDUC_MIN_EXPR < ");
1543       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1544       pp_string (buffer, " > ");
1545       break;
1546 
1547     case REDUC_PLUS_EXPR:
1548       pp_string (buffer, " REDUC_PLUS_EXPR < ");
1549       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1550       pp_string (buffer, " > ");
1551       break;
1552 
1553     default:
1554       NIY;
1555     }
1556
== *長いswitchここまで  ==

1557   if (is_stmt && is_expr)
1558     pp_semicolon (buffer);
1559   pp_write_text_to_stream (buffer);
1560 
1561   return spc;
1562 }


リンク元