gcc/c-dump.c

   1 /* Tree-dumping functionality for C-family languages.
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3    Written by Mark Mitchell <mark@codesourcery.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "c-tree.h"
  28 #include "tree-dump.h"
  29
  30 /* Dump information common to statements from STMT.  */
  31
  32 void
  33 dump_stmt (dump_info_p di, tree t)
  34 {
  35   location_t *locus = EXPR_LOCUS (t);
  36   if (locus)
  37     dump_int (di, "line", locus->line);
  38 }
  39
  40 /* Dump the next statement after STMT.  */
  41
  42 void
  43 dump_next_stmt (dump_info_p di, tree t)
  44 {
  45   dump_child ("next", TREE_CHAIN (t));
  46 }
  47
  48 /* Dump any C-specific tree codes and attributes of common codes.  */
  49
  50 bool
  51 c_dump_tree (void *dump_info, tree t)
  52 {
  53   enum tree_code code;
  54   dump_info_p di = (dump_info_p) dump_info;
  55
  56   /* Figure out what kind of node this is.  */
  57   code = TREE_CODE (t);
  58
  59   switch (code)
  60     {
  61     case FIELD_DECL:
  62       if (DECL_C_BIT_FIELD (t))
  63         dump_string (di, "bitfield");
  64       break;
  65
  66     case ASM_STMT:
  67       dump_stmt (di, t);
  68       if (ASM_VOLATILE_P (t))
  69         dump_string (di, "volatile");
  70       dump_child ("strg", ASM_STRING (t));
  71       dump_child ("outs", ASM_OUTPUTS (t));
  72       dump_child ("ins", ASM_INPUTS (t));
  73       dump_child ("clbr", ASM_CLOBBERS (t));
  74       dump_next_stmt (di, t);
  75       break;
  76
  77     case BREAK_STMT:
  78     case CONTINUE_STMT:
  79       dump_stmt (di, t);
  80       dump_next_stmt (di, t);
  81       break;
  82
  83     case CASE_LABEL:
  84       /* Note that a case label is not like other statements; there is
  85          no way to get the line-number of a case label.  */
  86       dump_child ("low", CASE_LOW (t));
  87       dump_child ("high", CASE_HIGH (t));
  88       dump_next_stmt (di, t);
  89       break;
  90
  91     case CLEANUP_STMT:
  92       dump_stmt (di, t);
  93       dump_child ("decl", CLEANUP_DECL (t));
  94       dump_child ("expr", CLEANUP_EXPR (t));
  95       dump_next_stmt (di, t);
  96       break;
  97
  98     case COMPOUND_STMT:
  99       dump_stmt (di, t);
 100       dump_child ("body", COMPOUND_BODY (t));
 101       dump_next_stmt (di, t);
 102       break;
 103
 104     case DECL_STMT:
 105       dump_stmt (di, t);
 106       dump_child ("decl", DECL_STMT_DECL (t));
 107       dump_next_stmt (di, t);
 108       break;
 109
 110     case DO_STMT:
 111       dump_stmt (di, t);
 112       dump_child ("body", DO_BODY (t));
 113       dump_child ("cond", DO_COND (t));
 114       dump_next_stmt (di, t);
 115       break;
 116
 117     case EXPR_STMT:
 118       dump_stmt (di, t);
 119       dump_child ("expr", EXPR_STMT_EXPR (t));
 120       dump_next_stmt (di, t);
 121       break;
 122
 123     case FOR_STMT:
 124       dump_stmt (di, t);
 125       dump_child ("init", FOR_INIT_STMT (t));
 126       dump_child ("cond", FOR_COND (t));
 127       dump_child ("expr", FOR_EXPR (t));
 128       dump_child ("body", FOR_BODY (t));
 129       dump_next_stmt (di, t);
 130       break;
 131
 132     case GOTO_STMT:
 133       dump_stmt (di, t);
 134       dump_child ("dest", GOTO_DESTINATION (t));
 135       dump_next_stmt (di, t);
 136       break;
 137
 138     case IF_STMT:
 139       dump_stmt (di, t);
 140       dump_child ("cond", IF_COND (t));
 141       dump_child ("then", THEN_CLAUSE (t));
 142       dump_child ("else", ELSE_CLAUSE (t));
 143       dump_next_stmt (di, t);
 144       break;
 145
 146     case LABEL_STMT:
 147       dump_stmt (di, t);
 148       dump_child ("labl", LABEL_STMT_LABEL (t));
 149       dump_next_stmt (di, t);
 150       break;
 151
 152     case RETURN_STMT:
 153       dump_stmt (di, t);
 154       dump_child ("expr", RETURN_STMT_EXPR (t));
 155       dump_next_stmt (di, t);
 156       break;
 157
 158     case SWITCH_STMT:
 159       dump_stmt (di, t);
 160       dump_child ("cond", SWITCH_COND (t));
 161       dump_child ("body", SWITCH_BODY (t));
 162       dump_next_stmt (di, t);
 163       break;
 164
 165     case WHILE_STMT:
 166       dump_stmt (di, t);
 167       dump_child ("cond", WHILE_COND (t));
 168       dump_child ("body", WHILE_BODY (t));
 169       dump_next_stmt (di, t);
 170       break;
 171
 172     case SCOPE_STMT:
 173       dump_stmt (di, t);
 174       if (SCOPE_BEGIN_P (t))
 175         dump_string (di, "begn");
 176       else
 177         dump_string (di, "end");
 178       if (SCOPE_NULLIFIED_P (t))
 179         dump_string (di, "null");
 180       if (!SCOPE_NO_CLEANUPS_P (t))
 181         dump_string (di, "clnp");
 182       dump_next_stmt (di, t);
 183       break;
 184
 185     case STMT_EXPR:
 186       dump_child ("stmt", STMT_EXPR_STMT (t));
 187       break;
 188
 189     default:
 190       break;
 191     }
 192
 193   return false;
 194 }