Mercurial > hg > CbC > CbC_gcc
annotate gcc/print-tree.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Prints out tree in human readable form - GCC |
| 145 | 2 Copyright (C) 1990-2020 Free Software Foundation, Inc. |
| 0 | 3 |
| 4 This file is part of GCC. | |
| 5 | |
| 6 GCC is free software; you can redistribute it and/or modify it under | |
| 7 the terms of the GNU General Public License as published by the Free | |
| 8 Software Foundation; either version 3, or (at your option) any later | |
| 9 version. | |
| 10 | |
| 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 14 for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
| 17 along with GCC; see the file COPYING3. If not see | |
| 18 <http://www.gnu.org/licenses/>. */ | |
| 19 | |
| 20 | |
| 21 #include "config.h" | |
| 22 #include "system.h" | |
| 23 #include "coretypes.h" | |
| 24 #include "tm.h" | |
| 25 #include "tree.h" | |
| 111 | 26 #include "cgraph.h" |
| 27 #include "diagnostic.h" | |
| 28 #include "varasm.h" | |
| 29 #include "print-rtl.h" | |
| 30 #include "stor-layout.h" | |
| 0 | 31 #include "langhooks.h" |
| 32 #include "tree-iterator.h" | |
| 111 | 33 #include "gimple-pretty-print.h" /* FIXME */ |
| 34 #include "tree-cfg.h" | |
| 35 #include "dumpfile.h" | |
| 36 #include "print-tree.h" | |
| 0 | 37 |
| 38 /* Define the hash table of nodes already seen. | |
| 39 Such nodes are not repeated; brief cross-references are used. */ | |
| 40 | |
| 41 #define HASH_SIZE 37 | |
| 42 | |
| 111 | 43 static hash_set<tree> *table = NULL; |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
44 |
| 0 | 45 /* Print PREFIX and ADDR to FILE. */ |
| 46 void | |
| 47 dump_addr (FILE *file, const char *prefix, const void *addr) | |
| 48 { | |
| 49 if (flag_dump_noaddr || flag_dump_unnumbered) | |
| 50 fprintf (file, "%s#", prefix); | |
| 51 else | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
52 fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr); |
| 0 | 53 } |
| 54 | |
| 131 | 55 /* Print to FILE a NODE representing a REAL_CST constant, including |
| 56 Infinity and NaN. Be verbose when BFRIEF is false. */ | |
| 57 | |
| 58 static void | |
| 59 print_real_cst (FILE *file, const_tree node, bool brief) | |
| 60 { | |
| 61 if (TREE_OVERFLOW (node)) | |
| 62 fprintf (file, " overflow"); | |
| 63 | |
| 64 REAL_VALUE_TYPE d = TREE_REAL_CST (node); | |
| 65 if (REAL_VALUE_ISINF (d)) | |
| 66 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); | |
| 67 else if (REAL_VALUE_ISNAN (d)) | |
| 68 { | |
| 69 /* Print a NaN in the format [-][Q]NaN[(significand[exponent])] | |
| 70 where significand is a hexadecimal string that starts with | |
| 71 the 0x prefix followed by 0 if the number is not canonical | |
| 72 and a non-zero digit if it is, and exponent is decimal. */ | |
| 73 unsigned start = 0; | |
| 74 const char *psig = (const char *) d.sig; | |
| 75 for (unsigned i = 0; i != sizeof d.sig; ++i) | |
| 76 if (psig[i]) | |
| 77 { | |
| 78 start = i; | |
| 79 break; | |
| 80 } | |
| 81 | |
| 82 fprintf (file, " %s%sNaN", d.sign ? "-" : "", | |
| 83 d.signalling ? "S" : "Q"); | |
| 84 | |
| 85 if (brief) | |
| 86 return; | |
| 87 | |
| 88 if (start) | |
| 89 fprintf (file, "(0x%s", d.canonical ? "" : "0"); | |
| 90 else if (d.uexp) | |
| 91 fprintf (file, "(%s", d.canonical ? "" : "0"); | |
| 92 else if (!d.canonical) | |
| 93 { | |
| 94 fprintf (file, "(0)"); | |
| 95 return; | |
| 96 } | |
| 97 | |
| 98 if (psig[start]) | |
| 99 { | |
| 100 for (unsigned i = start; i != sizeof d.sig; ++i) | |
| 101 if (i == start) | |
| 102 fprintf (file, "%x", psig[i]); | |
| 103 else | |
| 104 fprintf (file, "%02x", psig[i]); | |
| 105 } | |
| 106 | |
| 107 if (d.uexp) | |
| 108 fprintf (file, "%se%u)", psig[start] ? "," : "", d.uexp); | |
| 109 else if (psig[start]) | |
| 110 fputc (')', file); | |
| 111 } | |
| 112 else | |
| 113 { | |
| 114 char string[64]; | |
| 115 real_to_decimal (string, &d, sizeof (string), 0, 1); | |
| 116 fprintf (file, " %s", string); | |
| 117 } | |
| 118 } | |
| 119 | |
| 0 | 120 /* Print a node in brief fashion, with just the code, address and name. */ |
| 121 | |
| 122 void | |
| 123 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) | |
| 124 { | |
| 125 enum tree_code_class tclass; | |
| 126 | |
| 127 if (node == 0) | |
| 128 return; | |
| 129 | |
| 130 tclass = TREE_CODE_CLASS (TREE_CODE (node)); | |
| 131 | |
| 132 /* Always print the slot this node is in, and its code, address and | |
| 133 name if any. */ | |
| 134 if (indent > 0) | |
| 135 fprintf (file, " "); | |
| 111 | 136 fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node))); |
| 0 | 137 dump_addr (file, " ", node); |
| 138 | |
| 139 if (tclass == tcc_declaration) | |
| 140 { | |
| 141 if (DECL_NAME (node)) | |
| 142 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); | |
| 143 else if (TREE_CODE (node) == LABEL_DECL | |
| 144 && 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
|
145 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
146 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
|
147 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
|
148 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
149 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
|
150 } |
| 0 | 151 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
152 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
153 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
|
154 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
|
155 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
|
156 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
157 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
|
158 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
|
159 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
|
160 } |
| 0 | 161 } |
| 162 else if (tclass == tcc_type) | |
| 163 { | |
| 164 if (TYPE_NAME (node)) | |
| 165 { | |
| 166 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) | |
| 167 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); | |
| 168 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL | |
| 169 && DECL_NAME (TYPE_NAME (node))) | |
| 170 fprintf (file, " %s", | |
| 171 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); | |
| 172 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
173 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
|
174 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node)); |
| 0 | 175 } |
| 176 if (TREE_CODE (node) == IDENTIFIER_NODE) | |
| 177 fprintf (file, " %s", IDENTIFIER_POINTER (node)); | |
| 178 | |
| 179 /* We might as well always print the value of an integer or real. */ | |
| 180 if (TREE_CODE (node) == INTEGER_CST) | |
| 181 { | |
| 182 if (TREE_OVERFLOW (node)) | |
| 183 fprintf (file, " overflow"); | |
| 184 | |
| 185 fprintf (file, " "); | |
| 111 | 186 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node))); |
| 0 | 187 } |
| 188 if (TREE_CODE (node) == REAL_CST) | |
| 131 | 189 print_real_cst (file, node, true); |
| 0 | 190 if (TREE_CODE (node) == FIXED_CST) |
| 191 { | |
| 192 FIXED_VALUE_TYPE f; | |
| 193 char string[60]; | |
| 194 | |
| 195 if (TREE_OVERFLOW (node)) | |
| 196 fprintf (file, " overflow"); | |
| 197 | |
| 198 f = TREE_FIXED_CST (node); | |
| 199 fixed_to_decimal (string, &f, sizeof (string)); | |
| 200 fprintf (file, " %s", string); | |
| 201 } | |
| 202 | |
| 203 fprintf (file, ">"); | |
| 204 } | |
| 205 | |
| 206 void | |
| 207 indent_to (FILE *file, int column) | |
| 208 { | |
| 209 int i; | |
| 210 | |
| 211 /* Since this is the long way, indent to desired column. */ | |
| 212 if (column > 0) | |
| 213 fprintf (file, "\n"); | |
| 214 for (i = 0; i < column; i++) | |
| 215 fprintf (file, " "); | |
| 216 } | |
| 217 | |
| 218 /* Print the node NODE in full on file FILE, preceded by PREFIX, | |
| 219 starting in column INDENT. */ | |
| 220 | |
| 221 void | |
| 111 | 222 print_node (FILE *file, const char *prefix, tree node, int indent, |
| 223 bool brief_for_visited) | |
| 0 | 224 { |
| 111 | 225 machine_mode mode; |
| 0 | 226 enum tree_code_class tclass; |
| 227 int len; | |
| 228 int i; | |
| 229 expanded_location xloc; | |
| 230 enum tree_code code; | |
| 231 | |
| 232 if (node == 0) | |
| 233 return; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
234 |
| 0 | 235 code = TREE_CODE (node); |
| 145 | 236 |
| 237 /* It is unsafe to look at any other fields of a node with ERROR_MARK or | |
| 238 invalid code. */ | |
| 239 if (code == ERROR_MARK || code >= MAX_TREE_CODES) | |
| 240 { | |
| 241 print_node_brief (file, prefix, node, indent); | |
| 242 return; | |
| 243 } | |
| 244 | |
| 0 | 245 tclass = TREE_CODE_CLASS (code); |
| 246 | |
| 247 /* Don't get too deep in nesting. If the user wants to see deeper, | |
| 248 it is easy to use the address of a lowest-level node | |
| 249 as an argument in another call to debug_tree. */ | |
| 250 | |
| 251 if (indent > 24) | |
| 252 { | |
| 253 print_node_brief (file, prefix, node, indent); | |
| 254 return; | |
| 255 } | |
| 256 | |
| 257 if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration)) | |
| 258 { | |
| 259 print_node_brief (file, prefix, node, indent); | |
| 260 return; | |
| 261 } | |
| 262 | |
| 263 /* Allow this function to be called if the table is not there. */ | |
| 264 if (table) | |
| 265 { | |
| 111 | 266 /* If node is in the table, just mention its address. */ |
| 267 if (table->contains (node) && brief_for_visited) | |
| 268 { | |
| 269 print_node_brief (file, prefix, node, indent); | |
| 270 return; | |
| 271 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
272 |
| 111 | 273 table->add (node); |
| 0 | 274 } |
| 275 | |
| 276 /* Indent to the specified column, since this is the long form. */ | |
| 277 indent_to (file, indent); | |
| 278 | |
| 279 /* Print the slot this node is in, and its code, and address. */ | |
| 111 | 280 fprintf (file, "%s <%s", prefix, get_tree_code_name (code)); |
| 0 | 281 dump_addr (file, " ", node); |
| 282 | |
| 283 /* Print the name, if any. */ | |
| 284 if (tclass == tcc_declaration) | |
| 285 { | |
| 286 if (DECL_NAME (node)) | |
| 287 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); | |
| 288 else if (code == LABEL_DECL | |
| 289 && 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
|
290 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
291 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
|
292 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
|
293 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
294 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
|
295 } |
| 0 | 296 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
297 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
298 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
|
299 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
|
300 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
301 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
|
302 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
|
303 } |
| 0 | 304 } |
| 305 else if (tclass == tcc_type) | |
| 306 { | |
| 307 if (TYPE_NAME (node)) | |
| 308 { | |
| 309 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) | |
| 310 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node))); | |
| 311 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL | |
| 312 && DECL_NAME (TYPE_NAME (node))) | |
| 313 fprintf (file, " %s", | |
| 314 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)))); | |
| 315 } | |
| 316 } | |
| 317 if (code == IDENTIFIER_NODE) | |
| 318 fprintf (file, " %s", IDENTIFIER_POINTER (node)); | |
| 319 | |
| 320 if (code == INTEGER_CST) | |
| 321 { | |
| 322 if (indent <= 4) | |
| 323 print_node_brief (file, "type", TREE_TYPE (node), indent + 4); | |
| 324 } | |
| 111 | 325 else if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) |
| 0 | 326 { |
| 327 print_node (file, "type", TREE_TYPE (node), indent + 4); | |
| 328 if (TREE_TYPE (node)) | |
| 329 indent_to (file, indent + 3); | |
| 330 } | |
| 331 | |
| 332 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node)) | |
| 333 fputs (" side-effects", file); | |
| 334 | |
| 335 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node)) | |
| 336 fputs (" readonly", file); | |
| 111 | 337 if (TYPE_P (node) && TYPE_ATOMIC (node)) |
| 338 fputs (" atomic", file); | |
| 0 | 339 if (!TYPE_P (node) && TREE_CONSTANT (node)) |
| 340 fputs (" constant", file); | |
| 341 else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node)) | |
| 342 fputs (" sizes-gimplified", file); | |
| 343 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
344 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
|
345 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
|
346 |
| 0 | 347 if (TREE_ADDRESSABLE (node)) |
| 348 fputs (" addressable", file); | |
| 349 if (TREE_THIS_VOLATILE (node)) | |
| 350 fputs (" volatile", file); | |
| 351 if (TREE_ASM_WRITTEN (node)) | |
| 352 fputs (" asm_written", file); | |
| 353 if (TREE_USED (node)) | |
| 354 fputs (" used", file); | |
| 355 if (TREE_NOTHROW (node)) | |
| 111 | 356 fputs (" nothrow", file); |
| 0 | 357 if (TREE_PUBLIC (node)) |
| 358 fputs (" public", file); | |
| 359 if (TREE_PRIVATE (node)) | |
| 360 fputs (" private", file); | |
| 361 if (TREE_PROTECTED (node)) | |
| 362 fputs (" protected", file); | |
| 363 if (TREE_STATIC (node)) | |
| 111 | 364 fputs (code == CALL_EXPR ? " must-tail-call" : " static", file); |
| 0 | 365 if (TREE_DEPRECATED (node)) |
| 366 fputs (" deprecated", file); | |
| 367 if (TREE_VISITED (node)) | |
| 368 fputs (" visited", file); | |
| 111 | 369 |
| 370 if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME) | |
| 371 { | |
| 372 if (TREE_LANG_FLAG_0 (node)) | |
| 373 fputs (" tree_0", file); | |
| 374 if (TREE_LANG_FLAG_1 (node)) | |
| 375 fputs (" tree_1", file); | |
| 376 if (TREE_LANG_FLAG_2 (node)) | |
| 377 fputs (" tree_2", file); | |
| 378 if (TREE_LANG_FLAG_3 (node)) | |
| 379 fputs (" tree_3", file); | |
| 380 if (TREE_LANG_FLAG_4 (node)) | |
| 381 fputs (" tree_4", file); | |
| 382 if (TREE_LANG_FLAG_5 (node)) | |
| 383 fputs (" tree_5", file); | |
| 384 if (TREE_LANG_FLAG_6 (node)) | |
| 385 fputs (" tree_6", file); | |
| 386 } | |
| 0 | 387 |
| 388 /* DECL_ nodes have additional attributes. */ | |
| 389 | |
| 390 switch (TREE_CODE_CLASS (code)) | |
| 391 { | |
| 392 case tcc_declaration: | |
| 393 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
| 394 { | |
| 395 if (DECL_UNSIGNED (node)) | |
| 396 fputs (" unsigned", file); | |
| 397 if (DECL_IGNORED_P (node)) | |
| 398 fputs (" ignored", file); | |
| 111 | 399 if (DECL_ABSTRACT_P (node)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
400 fputs (" abstract", file); |
| 0 | 401 if (DECL_EXTERNAL (node)) |
| 402 fputs (" external", file); | |
| 403 if (DECL_NONLOCAL (node)) | |
| 404 fputs (" nonlocal", file); | |
| 405 } | |
| 406 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) | |
| 407 { | |
| 408 if (DECL_WEAK (node)) | |
| 409 fputs (" weak", file); | |
| 410 if (DECL_IN_SYSTEM_HEADER (node)) | |
| 411 fputs (" in_system_header", file); | |
| 412 } | |
| 413 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL) | |
| 414 && code != LABEL_DECL | |
| 415 && code != FUNCTION_DECL | |
| 416 && DECL_REGISTER (node)) | |
| 417 fputs (" regdecl", file); | |
| 418 | |
| 419 if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node)) | |
| 420 fputs (" suppress-debug", file); | |
| 421 | |
| 422 if (code == FUNCTION_DECL | |
| 423 && DECL_FUNCTION_SPECIFIC_TARGET (node)) | |
| 424 fputs (" function-specific-target", file); | |
| 425 if (code == FUNCTION_DECL | |
| 426 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node)) | |
| 427 fputs (" function-specific-opt", file); | |
| 428 if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node)) | |
| 429 fputs (" autoinline", file); | |
| 131 | 430 if (code == FUNCTION_DECL && DECL_UNINLINABLE (node)) |
| 431 fputs (" uninlinable", file); | |
| 432 if (code == FUNCTION_DECL && fndecl_built_in_p (node)) | |
| 0 | 433 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
|
434 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
|
435 fputs (" static-chain", file); |
| 111 | 436 if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node)) |
| 437 fputs (" tm-clone", file); | |
| 0 | 438 |
| 439 if (code == FIELD_DECL && DECL_PACKED (node)) | |
| 440 fputs (" packed", file); | |
| 441 if (code == FIELD_DECL && DECL_BIT_FIELD (node)) | |
| 442 fputs (" bit-field", file); | |
| 443 if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node)) | |
| 444 fputs (" nonaddressable", file); | |
| 445 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
446 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
|
447 fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node)); |
| 0 | 448 |
| 449 if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node)) | |
| 450 fputs (" in-text-section", file); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
451 if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
452 fputs (" in-constant-pool", file); |
| 0 | 453 if (code == VAR_DECL && DECL_COMMON (node)) |
| 454 fputs (" common", file); | |
| 111 | 455 if ((code == VAR_DECL || code == PARM_DECL) && DECL_READ_P (node)) |
| 456 fputs (" read", file); | |
| 0 | 457 if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node)) |
| 458 { | |
| 111 | 459 fputs (" ", file); |
| 460 fputs (tls_model_names[DECL_TLS_MODEL (node)], file); | |
| 0 | 461 } |
| 462 | |
| 463 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
|
464 { |
| 0 | 465 if (DECL_VIRTUAL_P (node)) |
| 466 fputs (" virtual", file); | |
| 467 if (DECL_PRESERVE_P (node)) | |
| 468 fputs (" preserve", file); | |
| 469 if (DECL_LANG_FLAG_0 (node)) | |
| 470 fputs (" decl_0", file); | |
| 471 if (DECL_LANG_FLAG_1 (node)) | |
| 472 fputs (" decl_1", file); | |
| 473 if (DECL_LANG_FLAG_2 (node)) | |
| 474 fputs (" decl_2", file); | |
| 475 if (DECL_LANG_FLAG_3 (node)) | |
| 476 fputs (" decl_3", file); | |
| 477 if (DECL_LANG_FLAG_4 (node)) | |
| 478 fputs (" decl_4", file); | |
| 479 if (DECL_LANG_FLAG_5 (node)) | |
| 480 fputs (" decl_5", file); | |
| 481 if (DECL_LANG_FLAG_6 (node)) | |
| 482 fputs (" decl_6", file); | |
| 483 if (DECL_LANG_FLAG_7 (node)) | |
| 484 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
|
485 |
| 0 | 486 mode = DECL_MODE (node); |
| 487 fprintf (file, " %s", GET_MODE_NAME (mode)); | |
| 488 } | |
| 489 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
490 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
|
491 && 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
|
492 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
|
493 |
| 0 | 494 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node)) |
| 495 fputs (" defer-output", file); | |
| 496 | |
| 497 | |
| 498 xloc = expand_location (DECL_SOURCE_LOCATION (node)); | |
| 111 | 499 fprintf (file, " %s:%d:%d", xloc.file, xloc.line, |
| 0 | 500 xloc.column); |
| 501 | |
| 502 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
|
503 { |
| 0 | 504 print_node (file, "size", DECL_SIZE (node), indent + 4); |
| 111 | 505 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
|
506 |
| 131 | 507 if (code != FUNCTION_DECL || fndecl_built_in_p (node)) |
| 0 | 508 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
|
509 |
| 0 | 510 if (DECL_USER_ALIGN (node)) |
| 511 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
|
512 |
| 111 | 513 fprintf (file, " align:%d warn_if_not_align:%d", |
| 514 DECL_ALIGN (node), DECL_WARN_IF_NOT_ALIGN (node)); | |
| 0 | 515 if (code == FIELD_DECL) |
| 516 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED, | |
| 517 DECL_OFFSET_ALIGN (node)); | |
| 518 | |
| 131 | 519 if (code == FUNCTION_DECL && fndecl_built_in_p (node)) |
| 0 | 520 { |
| 521 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD) | |
| 145 | 522 fprintf (file, " built-in: BUILT_IN_MD:%d", |
| 523 DECL_MD_FUNCTION_CODE (node)); | |
| 524 else if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_FRONTEND) | |
| 525 fprintf (file, " built-in: BUILT_IN_FRONTEND:%d", | |
| 526 DECL_FE_FUNCTION_CODE (node)); | |
| 0 | 527 else |
| 111 | 528 fprintf (file, " built-in: %s:%s", |
| 0 | 529 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)], |
| 530 built_in_names[(int) DECL_FUNCTION_CODE (node)]); | |
| 531 } | |
| 532 } | |
| 533 if (code == FIELD_DECL) | |
| 534 { | |
| 535 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4); | |
| 111 | 536 print_node (file, "bit-offset", DECL_FIELD_BIT_OFFSET (node), |
| 0 | 537 indent + 4); |
| 538 if (DECL_BIT_FIELD_TYPE (node)) | |
| 539 print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node), | |
| 540 indent + 4); | |
| 541 } | |
| 542 | |
| 543 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4); | |
| 544 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
545 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) |
| 0 | 546 { |
| 111 | 547 print_node (file, "attributes", |
| 0 | 548 DECL_ATTRIBUTES (node), indent + 4); |
| 549 if (code != PARM_DECL) | |
| 550 print_node_brief (file, "initial", DECL_INITIAL (node), | |
| 551 indent + 4); | |
| 552 } | |
| 553 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) | |
| 554 { | |
| 555 print_node_brief (file, "abstract_origin", | |
| 556 DECL_ABSTRACT_ORIGIN (node), indent + 4); | |
| 557 } | |
| 558 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON)) | |
| 559 { | |
| 560 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4); | |
| 561 } | |
| 562 | |
| 563 lang_hooks.print_decl (file, node, indent); | |
| 564 | |
| 565 if (DECL_RTL_SET_P (node)) | |
| 566 { | |
| 567 indent_to (file, indent + 4); | |
| 568 print_rtl (file, DECL_RTL (node)); | |
| 569 } | |
| 570 | |
| 571 if (code == PARM_DECL) | |
| 572 { | |
| 573 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4); | |
| 574 | |
| 575 if (DECL_INCOMING_RTL (node) != 0) | |
| 576 { | |
| 577 indent_to (file, indent + 4); | |
| 578 fprintf (file, "incoming-rtl "); | |
| 579 print_rtl (file, DECL_INCOMING_RTL (node)); | |
| 580 } | |
| 581 } | |
| 582 else if (code == FUNCTION_DECL | |
| 583 && DECL_STRUCT_FUNCTION (node) != 0) | |
| 584 { | |
| 111 | 585 print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4); |
| 0 | 586 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
|
587 dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node)); |
| 0 | 588 } |
| 589 | |
| 590 if ((code == VAR_DECL || code == PARM_DECL) | |
| 591 && DECL_HAS_VALUE_EXPR_P (node)) | |
| 592 print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4); | |
| 593 | |
| 594 /* Print the decl chain only if decl is at second level. */ | |
| 595 if (indent == 4) | |
| 596 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 597 else | |
| 598 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 599 break; | |
| 600 | |
| 601 case tcc_type: | |
| 602 if (TYPE_UNSIGNED (node)) | |
| 603 fputs (" unsigned", file); | |
| 604 | |
| 111 | 605 if (TYPE_NO_FORCE_BLK (node)) |
| 0 | 606 fputs (" no-force-blk", file); |
| 607 | |
| 145 | 608 if (code == ARRAY_TYPE && TYPE_STRING_FLAG (node)) |
| 0 | 609 fputs (" string-flag", file); |
| 111 | 610 |
| 0 | 611 if (TYPE_NEEDS_CONSTRUCTING (node)) |
| 612 fputs (" needs-constructing", file); | |
| 613 | |
| 111 | 614 if ((code == RECORD_TYPE |
| 615 || code == UNION_TYPE | |
| 616 || code == QUAL_UNION_TYPE | |
| 617 || code == ARRAY_TYPE) | |
| 618 && TYPE_REVERSE_STORAGE_ORDER (node)) | |
| 619 fputs (" reverse-storage-order", file); | |
| 620 | |
| 145 | 621 if ((code == RECORD_TYPE |
| 622 || code == UNION_TYPE) | |
| 623 && TYPE_CXX_ODR_P (node)) | |
| 624 fputs (" cxx-odr-p", file); | |
| 625 | |
| 0 | 626 /* The transparent-union flag is used for different things in |
| 627 different nodes. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
628 if ((code == UNION_TYPE || code == RECORD_TYPE) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
629 && TYPE_TRANSPARENT_AGGR (node)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
630 fputs (" transparent-aggr", file); |
| 0 | 631 else if (code == ARRAY_TYPE |
| 632 && TYPE_NONALIASED_COMPONENT (node)) | |
| 633 fputs (" nonaliased-component", file); | |
| 634 | |
| 635 if (TYPE_PACKED (node)) | |
| 636 fputs (" packed", file); | |
| 637 | |
| 638 if (TYPE_RESTRICT (node)) | |
| 639 fputs (" restrict", file); | |
| 640 | |
| 641 if (TYPE_LANG_FLAG_0 (node)) | |
| 642 fputs (" type_0", file); | |
| 643 if (TYPE_LANG_FLAG_1 (node)) | |
| 644 fputs (" type_1", file); | |
| 645 if (TYPE_LANG_FLAG_2 (node)) | |
| 646 fputs (" type_2", file); | |
| 647 if (TYPE_LANG_FLAG_3 (node)) | |
| 648 fputs (" type_3", file); | |
| 649 if (TYPE_LANG_FLAG_4 (node)) | |
| 650 fputs (" type_4", file); | |
| 651 if (TYPE_LANG_FLAG_5 (node)) | |
| 652 fputs (" type_5", file); | |
| 653 if (TYPE_LANG_FLAG_6 (node)) | |
| 654 fputs (" type_6", file); | |
| 111 | 655 if (TYPE_LANG_FLAG_7 (node)) |
| 656 fputs (" type_7", file); | |
| 0 | 657 |
| 658 mode = TYPE_MODE (node); | |
| 659 fprintf (file, " %s", GET_MODE_NAME (mode)); | |
| 660 | |
| 661 print_node (file, "size", TYPE_SIZE (node), indent + 4); | |
| 111 | 662 print_node (file, "unit-size", TYPE_SIZE_UNIT (node), indent + 4); |
| 0 | 663 indent_to (file, indent + 3); |
| 664 | |
| 665 if (TYPE_USER_ALIGN (node)) | |
| 666 fprintf (file, " user"); | |
| 667 | |
| 111 | 668 fprintf (file, " align:%d warn_if_not_align:%d symtab:%d alias-set " |
| 669 HOST_WIDE_INT_PRINT_DEC, | |
| 670 TYPE_ALIGN (node), TYPE_WARN_IF_NOT_ALIGN (node), | |
| 671 TYPE_SYMTAB_ADDRESS (node), | |
| 0 | 672 (HOST_WIDE_INT) TYPE_ALIAS_SET (node)); |
| 673 | |
| 674 if (TYPE_STRUCTURAL_EQUALITY_P (node)) | |
| 111 | 675 fprintf (file, " structural-equality"); |
| 0 | 676 else |
| 111 | 677 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
|
678 |
| 0 | 679 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4); |
| 680 | |
| 681 if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE | |
| 682 || code == FIXED_POINT_TYPE) | |
| 683 { | |
| 111 | 684 fprintf (file, " precision:%d", TYPE_PRECISION (node)); |
| 0 | 685 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4); |
| 686 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4); | |
| 687 } | |
| 688 | |
| 689 if (code == ENUMERAL_TYPE) | |
| 690 print_node (file, "values", TYPE_VALUES (node), indent + 4); | |
| 691 else if (code == ARRAY_TYPE) | |
| 692 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4); | |
| 693 else if (code == VECTOR_TYPE) | |
| 131 | 694 { |
| 695 fprintf (file, " nunits:"); | |
| 696 print_dec (TYPE_VECTOR_SUBPARTS (node), file); | |
| 697 } | |
| 0 | 698 else if (code == RECORD_TYPE |
| 699 || code == UNION_TYPE | |
| 700 || code == QUAL_UNION_TYPE) | |
| 701 print_node (file, "fields", TYPE_FIELDS (node), indent + 4); | |
| 702 else if (code == FUNCTION_TYPE | |
| 703 || code == METHOD_TYPE) | |
| 704 { | |
| 705 if (TYPE_METHOD_BASETYPE (node)) | |
| 706 print_node_brief (file, "method basetype", | |
| 707 TYPE_METHOD_BASETYPE (node), indent + 4); | |
| 708 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4); | |
| 709 } | |
| 710 else if (code == OFFSET_TYPE) | |
| 711 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node), | |
| 712 indent + 4); | |
| 713 | |
| 714 if (TYPE_CONTEXT (node)) | |
| 715 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4); | |
| 716 | |
| 717 lang_hooks.print_type (file, node, indent); | |
| 718 | |
| 719 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node)) | |
| 720 indent_to (file, indent + 3); | |
| 721 | |
| 722 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), | |
| 723 indent + 4); | |
| 724 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), | |
| 725 indent + 4); | |
| 726 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 727 break; | |
| 728 | |
| 729 case tcc_expression: | |
| 730 case tcc_comparison: | |
| 731 case tcc_unary: | |
| 732 case tcc_binary: | |
| 733 case tcc_reference: | |
| 734 case tcc_statement: | |
| 735 case tcc_vl_exp: | |
| 736 if (code == BIND_EXPR) | |
| 737 { | |
| 738 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4); | |
| 739 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4); | |
| 740 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4); | |
| 741 break; | |
| 742 } | |
| 743 if (code == CALL_EXPR) | |
| 744 { | |
| 745 call_expr_arg_iterator iter; | |
| 746 tree arg; | |
| 747 print_node (file, "fn", CALL_EXPR_FN (node), indent + 4); | |
| 748 print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node), | |
| 749 indent + 4); | |
| 750 i = 0; | |
| 751 FOR_EACH_CALL_EXPR_ARG (arg, iter, node) | |
| 752 { | |
| 111 | 753 /* Buffer big enough to format a 32-bit UINT_MAX into, plus |
| 754 the text. */ | |
| 755 char temp[15]; | |
| 756 sprintf (temp, "arg:%u", i); | |
| 0 | 757 print_node (file, temp, arg, indent + 4); |
| 758 i++; | |
| 759 } | |
| 760 } | |
| 761 else | |
| 762 { | |
| 763 len = TREE_OPERAND_LENGTH (node); | |
| 764 | |
| 765 for (i = 0; i < len; i++) | |
| 766 { | |
| 111 | 767 /* Buffer big enough to format a 32-bit UINT_MAX into, plus |
| 768 the text. */ | |
| 769 char temp[15]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
770 |
| 111 | 771 sprintf (temp, "arg:%d", i); |
| 0 | 772 print_node (file, temp, TREE_OPERAND (node, i), indent + 4); |
| 773 } | |
| 774 } | |
| 111 | 775 if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) |
| 776 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 0 | 777 break; |
| 778 | |
| 779 case tcc_constant: | |
| 780 case tcc_exceptional: | |
| 781 switch (code) | |
| 782 { | |
| 783 case INTEGER_CST: | |
| 784 if (TREE_OVERFLOW (node)) | |
| 785 fprintf (file, " overflow"); | |
| 786 | |
| 787 fprintf (file, " "); | |
| 111 | 788 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node))); |
| 0 | 789 break; |
| 790 | |
| 791 case REAL_CST: | |
| 131 | 792 print_real_cst (file, node, false); |
| 0 | 793 break; |
| 794 | |
| 795 case FIXED_CST: | |
| 796 { | |
| 797 FIXED_VALUE_TYPE f; | |
| 798 char string[64]; | |
| 799 | |
| 800 if (TREE_OVERFLOW (node)) | |
| 801 fprintf (file, " overflow"); | |
| 802 | |
| 803 f = TREE_FIXED_CST (node); | |
| 804 fixed_to_decimal (string, &f, sizeof (string)); | |
| 805 fprintf (file, " %s", string); | |
| 806 } | |
| 807 break; | |
| 808 | |
| 809 case VECTOR_CST: | |
| 810 { | |
| 131 | 811 /* Big enough for UINT_MAX plus the string below. */ |
| 111 | 812 char buf[32]; |
| 0 | 813 |
| 131 | 814 fprintf (file, " npatterns:%u nelts-per-pattern:%u", |
| 815 VECTOR_CST_NPATTERNS (node), | |
| 816 VECTOR_CST_NELTS_PER_PATTERN (node)); | |
| 817 unsigned int count = vector_cst_encoded_nelts (node); | |
| 818 for (unsigned int i = 0; i < count; ++i) | |
| 0 | 819 { |
| 131 | 820 sprintf (buf, "elt:%u: ", i); |
| 821 print_node (file, buf, VECTOR_CST_ENCODED_ELT (node, i), | |
| 822 indent + 4); | |
| 0 | 823 } |
| 824 } | |
| 825 break; | |
| 826 | |
| 827 case COMPLEX_CST: | |
| 828 print_node (file, "real", TREE_REALPART (node), indent + 4); | |
| 829 print_node (file, "imag", TREE_IMAGPART (node), indent + 4); | |
| 830 break; | |
| 831 | |
| 832 case STRING_CST: | |
| 833 { | |
| 834 const char *p = TREE_STRING_POINTER (node); | |
| 835 int i = TREE_STRING_LENGTH (node); | |
| 836 fputs (" \"", file); | |
| 837 while (--i >= 0) | |
| 838 { | |
| 839 char ch = *p++; | |
| 840 if (ch >= ' ' && ch < 127) | |
| 841 putc (ch, file); | |
| 842 else | |
| 111 | 843 fprintf (file, "\\%03o", ch & 0xFF); |
| 0 | 844 } |
| 845 fputc ('\"', file); | |
| 846 } | |
| 847 break; | |
| 848 | |
| 131 | 849 case POLY_INT_CST: |
| 850 { | |
| 851 char buf[10]; | |
| 852 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) | |
| 853 { | |
| 854 snprintf (buf, sizeof (buf), "elt%u: ", i); | |
| 855 print_node (file, buf, POLY_INT_CST_COEFF (node, i), | |
| 856 indent + 4); | |
| 857 } | |
| 858 } | |
| 859 break; | |
| 860 | |
| 0 | 861 case IDENTIFIER_NODE: |
| 862 lang_hooks.print_identifier (file, node, indent); | |
| 863 break; | |
| 864 | |
| 865 case TREE_LIST: | |
| 866 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4); | |
| 867 print_node (file, "value", TREE_VALUE (node), indent + 4); | |
| 868 print_node (file, "chain", TREE_CHAIN (node), indent + 4); | |
| 869 break; | |
| 870 | |
| 871 case TREE_VEC: | |
| 872 len = TREE_VEC_LENGTH (node); | |
| 111 | 873 fprintf (file, " length:%d", len); |
| 0 | 874 for (i = 0; i < len; i++) |
| 875 if (TREE_VEC_ELT (node, i)) | |
| 876 { | |
| 111 | 877 /* Buffer big enough to format a 32-bit UINT_MAX into, plus |
| 878 the text. */ | |
| 879 char temp[15]; | |
| 880 sprintf (temp, "elt:%d", i); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
881 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4); |
| 0 | 882 } |
| 883 break; | |
| 884 | |
| 885 case CONSTRUCTOR: | |
| 886 { | |
| 887 unsigned HOST_WIDE_INT cnt; | |
| 888 tree index, value; | |
| 111 | 889 len = CONSTRUCTOR_NELTS (node); |
| 890 fprintf (file, " length:%d", len); | |
| 0 | 891 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), |
| 892 cnt, index, value) | |
| 893 { | |
| 111 | 894 print_node (file, "idx", index, indent + 4, false); |
| 895 print_node (file, "val", value, indent + 4, false); | |
| 0 | 896 } |
| 897 } | |
| 898 break; | |
| 899 | |
| 900 case STATEMENT_LIST: | |
| 901 dump_addr (file, " head ", node->stmt_list.head); | |
| 902 dump_addr (file, " tail ", node->stmt_list.tail); | |
| 903 fprintf (file, " stmts"); | |
| 904 { | |
| 905 tree_stmt_iterator i; | |
| 906 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i)) | |
| 907 { | |
| 908 /* Not printing the addresses of the (not-a-tree) | |
| 909 'struct tree_stmt_list_node's. */ | |
| 910 dump_addr (file, " ", tsi_stmt (i)); | |
| 911 } | |
| 912 fprintf (file, "\n"); | |
| 913 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i)) | |
| 914 { | |
| 915 /* Not printing the addresses of the (not-a-tree) | |
| 916 'struct tree_stmt_list_node's. */ | |
| 917 print_node (file, "stmt", tsi_stmt (i), indent + 4); | |
| 918 } | |
| 919 } | |
| 920 break; | |
| 921 | |
| 922 case BLOCK: | |
| 923 print_node (file, "vars", BLOCK_VARS (node), indent + 4); | |
| 924 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), | |
| 925 indent + 4); | |
| 926 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4); | |
| 927 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4); | |
| 928 print_node (file, "abstract_origin", | |
| 929 BLOCK_ABSTRACT_ORIGIN (node), indent + 4); | |
| 930 break; | |
| 931 | |
| 932 case SSA_NAME: | |
| 933 print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4); | |
| 111 | 934 indent_to (file, indent + 4); |
| 0 | 935 fprintf (file, "def_stmt "); |
| 111 | 936 { |
| 937 pretty_printer buffer; | |
| 938 buffer.buffer->stream = file; | |
| 131 | 939 pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4, |
| 940 TDF_NONE); | |
| 111 | 941 pp_flush (&buffer); |
| 942 } | |
| 0 | 943 |
| 944 indent_to (file, indent + 4); | |
| 111 | 945 fprintf (file, "version:%u", SSA_NAME_VERSION (node)); |
| 0 | 946 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) |
| 947 fprintf (file, " in-abnormal-phi"); | |
| 948 if (SSA_NAME_IN_FREE_LIST (node)) | |
| 949 fprintf (file, " in-free-list"); | |
| 950 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
951 if (SSA_NAME_PTR_INFO (node)) |
| 0 | 952 { |
| 953 indent_to (file, indent + 3); | |
| 954 if (SSA_NAME_PTR_INFO (node)) | |
| 955 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node)); | |
| 956 } | |
| 957 break; | |
| 958 | |
| 959 case OMP_CLAUSE: | |
| 960 { | |
| 961 int i; | |
| 962 fprintf (file, " %s", | |
| 963 omp_clause_code_name[OMP_CLAUSE_CODE (node)]); | |
| 964 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++) | |
| 965 { | |
| 966 indent_to (file, indent + 4); | |
| 111 | 967 fprintf (file, "op-%d:", i); |
| 0 | 968 print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0); |
| 969 } | |
| 970 } | |
| 971 break; | |
| 972 | |
| 973 case OPTIMIZATION_NODE: | |
| 974 cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node)); | |
| 975 break; | |
| 976 | |
| 977 case TARGET_OPTION_NODE: | |
| 978 cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node)); | |
| 979 break; | |
| 980 case IMPORTED_DECL: | |
| 111 | 981 fprintf (file, " imported-declaration"); |
| 982 print_node_brief (file, "associated-declaration", | |
| 0 | 983 IMPORTED_DECL_ASSOCIATED_DECL (node), |
| 984 indent + 4); | |
| 985 break; | |
| 986 | |
| 111 | 987 case TREE_BINFO: |
| 988 fprintf (file, " bases:%d", | |
| 989 vec_safe_length (BINFO_BASE_BINFOS (node))); | |
| 990 print_node_brief (file, "offset", BINFO_OFFSET (node), indent + 4); | |
| 991 print_node_brief (file, "virtuals", BINFO_VIRTUALS (node), | |
| 992 indent + 4); | |
| 993 print_node_brief (file, "inheritance-chain", | |
| 994 BINFO_INHERITANCE_CHAIN (node), | |
| 995 indent + 4); | |
| 996 break; | |
| 997 | |
| 0 | 998 default: |
| 999 if (EXCEPTIONAL_CLASS_P (node)) | |
| 1000 lang_hooks.print_xnode (file, node, indent); | |
| 1001 break; | |
| 1002 } | |
| 1003 | |
| 1004 break; | |
| 1005 } | |
| 1006 | |
| 1007 if (EXPR_HAS_LOCATION (node)) | |
| 1008 { | |
| 1009 expanded_location xloc = expand_location (EXPR_LOCATION (node)); | |
| 1010 indent_to (file, indent+4); | |
| 1011 fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column); | |
| 111 | 1012 |
| 1013 /* Print the range, if any */ | |
| 1014 source_range r = EXPR_LOCATION_RANGE (node); | |
| 1015 if (r.m_start) | |
| 1016 { | |
| 1017 xloc = expand_location (r.m_start); | |
| 1018 fprintf (file, " start: %s:%d:%d", xloc.file, xloc.line, xloc.column); | |
| 1019 } | |
| 1020 else | |
| 1021 { | |
| 1022 fprintf (file, " start: unknown"); | |
| 1023 } | |
| 1024 if (r.m_finish) | |
| 1025 { | |
| 1026 xloc = expand_location (r.m_finish); | |
| 1027 fprintf (file, " finish: %s:%d:%d", xloc.file, xloc.line, xloc.column); | |
| 1028 } | |
| 1029 else | |
| 1030 { | |
| 1031 fprintf (file, " finish: unknown"); | |
| 1032 } | |
| 0 | 1033 } |
| 1034 | |
| 1035 fprintf (file, ">"); | |
| 1036 } | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1037 |
| 145 | 1038 /* Print the identifier for DECL according to FLAGS. */ |
| 1039 | |
| 1040 void | |
| 1041 print_decl_identifier (FILE *file, tree decl, int flags) | |
| 1042 { | |
| 1043 bool needs_colon = false; | |
| 1044 const char *name; | |
| 1045 char c; | |
| 1046 | |
| 1047 if (flags & PRINT_DECL_ORIGIN) | |
| 1048 { | |
| 1049 if (DECL_IS_BUILTIN (decl)) | |
| 1050 fputs ("<built-in>", file); | |
| 1051 else | |
| 1052 { | |
| 1053 expanded_location loc | |
| 1054 = expand_location (DECL_SOURCE_LOCATION (decl)); | |
| 1055 fprintf (file, "%s:%d:%d", loc.file, loc.line, loc.column); | |
| 1056 } | |
| 1057 needs_colon = true; | |
| 1058 } | |
| 1059 | |
| 1060 if (flags & PRINT_DECL_UNIQUE_NAME) | |
| 1061 { | |
| 1062 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); | |
| 1063 if (!TREE_PUBLIC (decl) | |
| 1064 || (DECL_WEAK (decl) && !DECL_EXTERNAL (decl))) | |
| 1065 /* The symbol has internal or weak linkage so its assembler name | |
| 1066 is not necessarily unique among the compilation units of the | |
| 1067 program. We therefore have to further mangle it. But we can't | |
| 1068 simply use DECL_SOURCE_FILE because it contains the name of the | |
| 1069 file the symbol originates from so, e.g. for function templates | |
| 1070 in C++ where the templates are defined in a header file, we can | |
| 1071 have symbols with the same assembler name and DECL_SOURCE_FILE. | |
| 1072 That's why we use the name of the top-level source file of the | |
| 1073 compilation unit. ??? Unnecessary for Ada. */ | |
| 1074 name = ACONCAT ((main_input_filename, ":", name, NULL)); | |
| 1075 } | |
| 1076 else if (flags & PRINT_DECL_NAME) | |
| 1077 { | |
| 1078 /* We don't want to print the full qualified name because it can be long, | |
| 1079 so we strip the scope prefix, but we may need to deal with the suffix | |
| 1080 created by the compiler. */ | |
| 1081 const char *suffix = strchr (IDENTIFIER_POINTER (DECL_NAME (decl)), '.'); | |
| 1082 name = lang_hooks.decl_printable_name (decl, 2); | |
| 1083 if (suffix) | |
| 1084 { | |
| 1085 const char *dot = strchr (name, '.'); | |
| 1086 while (dot && strcasecmp (dot, suffix) != 0) | |
| 1087 { | |
| 1088 name = dot + 1; | |
| 1089 dot = strchr (name, '.'); | |
| 1090 } | |
| 1091 } | |
| 1092 else | |
| 1093 { | |
| 1094 const char *dot = strrchr (name, '.'); | |
| 1095 if (dot) | |
| 1096 name = dot + 1; | |
| 1097 } | |
| 1098 } | |
| 1099 else | |
| 1100 return; | |
| 1101 | |
| 1102 if (needs_colon) | |
| 1103 fputc (':', file); | |
| 1104 | |
| 1105 while ((c = *name++) != '\0') | |
| 1106 { | |
| 1107 /* Strip double-quotes because of VCG. */ | |
| 1108 if (c == '"') | |
| 1109 continue; | |
| 1110 fputc (c, file); | |
| 1111 } | |
| 1112 } | |
| 1113 | |
| 111 | 1114 |
| 1115 /* Print the node NODE on standard error, for debugging. | |
| 1116 Most nodes referred to by this one are printed recursively | |
| 1117 down to a depth of six. */ | |
| 1118 | |
| 1119 DEBUG_FUNCTION void | |
| 1120 debug_tree (tree node) | |
| 1121 { | |
| 1122 table = new hash_set<tree> (HASH_SIZE); | |
| 1123 print_node (stderr, "", node, 0); | |
| 1124 delete table; | |
| 1125 table = NULL; | |
| 1126 putc ('\n', stderr); | |
| 1127 } | |
| 1128 | |
| 1129 DEBUG_FUNCTION void | |
| 1130 debug_raw (const tree_node &ref) | |
| 1131 { | |
| 1132 debug_tree (const_cast <tree> (&ref)); | |
| 1133 } | |
| 1134 | |
| 1135 DEBUG_FUNCTION void | |
| 1136 debug_raw (const tree_node *ptr) | |
| 1137 { | |
| 1138 if (ptr) | |
| 1139 debug_raw (*ptr); | |
| 1140 else | |
| 1141 fprintf (stderr, "<nil>\n"); | |
| 1142 } | |
| 1143 | |
| 1144 static void | |
| 1145 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options) | |
| 1146 { | |
| 1147 if (DECL_P (ptr)) | |
| 1148 lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0); | |
| 1149 else if (TYPE_P (ptr)) | |
| 1150 lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0); | |
| 1151 else if (TREE_CODE (ptr) == IDENTIFIER_NODE) | |
| 1152 lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0); | |
| 1153 else | |
| 1154 print_generic_expr (stderr, const_cast <tree_node*> (ptr), options); | |
| 1155 fprintf (stderr, "\n"); | |
| 1156 } | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1157 |
| 111 | 1158 DEBUG_FUNCTION void |
| 1159 debug (const tree_node &ref) | |
| 1160 { | |
| 131 | 1161 dump_tree_via_hooks (&ref, TDF_NONE); |
| 111 | 1162 } |
| 1163 | |
| 1164 DEBUG_FUNCTION void | |
| 1165 debug (const tree_node *ptr) | |
| 1166 { | |
| 1167 if (ptr) | |
| 1168 debug (*ptr); | |
| 1169 else | |
| 1170 fprintf (stderr, "<nil>\n"); | |
| 1171 } | |
| 1172 | |
| 1173 DEBUG_FUNCTION void | |
| 1174 debug_head (const tree_node &ref) | |
| 1175 { | |
| 1176 debug (ref); | |
| 1177 } | |
| 1178 | |
| 1179 DEBUG_FUNCTION void | |
| 1180 debug_head (const tree_node *ptr) | |
| 1181 { | |
| 1182 if (ptr) | |
| 1183 debug_head (*ptr); | |
| 1184 else | |
| 1185 fprintf (stderr, "<nil>\n"); | |
| 1186 } | |
| 1187 | |
| 1188 DEBUG_FUNCTION void | |
| 1189 debug_body (const tree_node &ref) | |
| 1190 { | |
| 1191 if (TREE_CODE (&ref) == FUNCTION_DECL) | |
| 131 | 1192 dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE); |
| 111 | 1193 else |
| 1194 debug (ref); | |
| 1195 } | |
| 1196 | |
| 1197 DEBUG_FUNCTION void | |
| 1198 debug_body (const tree_node *ptr) | |
| 1199 { | |
| 1200 if (ptr) | |
| 1201 debug_body (*ptr); | |
| 1202 else | |
| 1203 fprintf (stderr, "<nil>\n"); | |
| 1204 } | |
| 1205 | |
| 1206 /* Print the vector of trees VEC on standard error, for debugging. | |
| 1207 Most nodes referred to by this one are printed recursively | |
| 1208 down to a depth of six. */ | |
| 1209 | |
| 1210 DEBUG_FUNCTION void | |
| 1211 debug_raw (vec<tree, va_gc> &ref) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1212 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1213 tree elt; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1214 unsigned ix; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1215 |
| 111 | 1216 /* Print the slot this node is in, and its code, and address. */ |
| 1217 fprintf (stderr, "<VEC"); | |
| 1218 dump_addr (stderr, " ", ref.address ()); | |
| 1219 | |
| 1220 FOR_EACH_VEC_ELT (ref, ix, elt) | |
| 1221 { | |
| 1222 fprintf (stderr, "elt:%d ", ix); | |
| 1223 debug_raw (elt); | |
| 1224 } | |
| 1225 } | |
| 1226 | |
| 1227 DEBUG_FUNCTION void | |
| 1228 debug_raw (vec<tree, va_gc> *ptr) | |
| 1229 { | |
| 1230 if (ptr) | |
| 1231 debug_raw (*ptr); | |
| 1232 else | |
| 1233 fprintf (stderr, "<nil>\n"); | |
| 1234 } | |
| 1235 | |
| 131 | 1236 static void |
| 1237 debug_slim (tree t) | |
| 111 | 1238 { |
| 131 | 1239 print_node_brief (stderr, "", t, 0); |
| 111 | 1240 } |
| 131 | 1241 |
| 1242 DEFINE_DEBUG_VEC (tree) | |
| 1243 DEFINE_DEBUG_HASH_SET (tree) |