Mercurial > hg > CbC > CbC_gcc
annotate gcc/print-tree.c @ 60:bd49c42ec43e
remove unnecessary files
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 15 Feb 2010 17:39:45 +0900 |
| parents | 77e2b8dfacca |
| children | b7f97abdc517 |
| rev | line source |
|---|---|
| 0 | 1 /* Prints out tree in human readable form - GCC |
| 2 Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
4 Free Software Foundation, Inc. |
| 0 | 5 |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify it under | |
| 9 the terms of the GNU General Public License as published by the Free | |
| 10 Software Foundation; either version 3, or (at your option) any later | |
| 11 version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 | |
| 23 #include "config.h" | |
| 24 #include "system.h" | |
| 25 #include "coretypes.h" | |
| 26 #include "tm.h" | |
| 27 #include "tree.h" | |
| 28 #include "real.h" | |
| 29 #include "fixed-value.h" | |
| 30 #include "ggc.h" | |
| 31 #include "langhooks.h" | |
| 32 #include "tree-iterator.h" | |
| 33 #include "diagnostic.h" | |
| 34 #include "tree-flow.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
35 #include "tree-pass.h" |
| 0 | 36 |
| 37 /* Define the hash table of nodes already seen. | |
| 38 Such nodes are not repeated; brief cross-references are used. */ | |
| 39 | |
| 40 #define HASH_SIZE 37 | |
| 41 | |
| 42 struct bucket | |
| 43 { | |
| 44 tree node; | |
| 45 struct bucket *next; | |
| 46 }; | |
| 47 | |
| 48 static struct bucket **table; | |
| 49 | |
| 50 /* Print the node NODE on standard error, for debugging. | |
| 51 Most nodes referred to by this one are printed recursively | |
| 52 down to a depth of six. */ | |
| 53 | |
| 54 void | |
| 55 debug_tree (tree node) | |
| 56 { | |
| 57 table = XCNEWVEC (struct bucket *, HASH_SIZE); | |
| 58 print_node (stderr, "", node, 0); | |
| 59 free (table); | |
| 60 table = 0; | |
| 61 putc ('\n', stderr); | |
| 62 } | |
| 63 | |
| 64 /* Print PREFIX and ADDR to FILE. */ | |
| 65 void | |
| 66 dump_addr (FILE *file, const char *prefix, const void *addr) | |
| 67 { | |
| 68 if (flag_dump_noaddr || flag_dump_unnumbered) | |
| 69 fprintf (file, "%s#", prefix); | |
| 70 else | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
71 fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr); |
| 0 | 72 } |
| 73 | |
| 74 /* Print a node in brief fashion, with just the code, address and name. */ | |
| 75 | |
| 76 void | |
| 77 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) | |
| 78 { | |
| 79 enum tree_code_class tclass; | |
| 80 | |
| 81 if (node == 0) | |
| 82 return; | |
| 83 | |
| 84 tclass = TREE_CODE_CLASS (TREE_CODE (node)); | |
| 85 | |
| 86 /* Always print the slot this node is in, and its code, address and | |
| 87 name if any. */ | |
| 88 if (indent > 0) | |
| 89 fprintf (file, " "); | |
| 90 fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]); | |
| 91 dump_addr (file, " ", node); | |
| 92 | |
| 93 if (tclass == tcc_declaration) | |
| 94 { | |
| 95 if (DECL_NAME (node)) | |
| 96 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); | |
| 97 else if (TREE_CODE (node) == LABEL_DECL | |
| 98 && LABEL_DECL_UID (node) != -1) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
99 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
100 if (dump_flags & TDF_NOUID) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
101 fprintf (file, " L.xxxx"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
102 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
104 } |
| 0 | 105 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
107 if (dump_flags & TDF_NOUID) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
108 fprintf (file, " %c.xxxx", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
109 TREE_CODE (node) == CONST_DECL ? 'C' : 'D'); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
110 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
111 fprintf (file, " %c.%u", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
112 TREE_CODE (node) == CONST_DECL ? 'C' : 'D', |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
113 DECL_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
114 } |
| 0 | 115 } |
| 116 else if (tclass == tcc_type) | |
| 117 { | |
| 118 if (TYPE_NAME (node)) | |
| 119 { | |
| 120 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) | |
| 121 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); | |
| 122 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL | |
| 123 && DECL_NAME (TYPE_NAME (node))) | |
| 124 fprintf (file, " %s", | |
| 125 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); | |
| 126 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
127 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
128 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node)); |
| 0 | 129 } |
| 130 if (TREE_CODE (node) == IDENTIFIER_NODE) | |
| 131 fprintf (file, " %s", IDENTIFIER_POINTER (node)); | |
| 132 | |
| 133 /* We might as well always print the value of an integer or real. */ | |
| 134 if (TREE_CODE (node) == INTEGER_CST) | |
| 135 { | |
| 136 if (TREE_OVERFLOW (node)) | |
| 137 fprintf (file, " overflow"); | |
| 138 | |
| 139 fprintf (file, " "); | |
| 140 if (TREE_INT_CST_HIGH (node) == 0) | |
| 141 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, TREE_INT_CST_LOW (node)); | |
| 142 else if (TREE_INT_CST_HIGH (node) == -1 | |
| 143 && TREE_INT_CST_LOW (node) != 0) | |
| 144 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED, | |
| 145 -TREE_INT_CST_LOW (node)); | |
| 146 else | |
| 147 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, | |
| 148 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (node), | |
| 149 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (node)); | |
| 150 } | |
| 151 if (TREE_CODE (node) == REAL_CST) | |
| 152 { | |
| 153 REAL_VALUE_TYPE d; | |
| 154 | |
| 155 if (TREE_OVERFLOW (node)) | |
| 156 fprintf (file, " overflow"); | |
| 157 | |
| 158 d = TREE_REAL_CST (node); | |
| 159 if (REAL_VALUE_ISINF (d)) | |
| 160 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); | |
| 161 else if (REAL_VALUE_ISNAN (d)) | |
| 162 fprintf (file, " Nan"); | |
| 163 else | |
| 164 { | |
| 165 char string[60]; | |
| 166 real_to_decimal (string, &d, sizeof (string), 0, 1); | |
| 167 fprintf (file, " %s", string); | |
| 168 } | |
| 169 } | |
| 170 if (TREE_CODE (node) == FIXED_CST) | |
| 171 { | |
| 172 FIXED_VALUE_TYPE f; | |
| 173 char string[60]; | |
| 174 | |
| 175 if (TREE_OVERFLOW (node)) | |
| 176 fprintf (file, " overflow"); | |
| 177 | |
| 178 f = TREE_FIXED_CST (node); | |
| 179 fixed_to_decimal (string, &f, sizeof (string)); | |
| 180 fprintf (file, " %s", string); | |
| 181 } | |
| 182 | |
| 183 fprintf (file, ">"); | |
| 184 } | |
| 185 | |
| 186 void | |
| 187 indent_to (FILE *file, int column) | |
| 188 { | |
| 189 int i; | |
| 190 | |
| 191 /* Since this is the long way, indent to desired column. */ | |
| 192 if (column > 0) | |
| 193 fprintf (file, "\n"); | |
| 194 for (i = 0; i < column; i++) | |
| 195 fprintf (file, " "); | |
| 196 } | |
| 197 | |
| 198 /* Print the node NODE in full on file FILE, preceded by PREFIX, | |
| 199 starting in column INDENT. */ | |
| 200 | |
| 201 void | |
| 202 print_node (FILE *file, const char *prefix, tree node, int indent) | |
| 203 { | |
| 204 int hash; | |
| 205 struct bucket *b; | |
| 206 enum machine_mode mode; | |
| 207 enum tree_code_class tclass; | |
| 208 int len; | |
| 209 int i; | |
| 210 expanded_location xloc; | |
| 211 enum tree_code code; | |
| 212 | |
| 213 if (node == 0) | |
| 214 return; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
215 |
| 0 | 216 code = TREE_CODE (node); |
| 217 tclass = TREE_CODE_CLASS (code); | |
| 218 | |
| 219 /* Don't get too deep in nesting. If the user wants to see deeper, | |
| 220 it is easy to use the address of a lowest-level node | |
| 221 as an argument in another call to debug_tree. */ | |
| 222 | |
| 223 if (indent > 24) | |
| 224 { | |
| 225 print_node_brief (file, prefix, node, indent); | |
| 226 return; | |
| 227 } | |
| 228 | |
| 229 if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration)) | |
| 230 { | |
| 231 print_node_brief (file, prefix, node, indent); | |
| 232 return; | |
| 233 } | |
| 234 | |
| 235 /* It is unsafe to look at any other fields of an ERROR_MARK node. */ | |
| 236 if (code == ERROR_MARK) | |
| 237 { | |
| 238 print_node_brief (file, prefix, node, indent); | |
| 239 return; | |
| 240 } | |
| 241 | |
| 242 /* Allow this function to be called if the table is not there. */ | |
| 243 if (table) | |
| 244 { | |
| 245 hash = ((unsigned long) node) % HASH_SIZE; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
246 |
| 0 | 247 /* If node is in the table, just mention its address. */ |
| 248 for (b = table[hash]; b; b = b->next) | |
| 249 if (b->node == node) | |
| 250 { | |
| 251 print_node_brief (file, prefix, node, indent); | |
| 252 return; | |
| 253 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
254 |
| 0 | 255 /* Add this node to the table. */ |
| 256 b = XNEW (struct bucket); | |
| 257 b->node = node; | |
| 258 b->next = table[hash]; | |
| 259 table[hash] = b; | |
| 260 } | |
| 261 | |
| 262 /* Indent to the specified column, since this is the long form. */ | |
| 263 indent_to (file, indent); | |
| 264 | |
| 265 /* Print the slot this node is in, and its code, and address. */ | |
| 266 fprintf (file, "%s <%s", prefix, tree_code_name[(int) code]); | |
| 267 dump_addr (file, " ", node); | |
| 268 | |
| 269 /* Print the name, if any. */ | |
| 270 if (tclass == tcc_declaration) | |
| 271 { | |
| 272 if (DECL_NAME (node)) | |
| 273 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); | |
| 274 else if (code == LABEL_DECL | |
| 275 && LABEL_DECL_UID (node) != -1) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
276 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
277 if (dump_flags & TDF_NOUID) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
278 fprintf (file, " L.xxxx"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
279 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
280 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
281 } |
| 0 | 282 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
283 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
284 if (dump_flags & TDF_NOUID) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
285 fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D'); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
286 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
287 fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D', |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
288 DECL_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
289 } |
| 0 | 290 } |
| 291 else if (tclass == tcc_type) | |
| 292 { | |
| 293 if (TYPE_NAME (node)) | |
| 294 { | |
| 295 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) | |
| 296 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); | |
| 297 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL | |
| 298 && DECL_NAME (TYPE_NAME (node))) | |
| 299 fprintf (file, " %s", | |
| 300 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); | |
| 301 } | |
| 302 } | |
| 303 if (code == IDENTIFIER_NODE) | |
| 304 fprintf (file, " %s", IDENTIFIER_POINTER (node)); | |
| 305 | |
| 306 if (code == INTEGER_CST) | |
| 307 { | |
| 308 if (indent <= 4) | |
| 309 print_node_brief (file, "type", TREE_TYPE (node), indent + 4); | |
| 310 } | |
| 311 else | |
| 312 { | |
| 313 print_node (file, "type", TREE_TYPE (node), indent + 4); | |
| 314 if (TREE_TYPE (node)) | |
| 315 indent_to (file, indent + 3); | |
| 316 } | |
| 317 | |
| 318 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node)) | |
| 319 fputs (" side-effects", file); | |
| 320 | |
| 321 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node)) | |
| 322 fputs (" readonly", file); | |
| 323 if (!TYPE_P (node) && TREE_CONSTANT (node)) | |
| 324 fputs (" constant", file); | |
| 325 else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node)) | |
| 326 fputs (" sizes-gimplified", file); | |
| 327 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
328 if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
329 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
330 |
| 0 | 331 if (TREE_ADDRESSABLE (node)) |
| 332 fputs (" addressable", file); | |
| 333 if (TREE_THIS_VOLATILE (node)) | |
| 334 fputs (" volatile", file); | |
| 335 if (TREE_ASM_WRITTEN (node)) | |
| 336 fputs (" asm_written", file); | |
| 337 if (TREE_USED (node)) | |
| 338 fputs (" used", file); | |
| 339 if (TREE_NOTHROW (node)) | |
| 340 fputs (TYPE_P (node) ? " align-ok" : " nothrow", file); | |
| 341 if (TREE_PUBLIC (node)) | |
| 342 fputs (" public", file); | |
| 343 if (TREE_PRIVATE (node)) | |
| 344 fputs (" private", file); | |
| 345 if (TREE_PROTECTED (node)) | |
| 346 fputs (" protected", file); | |
| 347 if (TREE_STATIC (node)) | |
| 348 fputs (" static", file); | |
| 349 if (TREE_DEPRECATED (node)) | |
| 350 fputs (" deprecated", file); | |
| 351 if (TREE_VISITED (node)) | |
| 352 fputs (" visited", file); | |
| 353 if (TREE_LANG_FLAG_0 (node)) | |
| 354 fputs (" tree_0", file); | |
| 355 if (TREE_LANG_FLAG_1 (node)) | |
| 356 fputs (" tree_1", file); | |
| 357 if (TREE_LANG_FLAG_2 (node)) | |
| 358 fputs (" tree_2", file); | |
| 359 if (TREE_LANG_FLAG_3 (node)) | |
| 360 fputs (" tree_3", file); | |
| 361 if (TREE_LANG_FLAG_4 (node)) | |
| 362 fputs (" tree_4", file); | |
| 363 if (TREE_LANG_FLAG_5 (node)) | |
| 364 fputs (" tree_5", file); | |
| 365 if (TREE_LANG_FLAG_6 (node)) | |
| 366 fputs (" tree_6", file); | |
| 367 | |
| 368 /* DECL_ nodes have additional attributes. */ | |
| 369 | |
| 370 switch (TREE_CODE_CLASS (code)) | |
| 371 { | |
| 372 case tcc_declaration: | |
| 373 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
| 374 { | |
| 375 if (DECL_UNSIGNED (node)) | |
| 376 fputs (" unsigned", file); | |
| 377 if (DECL_IGNORED_P (node)) | |
| 378 fputs (" ignored", file); | |
| 379 if (DECL_ABSTRACT (node)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
380 fputs (" abstract", file); |
| 0 | 381 if (DECL_EXTERNAL (node)) |
| 382 fputs (" external", file); | |
| 383 if (DECL_NONLOCAL (node)) | |
| 384 fputs (" nonlocal", file); | |
| 385 } | |
| 386 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) | |
| 387 { | |
| 388 if (DECL_WEAK (node)) | |
| 389 fputs (" weak", file); | |
| 390 if (DECL_IN_SYSTEM_HEADER (node)) | |
| 391 fputs (" in_system_header", file); | |
| 392 } | |
| 393 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL) | |
| 394 && code != LABEL_DECL | |
| 395 && code != FUNCTION_DECL | |
| 396 && DECL_REGISTER (node)) | |
| 397 fputs (" regdecl", file); | |
| 398 | |
| 399 if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node)) | |
| 400 fputs (" suppress-debug", file); | |
| 401 | |
| 402 if (code == FUNCTION_DECL | |
| 403 && DECL_FUNCTION_SPECIFIC_TARGET (node)) | |
| 404 fputs (" function-specific-target", file); | |
| 405 if (code == FUNCTION_DECL | |
| 406 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node)) | |
| 407 fputs (" function-specific-opt", file); | |
| 408 if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node)) | |
| 409 fputs (" autoinline", file); | |
| 410 if (code == FUNCTION_DECL && DECL_BUILT_IN (node)) | |
| 411 fputs (" built-in", file); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
412 if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
413 fputs (" static-chain", file); |
| 0 | 414 |
| 415 if (code == FIELD_DECL && DECL_PACKED (node)) | |
| 416 fputs (" packed", file); | |
| 417 if (code == FIELD_DECL && DECL_BIT_FIELD (node)) | |
| 418 fputs (" bit-field", file); | |
| 419 if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node)) | |
| 420 fputs (" nonaddressable", file); | |
| 421 | |
| 422 if (code == LABEL_DECL && DECL_ERROR_ISSUED (node)) | |
| 423 fputs (" error-issued", file); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
424 if (code == LABEL_DECL && EH_LANDING_PAD_NR (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
425 fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node)); |
| 0 | 426 |
| 427 if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node)) | |
| 428 fputs (" in-text-section", file); | |
| 429 if (code == VAR_DECL && DECL_COMMON (node)) | |
| 430 fputs (" common", file); | |
| 431 if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node)) | |
| 432 { | |
| 433 enum tls_model kind = DECL_TLS_MODEL (node); | |
| 434 switch (kind) | |
| 435 { | |
| 436 case TLS_MODEL_GLOBAL_DYNAMIC: | |
| 437 fputs (" tls-global-dynamic", file); | |
| 438 break; | |
| 439 case TLS_MODEL_LOCAL_DYNAMIC: | |
| 440 fputs (" tls-local-dynamic", file); | |
| 441 break; | |
| 442 case TLS_MODEL_INITIAL_EXEC: | |
| 443 fputs (" tls-initial-exec", file); | |
| 444 break; | |
| 445 case TLS_MODEL_LOCAL_EXEC: | |
| 446 fputs (" tls-local-exec", file); | |
| 447 break; | |
| 448 default: | |
| 449 gcc_unreachable (); | |
| 450 } | |
| 451 } | |
| 452 | |
| 453 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
454 { |
| 0 | 455 if (DECL_VIRTUAL_P (node)) |
| 456 fputs (" virtual", file); | |
| 457 if (DECL_PRESERVE_P (node)) | |
| 458 fputs (" preserve", file); | |
| 459 if (DECL_LANG_FLAG_0 (node)) | |
| 460 fputs (" decl_0", file); | |
| 461 if (DECL_LANG_FLAG_1 (node)) | |
| 462 fputs (" decl_1", file); | |
| 463 if (DECL_LANG_FLAG_2 (node)) | |
| 464 fputs (" decl_2", file); | |
| 465 if (DECL_LANG_FLAG_3 (node)) | |
| 466 fputs (" decl_3", file); | |
| 467 if (DECL_LANG_FLAG_4 (node)) | |
| 468 fputs (" decl_4", file); | |
| 469 if (DECL_LANG_FLAG_5 (node)) | |
| 470 fputs (" decl_5", file); | |
| 471 if (DECL_LANG_FLAG_6 (node)) | |
| 472 fputs (" decl_6", file); | |
| 473 if (DECL_LANG_FLAG_7 (node)) | |
| 474 fputs (" decl_7", file); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
475 |
| 0 | 476 mode = DECL_MODE (node); |
| 477 fprintf (file, " %s", GET_MODE_NAME (mode)); | |
| 478 } | |
| 479 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
480 if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
481 && DECL_BY_REFERENCE (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
482 fputs (" passed-by-reference", file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
483 |
| 0 | 484 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node)) |
| 485 fputs (" defer-output", file); | |
| 486 | |
| 487 | |
| 488 xloc = expand_location (DECL_SOURCE_LOCATION (node)); | |
| 489 fprintf (file, " file %s line %d col %d", xloc.file, xloc.line, | |
| 490 xloc.column); | |
| 491 | |
| 492 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 { |
| 0 | 494 print_node (file, "size", DECL_SIZE (node), indent + 4); |
| 495 print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
496 |
| 0 | 497 if (code != FUNCTION_DECL || DECL_BUILT_IN (node)) |
| 498 indent_to (file, indent + 3); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
499 |
| 0 | 500 if (DECL_USER_ALIGN (node)) |
| 501 fprintf (file, " user"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
502 |
| 0 | 503 fprintf (file, " align %d", DECL_ALIGN (node)); |
| 504 if (code == FIELD_DECL) | |
| 505 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED, | |
| 506 DECL_OFFSET_ALIGN (node)); | |
| 507 | |
| 508 if (code == FUNCTION_DECL && DECL_BUILT_IN (node)) | |
| 509 { | |
| 510 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD) | |
| 511 fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node)); | |
| 512 else | |
| 513 fprintf (file, " built-in %s:%s", | |
| 514 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)], | |
| 515 built_in_names[(int) DECL_FUNCTION_CODE (node)]); | |
| 516 } | |
| 517 } | |
| 518 if (code == FIELD_DECL) | |
| 519 { | |
| 520 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4); | |
| 521 print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node), | |
| 522 indent + 4); | |
| 523 if (DECL_BIT_FIELD_TYPE (node)) | |
| 524 print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node), | |
| 525 indent + 4); | |
| 526 } | |
| 527 | |
| 528 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4); | |
| 529 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
530 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) |
| 0 | 531 { |
| 532 print_node_brief (file, "attributes", | |
| 533 DECL_ATTRIBUTES (node), indent + 4); | |
| 534 if (code != PARM_DECL) | |
| 535 print_node_brief (file, "initial", DECL_INITIAL (node), | |
| 536 indent + 4); | |
| 537 } | |
| 538 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) | |
| 539 { | |
| 540 print_node_brief (file, "abstract_origin", | |
| 541 DECL_ABSTRACT_ORIGIN (node), indent + 4); | |
| 542 } | |
| 543 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) | |
| 544 { | |
| 545 print_node (file, "arguments", DECL_ARGUMENT_FLD (node), indent + 4); | |
| 546 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4); | |
| 547 } | |
| 548 | |
| 549 lang_hooks.print_decl (file, node, indent); | |
| 550 | |
| 551 if (DECL_RTL_SET_P (node)) | |
| 552 { | |
| 553 indent_to (file, indent + 4); | |
| 554 print_rtl (file, DECL_RTL (node)); | |
| 555 } | |
| 556 | |
| 557 if (code == PARM_DECL) | |
| 558 { | |
| 559 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4); | |
| 560 | |
| 561 if (DECL_INCOMING_RTL (node) != 0) | |
| 562 { | |
| 563 indent_to (file, indent + 4); | |
| 564 fprintf (file, "incoming-rtl "); | |
| 565 print_rtl (file, DECL_INCOMING_RTL (node)); | |
| 566 } | |
| 567 } | |
| 568 else if (code == FUNCTION_DECL | |
| 569 && DECL_STRUCT_FUNCTION (node) != 0) | |
| 570 { | |
| 571 indent_to (file, indent + 4); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
572 dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node)); |
| 0 | 573 } |
| 574 | |
| 575 if ((code == VAR_DECL || code == PARM_DECL) | |
| 576 && DECL_HAS_VALUE_EXPR_P (node)) | |
| 577 print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4); | |
| 578 | |
| 579 /* Print the decl chain only if decl is at second level. */ | |
| 580 if (indent == 4) | |
| 581 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 582 else | |
| 583 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 584 break; | |
| 585 | |
| 586 case tcc_type: | |
| 587 if (TYPE_UNSIGNED (node)) | |
| 588 fputs (" unsigned", file); | |
| 589 | |
| 590 /* The no-force-blk flag is used for different things in | |
| 591 different types. */ | |
| 592 if ((code == RECORD_TYPE | |
| 593 || code == UNION_TYPE | |
| 594 || code == QUAL_UNION_TYPE) | |
| 595 && TYPE_NO_FORCE_BLK (node)) | |
| 596 fputs (" no-force-blk", file); | |
| 597 else if (code == INTEGER_TYPE | |
| 598 && TYPE_IS_SIZETYPE (node)) | |
| 599 fputs (" sizetype", file); | |
| 600 | |
| 601 if (TYPE_STRING_FLAG (node)) | |
| 602 fputs (" string-flag", file); | |
| 603 if (TYPE_NEEDS_CONSTRUCTING (node)) | |
| 604 fputs (" needs-constructing", file); | |
| 605 | |
| 606 /* The transparent-union flag is used for different things in | |
| 607 different nodes. */ | |
| 608 if (code == UNION_TYPE && TYPE_TRANSPARENT_UNION (node)) | |
| 609 fputs (" transparent-union", file); | |
| 610 else if (code == ARRAY_TYPE | |
| 611 && TYPE_NONALIASED_COMPONENT (node)) | |
| 612 fputs (" nonaliased-component", file); | |
| 613 | |
| 614 if (TYPE_PACKED (node)) | |
| 615 fputs (" packed", file); | |
| 616 | |
| 617 if (TYPE_RESTRICT (node)) | |
| 618 fputs (" restrict", file); | |
| 619 | |
| 620 if (TYPE_LANG_FLAG_0 (node)) | |
| 621 fputs (" type_0", file); | |
| 622 if (TYPE_LANG_FLAG_1 (node)) | |
| 623 fputs (" type_1", file); | |
| 624 if (TYPE_LANG_FLAG_2 (node)) | |
| 625 fputs (" type_2", file); | |
| 626 if (TYPE_LANG_FLAG_3 (node)) | |
| 627 fputs (" type_3", file); | |
| 628 if (TYPE_LANG_FLAG_4 (node)) | |
| 629 fputs (" type_4", file); | |
| 630 if (TYPE_LANG_FLAG_5 (node)) | |
| 631 fputs (" type_5", file); | |
| 632 if (TYPE_LANG_FLAG_6 (node)) | |
| 633 fputs (" type_6", file); | |
| 634 | |
| 635 mode = TYPE_MODE (node); | |
| 636 fprintf (file, " %s", GET_MODE_NAME (mode)); | |
| 637 | |
| 638 print_node (file, "size", TYPE_SIZE (node), indent + 4); | |
| 639 print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4); | |
| 640 indent_to (file, indent + 3); | |
| 641 | |
| 642 if (TYPE_USER_ALIGN (node)) | |
| 643 fprintf (file, " user"); | |
| 644 | |
| 645 fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC, | |
| 646 TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node), | |
| 647 (HOST_WIDE_INT) TYPE_ALIAS_SET (node)); | |
| 648 | |
| 649 if (TYPE_STRUCTURAL_EQUALITY_P (node)) | |
| 650 fprintf (file, " structural equality"); | |
| 651 else | |
| 652 dump_addr (file, " canonical type ", TYPE_CANONICAL (node)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
653 |
| 0 | 654 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4); |
| 655 | |
| 656 if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE | |
| 657 || code == FIXED_POINT_TYPE) | |
| 658 { | |
| 659 fprintf (file, " precision %d", TYPE_PRECISION (node)); | |
| 660 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4); | |
| 661 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4); | |
| 662 } | |
| 663 | |
| 664 if (code == ENUMERAL_TYPE) | |
| 665 print_node (file, "values", TYPE_VALUES (node), indent + 4); | |
| 666 else if (code == ARRAY_TYPE) | |
| 667 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4); | |
| 668 else if (code == VECTOR_TYPE) | |
| 669 fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node)); | |
| 670 else if (code == RECORD_TYPE | |
| 671 || code == UNION_TYPE | |
| 672 || code == QUAL_UNION_TYPE) | |
| 673 print_node (file, "fields", TYPE_FIELDS (node), indent + 4); | |
| 674 else if (code == FUNCTION_TYPE | |
| 675 || code == METHOD_TYPE) | |
| 676 { | |
| 677 if (TYPE_METHOD_BASETYPE (node)) | |
| 678 print_node_brief (file, "method basetype", | |
| 679 TYPE_METHOD_BASETYPE (node), indent + 4); | |
| 680 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4); | |
| 681 } | |
| 682 else if (code == OFFSET_TYPE) | |
| 683 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node), | |
| 684 indent + 4); | |
| 685 | |
| 686 if (TYPE_CONTEXT (node)) | |
| 687 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4); | |
| 688 | |
| 689 lang_hooks.print_type (file, node, indent); | |
| 690 | |
| 691 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node)) | |
| 692 indent_to (file, indent + 3); | |
| 693 | |
| 694 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), | |
| 695 indent + 4); | |
| 696 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), | |
| 697 indent + 4); | |
| 698 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 699 break; | |
| 700 | |
| 701 case tcc_expression: | |
| 702 case tcc_comparison: | |
| 703 case tcc_unary: | |
| 704 case tcc_binary: | |
| 705 case tcc_reference: | |
| 706 case tcc_statement: | |
| 707 case tcc_vl_exp: | |
| 708 if (code == BIND_EXPR) | |
| 709 { | |
| 710 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4); | |
| 711 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4); | |
| 712 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4); | |
| 713 break; | |
| 714 } | |
| 715 if (code == CALL_EXPR) | |
| 716 { | |
| 717 call_expr_arg_iterator iter; | |
| 718 tree arg; | |
| 719 print_node (file, "fn", CALL_EXPR_FN (node), indent + 4); | |
| 720 print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node), | |
| 721 indent + 4); | |
| 722 i = 0; | |
| 723 FOR_EACH_CALL_EXPR_ARG (arg, iter, node) | |
| 724 { | |
| 725 char temp[10]; | |
| 726 sprintf (temp, "arg %d", i); | |
| 727 print_node (file, temp, arg, indent + 4); | |
| 728 i++; | |
| 729 } | |
| 730 } | |
| 731 else | |
| 732 { | |
| 733 len = TREE_OPERAND_LENGTH (node); | |
| 734 | |
| 735 for (i = 0; i < len; i++) | |
| 736 { | |
| 737 char temp[10]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
738 |
| 0 | 739 sprintf (temp, "arg %d", i); |
| 740 print_node (file, temp, TREE_OPERAND (node, i), indent + 4); | |
| 741 } | |
| 742 } | |
| 743 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 744 break; | |
| 745 | |
| 746 case tcc_constant: | |
| 747 case tcc_exceptional: | |
| 748 switch (code) | |
| 749 { | |
| 750 case INTEGER_CST: | |
| 751 if (TREE_OVERFLOW (node)) | |
| 752 fprintf (file, " overflow"); | |
| 753 | |
| 754 fprintf (file, " "); | |
| 755 if (TREE_INT_CST_HIGH (node) == 0) | |
| 756 fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED, | |
| 757 TREE_INT_CST_LOW (node)); | |
| 758 else if (TREE_INT_CST_HIGH (node) == -1 | |
| 759 && TREE_INT_CST_LOW (node) != 0) | |
| 760 fprintf (file, "-" HOST_WIDE_INT_PRINT_UNSIGNED, | |
| 761 -TREE_INT_CST_LOW (node)); | |
| 762 else | |
| 763 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, | |
| 764 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (node), | |
| 765 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (node)); | |
| 766 break; | |
| 767 | |
| 768 case REAL_CST: | |
| 769 { | |
| 770 REAL_VALUE_TYPE d; | |
| 771 | |
| 772 if (TREE_OVERFLOW (node)) | |
| 773 fprintf (file, " overflow"); | |
| 774 | |
| 775 d = TREE_REAL_CST (node); | |
| 776 if (REAL_VALUE_ISINF (d)) | |
| 777 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); | |
| 778 else if (REAL_VALUE_ISNAN (d)) | |
| 779 fprintf (file, " Nan"); | |
| 780 else | |
| 781 { | |
| 782 char string[64]; | |
| 783 real_to_decimal (string, &d, sizeof (string), 0, 1); | |
| 784 fprintf (file, " %s", string); | |
| 785 } | |
| 786 } | |
| 787 break; | |
| 788 | |
| 789 case FIXED_CST: | |
| 790 { | |
| 791 FIXED_VALUE_TYPE f; | |
| 792 char string[64]; | |
| 793 | |
| 794 if (TREE_OVERFLOW (node)) | |
| 795 fprintf (file, " overflow"); | |
| 796 | |
| 797 f = TREE_FIXED_CST (node); | |
| 798 fixed_to_decimal (string, &f, sizeof (string)); | |
| 799 fprintf (file, " %s", string); | |
| 800 } | |
| 801 break; | |
| 802 | |
| 803 case VECTOR_CST: | |
| 804 { | |
| 805 tree vals = TREE_VECTOR_CST_ELTS (node); | |
| 806 char buf[10]; | |
| 807 tree link; | |
| 808 int i; | |
| 809 | |
| 810 i = 0; | |
| 811 for (link = vals; link; link = TREE_CHAIN (link), ++i) | |
| 812 { | |
| 813 sprintf (buf, "elt%d: ", i); | |
| 814 print_node (file, buf, TREE_VALUE (link), indent + 4); | |
| 815 } | |
| 816 } | |
| 817 break; | |
| 818 | |
| 819 case COMPLEX_CST: | |
| 820 print_node (file, "real", TREE_REALPART (node), indent + 4); | |
| 821 print_node (file, "imag", TREE_IMAGPART (node), indent + 4); | |
| 822 break; | |
| 823 | |
| 824 case STRING_CST: | |
| 825 { | |
| 826 const char *p = TREE_STRING_POINTER (node); | |
| 827 int i = TREE_STRING_LENGTH (node); | |
| 828 fputs (" \"", file); | |
| 829 while (--i >= 0) | |
| 830 { | |
| 831 char ch = *p++; | |
| 832 if (ch >= ' ' && ch < 127) | |
| 833 putc (ch, file); | |
| 834 else | |
| 835 fprintf(file, "\\%03o", ch & 0xFF); | |
| 836 } | |
| 837 fputc ('\"', file); | |
| 838 } | |
| 839 /* Print the chain at second level. */ | |
| 840 if (indent == 4) | |
| 841 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 842 else | |
| 843 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 844 break; | |
| 845 | |
| 846 case IDENTIFIER_NODE: | |
| 847 lang_hooks.print_identifier (file, node, indent); | |
| 848 break; | |
| 849 | |
| 850 case TREE_LIST: | |
| 851 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4); | |
| 852 print_node (file, "value", TREE_VALUE (node), indent + 4); | |
| 853 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 854 break; | |
| 855 | |
| 856 case TREE_VEC: | |
| 857 len = TREE_VEC_LENGTH (node); | |
| 858 for (i = 0; i < len; i++) | |
| 859 if (TREE_VEC_ELT (node, i)) | |
| 860 { | |
| 861 char temp[10]; | |
| 862 sprintf (temp, "elt %d", i); | |
| 863 indent_to (file, indent + 4); | |
| 864 print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0); | |
| 865 } | |
| 866 break; | |
| 867 | |
| 868 case CONSTRUCTOR: | |
| 869 { | |
| 870 unsigned HOST_WIDE_INT cnt; | |
| 871 tree index, value; | |
| 872 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)); | |
| 873 fprintf (file, " lngt %d", len); | |
| 874 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), | |
| 875 cnt, index, value) | |
| 876 { | |
| 877 print_node (file, "idx", index, indent + 4); | |
| 878 print_node (file, "val", value, indent + 4); | |
| 879 } | |
| 880 } | |
| 881 break; | |
| 882 | |
| 883 case STATEMENT_LIST: | |
| 884 dump_addr (file, " head ", node->stmt_list.head); | |
| 885 dump_addr (file, " tail ", node->stmt_list.tail); | |
| 886 fprintf (file, " stmts"); | |
| 887 { | |
| 888 tree_stmt_iterator i; | |
| 889 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i)) | |
| 890 { | |
| 891 /* Not printing the addresses of the (not-a-tree) | |
| 892 'struct tree_stmt_list_node's. */ | |
| 893 dump_addr (file, " ", tsi_stmt (i)); | |
| 894 } | |
| 895 fprintf (file, "\n"); | |
| 896 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i)) | |
| 897 { | |
| 898 /* Not printing the addresses of the (not-a-tree) | |
| 899 'struct tree_stmt_list_node's. */ | |
| 900 print_node (file, "stmt", tsi_stmt (i), indent + 4); | |
| 901 } | |
| 902 } | |
| 903 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 904 break; | |
| 905 | |
| 906 case BLOCK: | |
| 907 print_node (file, "vars", BLOCK_VARS (node), indent + 4); | |
| 908 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), | |
| 909 indent + 4); | |
| 910 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4); | |
| 911 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4); | |
| 912 print_node (file, "abstract_origin", | |
| 913 BLOCK_ABSTRACT_ORIGIN (node), indent + 4); | |
| 914 break; | |
| 915 | |
| 916 case SSA_NAME: | |
| 917 print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4); | |
| 918 fprintf (file, "def_stmt "); | |
| 919 print_gimple_stmt (file, SSA_NAME_DEF_STMT (node), indent + 4, 0); | |
| 920 | |
| 921 indent_to (file, indent + 4); | |
| 922 fprintf (file, "version %u", SSA_NAME_VERSION (node)); | |
| 923 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) | |
| 924 fprintf (file, " in-abnormal-phi"); | |
| 925 if (SSA_NAME_IN_FREE_LIST (node)) | |
| 926 fprintf (file, " in-free-list"); | |
| 927 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
928 if (SSA_NAME_PTR_INFO (node)) |
| 0 | 929 { |
| 930 indent_to (file, indent + 3); | |
| 931 if (SSA_NAME_PTR_INFO (node)) | |
| 932 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node)); | |
| 933 } | |
| 934 break; | |
| 935 | |
| 936 case OMP_CLAUSE: | |
| 937 { | |
| 938 int i; | |
| 939 fprintf (file, " %s", | |
| 940 omp_clause_code_name[OMP_CLAUSE_CODE (node)]); | |
| 941 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++) | |
| 942 { | |
| 943 indent_to (file, indent + 4); | |
| 944 fprintf (file, "op %d:", i); | |
| 945 print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0); | |
| 946 } | |
| 947 } | |
| 948 break; | |
| 949 | |
| 950 case OPTIMIZATION_NODE: | |
| 951 cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node)); | |
| 952 break; | |
| 953 | |
| 954 case TARGET_OPTION_NODE: | |
| 955 cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node)); | |
| 956 break; | |
| 957 case IMPORTED_DECL: | |
| 958 fprintf (file, " imported declaration"); | |
| 959 print_node_brief (file, "associated declaration", | |
| 960 IMPORTED_DECL_ASSOCIATED_DECL (node), | |
| 961 indent + 4); | |
| 962 break; | |
| 963 | |
| 964 default: | |
| 965 if (EXCEPTIONAL_CLASS_P (node)) | |
| 966 lang_hooks.print_xnode (file, node, indent); | |
| 967 break; | |
| 968 } | |
| 969 | |
| 970 break; | |
| 971 } | |
| 972 | |
| 973 if (EXPR_HAS_LOCATION (node)) | |
| 974 { | |
| 975 expanded_location xloc = expand_location (EXPR_LOCATION (node)); | |
| 976 indent_to (file, indent+4); | |
| 977 fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column); | |
| 978 } | |
| 979 | |
| 980 fprintf (file, ">"); | |
| 981 } |