Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-pretty-print.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
| author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 22 Mar 2011 17:18:12 +0900 |
| parents | b7f97abdc517 |
| children | 04ced10e8804 |
| rev | line source |
|---|---|
| 0 | 1 /* Pretty formatting of GENERIC trees in C syntax. |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 |
| 0 | 3 Free Software Foundation, Inc. |
| 4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com> | |
| 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 #include "config.h" | |
| 23 #include "system.h" | |
| 24 #include "coretypes.h" | |
| 25 #include "tm.h" | |
| 26 #include "tree.h" | |
| 27 #include "output.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
28 #include "tree-pretty-print.h" |
| 0 | 29 #include "hashtab.h" |
| 30 #include "tree-flow.h" | |
| 31 #include "langhooks.h" | |
| 32 #include "tree-iterator.h" | |
| 33 #include "tree-chrec.h" | |
| 34 #include "tree-pass.h" | |
| 35 #include "value-prof.h" | |
| 36 #include "predict.h" | |
| 37 | |
| 38 /* Local functions, macros and variables. */ | |
| 39 static const char *op_symbol (const_tree); | |
| 40 static void pretty_print_string (pretty_printer *, const char*); | |
| 41 static void newline_and_indent (pretty_printer *, int); | |
| 42 static void maybe_init_pretty_print (FILE *); | |
| 43 static void print_struct_decl (pretty_printer *, const_tree, int, int); | |
| 44 static void do_niy (pretty_printer *, const_tree); | |
| 45 | |
| 46 #define INDENT(SPACE) do { \ | |
| 47 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0) | |
| 48 | |
| 49 #define NIY do_niy(buffer,node) | |
| 50 | |
| 51 static pretty_printer buffer; | |
| 52 static int initialized = 0; | |
| 53 | |
| 54 /* Try to print something for an unknown tree code. */ | |
| 55 | |
| 56 static void | |
| 57 do_niy (pretty_printer *buffer, const_tree node) | |
| 58 { | |
| 59 int i, len; | |
| 60 | |
| 61 pp_string (buffer, "<<< Unknown tree: "); | |
| 62 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]); | |
| 63 | |
| 64 if (EXPR_P (node)) | |
| 65 { | |
| 66 len = TREE_OPERAND_LENGTH (node); | |
| 67 for (i = 0; i < len; ++i) | |
| 68 { | |
| 69 newline_and_indent (buffer, 2); | |
| 70 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false); | |
| 71 } | |
| 72 } | |
| 73 | |
|
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
|
74 pp_string (buffer, " >>>"); |
| 0 | 75 } |
| 76 | |
| 77 /* Debugging function to print out a generic expression. */ | |
| 78 | |
|
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
|
79 DEBUG_FUNCTION void |
| 0 | 80 debug_generic_expr (tree t) |
| 81 { | |
| 82 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); | |
| 83 fprintf (stderr, "\n"); | |
| 84 } | |
| 85 | |
| 86 /* Debugging function to print out a generic statement. */ | |
| 87 | |
|
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
|
88 DEBUG_FUNCTION void |
| 0 | 89 debug_generic_stmt (tree t) |
| 90 { | |
| 91 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); | |
| 92 fprintf (stderr, "\n"); | |
| 93 } | |
| 94 | |
| 95 /* Debugging function to print out a chain of trees . */ | |
| 96 | |
|
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
|
97 DEBUG_FUNCTION void |
| 0 | 98 debug_tree_chain (tree t) |
| 99 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
100 struct pointer_set_t *seen = pointer_set_create (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
101 |
| 0 | 102 while (t) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
104 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
105 fprintf (stderr, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 t = TREE_CHAIN (t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
107 if (pointer_set_insert (seen, t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
108 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
109 fprintf (stderr, "... [cycled back to "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
110 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
111 fprintf (stderr, "]"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
112 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
113 } |
|
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 fprintf (stderr, "\n"); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
116 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
117 pointer_set_destroy (seen); |
| 0 | 118 } |
| 119 | |
| 120 /* Prints declaration DECL to the FILE with details specified by FLAGS. */ | |
| 121 void | |
| 122 print_generic_decl (FILE *file, tree decl, int flags) | |
| 123 { | |
| 124 maybe_init_pretty_print (file); | |
| 125 print_declaration (&buffer, decl, 2, flags); | |
| 126 pp_write_text_to_stream (&buffer); | |
| 127 } | |
| 128 | |
| 129 /* Print tree T, and its successors, on file FILE. FLAGS specifies details | |
| 130 to show in the dump. See TDF_* in tree-pass.h. */ | |
| 131 | |
| 132 void | |
| 133 print_generic_stmt (FILE *file, tree t, int flags) | |
| 134 { | |
| 135 maybe_init_pretty_print (file); | |
| 136 dump_generic_node (&buffer, t, 0, flags, true); | |
| 137 pp_flush (&buffer); | |
| 138 } | |
| 139 | |
| 140 /* Print tree T, and its successors, on file FILE. FLAGS specifies details | |
| 141 to show in the dump. See TDF_* in tree-pass.h. The output is indented by | |
| 142 INDENT spaces. */ | |
| 143 | |
| 144 void | |
| 145 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent) | |
| 146 { | |
| 147 int i; | |
| 148 | |
| 149 maybe_init_pretty_print (file); | |
| 150 | |
| 151 for (i = 0; i < indent; i++) | |
| 152 pp_space (&buffer); | |
| 153 dump_generic_node (&buffer, t, indent, flags, true); | |
| 154 pp_flush (&buffer); | |
| 155 } | |
| 156 | |
| 157 /* Print a single expression T on file FILE. FLAGS specifies details to show | |
| 158 in the dump. See TDF_* in tree-pass.h. */ | |
| 159 | |
| 160 void | |
| 161 print_generic_expr (FILE *file, tree t, int flags) | |
| 162 { | |
| 163 maybe_init_pretty_print (file); | |
| 164 dump_generic_node (&buffer, t, 0, flags, false); | |
| 165 } | |
| 166 | |
| 167 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set | |
| 168 in FLAGS. */ | |
| 169 | |
| 170 static void | |
| 171 dump_decl_name (pretty_printer *buffer, tree node, int flags) | |
| 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 (DECL_NAME (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
174 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
175 if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
176 pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
177 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
178 pp_tree_identifier (buffer, DECL_NAME (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
179 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
180 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE) |
| 0 | 181 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
182 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
183 pp_printf (buffer, "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
|
184 else if (TREE_CODE (node) == DEBUG_EXPR_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
185 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
186 if (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
|
187 pp_string (buffer, "D#xxxx"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
188 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
189 pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
190 } |
| 0 | 191 else |
| 192 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
193 char c = 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
|
194 if (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
|
195 pp_printf (buffer, "%c.xxxx", c); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
196 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
197 pp_printf (buffer, "%c.%u", c, DECL_UID (node)); |
| 0 | 198 } |
| 199 } | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
200 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
201 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
202 if (flags & TDF_NOUID) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
203 pp_printf (buffer, "ptD.xxxx"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
204 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
205 pp_printf (buffer, "ptD.%u", DECL_PT_UID (node)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
206 } |
| 0 | 207 } |
| 208 | |
| 209 /* Like the above, but used for pretty printing function calls. */ | |
| 210 | |
| 211 static void | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
212 dump_function_name (pretty_printer *buffer, tree node, int flags) |
| 0 | 213 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
214 if (TREE_CODE (node) == NOP_EXPR) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
215 node = TREE_OPERAND (node, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
216 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
217 pp_string (buffer, lang_hooks.decl_printable_name (node, 1)); |
| 0 | 218 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
219 dump_decl_name (buffer, node, flags); |
| 0 | 220 } |
| 221 | |
| 222 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and | |
| 223 FLAGS are as in dump_generic_node. */ | |
| 224 | |
| 225 static void | |
| 226 dump_function_declaration (pretty_printer *buffer, tree node, | |
| 227 int spc, int flags) | |
| 228 { | |
| 229 bool wrote_arg = false; | |
| 230 tree arg; | |
| 231 | |
| 232 pp_space (buffer); | |
| 233 pp_character (buffer, '('); | |
| 234 | |
| 235 /* Print the argument types. The last element in the list is a VOID_TYPE. | |
| 236 The following avoids printing the last element. */ | |
| 237 arg = TYPE_ARG_TYPES (node); | |
| 238 while (arg && TREE_CHAIN (arg) && arg != error_mark_node) | |
| 239 { | |
| 240 wrote_arg = true; | |
| 241 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false); | |
| 242 arg = TREE_CHAIN (arg); | |
| 243 if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST) | |
| 244 { | |
| 245 pp_character (buffer, ','); | |
| 246 pp_space (buffer); | |
| 247 } | |
| 248 } | |
| 249 | |
| 250 if (!wrote_arg) | |
| 251 pp_string (buffer, "void"); | |
| 252 | |
| 253 pp_character (buffer, ')'); | |
| 254 } | |
| 255 | |
| 256 /* Dump the domain associated with an array. */ | |
| 257 | |
| 258 static void | |
| 259 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags) | |
| 260 { | |
| 261 pp_character (buffer, '['); | |
| 262 if (domain) | |
| 263 { | |
| 264 tree min = TYPE_MIN_VALUE (domain); | |
| 265 tree max = TYPE_MAX_VALUE (domain); | |
| 266 | |
| 267 if (min && max | |
| 268 && integer_zerop (min) | |
| 269 && host_integerp (max, 0)) | |
| 270 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1); | |
| 271 else | |
| 272 { | |
| 273 if (min) | |
| 274 dump_generic_node (buffer, min, spc, flags, false); | |
| 275 pp_character (buffer, ':'); | |
| 276 if (max) | |
| 277 dump_generic_node (buffer, max, spc, flags, false); | |
| 278 } | |
| 279 } | |
| 280 else | |
| 281 pp_string (buffer, "<unknown>"); | |
| 282 pp_character (buffer, ']'); | |
| 283 } | |
| 284 | |
| 285 | |
| 286 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in | |
| 287 dump_generic_node. */ | |
| 288 | |
| 289 static void | |
| 290 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) | |
| 291 { | |
| 292 const char *name; | |
| 293 | |
| 294 switch (OMP_CLAUSE_CODE (clause)) | |
| 295 { | |
| 296 case OMP_CLAUSE_PRIVATE: | |
| 297 name = "private"; | |
| 298 goto print_remap; | |
| 299 case OMP_CLAUSE_SHARED: | |
| 300 name = "shared"; | |
| 301 goto print_remap; | |
| 302 case OMP_CLAUSE_FIRSTPRIVATE: | |
| 303 name = "firstprivate"; | |
| 304 goto print_remap; | |
| 305 case OMP_CLAUSE_LASTPRIVATE: | |
| 306 name = "lastprivate"; | |
| 307 goto print_remap; | |
| 308 case OMP_CLAUSE_COPYIN: | |
| 309 name = "copyin"; | |
| 310 goto print_remap; | |
| 311 case OMP_CLAUSE_COPYPRIVATE: | |
| 312 name = "copyprivate"; | |
| 313 goto print_remap; | |
| 314 print_remap: | |
| 315 pp_string (buffer, name); | |
| 316 pp_character (buffer, '('); | |
| 317 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), | |
| 318 spc, flags, false); | |
| 319 pp_character (buffer, ')'); | |
| 320 break; | |
| 321 | |
| 322 case OMP_CLAUSE_REDUCTION: | |
| 323 pp_string (buffer, "reduction("); | |
| 324 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); | |
| 325 pp_character (buffer, ':'); | |
| 326 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), | |
| 327 spc, flags, false); | |
| 328 pp_character (buffer, ')'); | |
| 329 break; | |
| 330 | |
| 331 case OMP_CLAUSE_IF: | |
| 332 pp_string (buffer, "if("); | |
| 333 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause), | |
| 334 spc, flags, false); | |
| 335 pp_character (buffer, ')'); | |
| 336 break; | |
| 337 | |
| 338 case OMP_CLAUSE_NUM_THREADS: | |
| 339 pp_string (buffer, "num_threads("); | |
| 340 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause), | |
| 341 spc, flags, false); | |
| 342 pp_character (buffer, ')'); | |
| 343 break; | |
| 344 | |
| 345 case OMP_CLAUSE_NOWAIT: | |
| 346 pp_string (buffer, "nowait"); | |
| 347 break; | |
| 348 case OMP_CLAUSE_ORDERED: | |
| 349 pp_string (buffer, "ordered"); | |
| 350 break; | |
| 351 | |
| 352 case OMP_CLAUSE_DEFAULT: | |
| 353 pp_string (buffer, "default("); | |
| 354 switch (OMP_CLAUSE_DEFAULT_KIND (clause)) | |
| 355 { | |
| 356 case OMP_CLAUSE_DEFAULT_UNSPECIFIED: | |
| 357 break; | |
| 358 case OMP_CLAUSE_DEFAULT_SHARED: | |
| 359 pp_string (buffer, "shared"); | |
| 360 break; | |
| 361 case OMP_CLAUSE_DEFAULT_NONE: | |
| 362 pp_string (buffer, "none"); | |
| 363 break; | |
| 364 case OMP_CLAUSE_DEFAULT_PRIVATE: | |
| 365 pp_string (buffer, "private"); | |
| 366 break; | |
| 367 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE: | |
| 368 pp_string (buffer, "firstprivate"); | |
| 369 break; | |
| 370 default: | |
| 371 gcc_unreachable (); | |
| 372 } | |
| 373 pp_character (buffer, ')'); | |
| 374 break; | |
| 375 | |
| 376 case OMP_CLAUSE_SCHEDULE: | |
| 377 pp_string (buffer, "schedule("); | |
| 378 switch (OMP_CLAUSE_SCHEDULE_KIND (clause)) | |
| 379 { | |
| 380 case OMP_CLAUSE_SCHEDULE_STATIC: | |
| 381 pp_string (buffer, "static"); | |
| 382 break; | |
| 383 case OMP_CLAUSE_SCHEDULE_DYNAMIC: | |
| 384 pp_string (buffer, "dynamic"); | |
| 385 break; | |
| 386 case OMP_CLAUSE_SCHEDULE_GUIDED: | |
| 387 pp_string (buffer, "guided"); | |
| 388 break; | |
| 389 case OMP_CLAUSE_SCHEDULE_RUNTIME: | |
| 390 pp_string (buffer, "runtime"); | |
| 391 break; | |
| 392 case OMP_CLAUSE_SCHEDULE_AUTO: | |
| 393 pp_string (buffer, "auto"); | |
| 394 break; | |
| 395 default: | |
| 396 gcc_unreachable (); | |
| 397 } | |
| 398 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) | |
| 399 { | |
| 400 pp_character (buffer, ','); | |
| 401 dump_generic_node (buffer, | |
| 402 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause), | |
| 403 spc, flags, false); | |
| 404 } | |
| 405 pp_character (buffer, ')'); | |
| 406 break; | |
| 407 | |
| 408 case OMP_CLAUSE_UNTIED: | |
| 409 pp_string (buffer, "untied"); | |
| 410 break; | |
| 411 | |
| 412 case OMP_CLAUSE_COLLAPSE: | |
| 413 pp_string (buffer, "collapse("); | |
| 414 dump_generic_node (buffer, | |
| 415 OMP_CLAUSE_COLLAPSE_EXPR (clause), | |
| 416 spc, flags, false); | |
| 417 pp_character (buffer, ')'); | |
| 418 break; | |
| 419 | |
| 420 default: | |
| 421 /* Should never happen. */ | |
| 422 dump_generic_node (buffer, clause, spc, flags, false); | |
| 423 break; | |
| 424 } | |
| 425 } | |
| 426 | |
| 427 | |
| 428 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in | |
| 429 dump_generic_node. */ | |
| 430 | |
| 431 void | |
| 432 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) | |
| 433 { | |
| 434 if (clause == NULL) | |
| 435 return; | |
| 436 | |
| 437 pp_space (buffer); | |
| 438 while (1) | |
| 439 { | |
| 440 dump_omp_clause (buffer, clause, spc, flags); | |
| 441 clause = OMP_CLAUSE_CHAIN (clause); | |
| 442 if (clause == NULL) | |
| 443 return; | |
| 444 pp_space (buffer); | |
| 445 } | |
| 446 } | |
| 447 | |
| 448 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
449 /* Dump location LOC to BUFFER. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
450 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
451 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
452 dump_location (pretty_printer *buffer, location_t loc) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
453 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
454 expanded_location xloc = expand_location (loc); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
455 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
456 pp_character (buffer, '['); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
457 if (xloc.file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
458 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
459 pp_string (buffer, xloc.file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
460 pp_string (buffer, " : "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
461 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
462 pp_decimal_int (buffer, xloc.line); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
463 pp_string (buffer, "] "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
464 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
465 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
466 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
467 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
468 dump_generic_node. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
469 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
470 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
471 dump_block_node (pretty_printer *buffer, tree block, int spc, int flags) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
472 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
473 tree t; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
474 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
475 pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
476 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
477 if (flags & TDF_ADDRESS) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
478 pp_printf (buffer, "[%p] ", (void *) block); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
479 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
480 if (BLOCK_ABSTRACT (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
481 pp_string (buffer, "[abstract] "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
482 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
483 if (TREE_ASM_WRITTEN (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
484 pp_string (buffer, "[written] "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
485 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
486 if (flags & TDF_SLIM) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
487 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
488 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
489 if (BLOCK_SOURCE_LOCATION (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
490 dump_location (buffer, BLOCK_SOURCE_LOCATION (block)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
491 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
492 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
494 if (BLOCK_SUPERCONTEXT (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
495 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
496 pp_string (buffer, "SUPERCONTEXT: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
497 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
498 flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
499 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
500 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
501 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
502 if (BLOCK_SUBBLOCKS (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
503 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
504 pp_string (buffer, "SUBBLOCKS: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
505 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
506 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
507 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
508 pp_string (buffer, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
509 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
510 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
511 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
512 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
513 if (BLOCK_CHAIN (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
514 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
515 pp_string (buffer, "SIBLINGS: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
516 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
517 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
518 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
519 pp_string (buffer, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
520 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
521 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
522 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
523 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
524 if (BLOCK_VARS (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
525 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
526 pp_string (buffer, "VARS: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
527 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
528 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
529 dump_generic_node (buffer, t, 0, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
530 pp_string (buffer, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
531 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
532 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
533 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
534 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
535 if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
536 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
537 unsigned i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
538 VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
539 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
540 pp_string (buffer, "NONLOCALIZED_VARS: "); |
|
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
|
541 FOR_EACH_VEC_ELT (tree, nlv, i, t) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
542 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
543 dump_generic_node (buffer, t, 0, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
544 pp_string (buffer, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
545 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
546 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
547 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
548 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
549 if (BLOCK_ABSTRACT_ORIGIN (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
550 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
551 pp_string (buffer, "ABSTRACT_ORIGIN: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
552 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
553 flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
554 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
555 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
556 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
557 if (BLOCK_FRAGMENT_ORIGIN (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
558 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
559 pp_string (buffer, "FRAGMENT_ORIGIN: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
560 dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
561 flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
562 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
563 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
564 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
565 if (BLOCK_FRAGMENT_CHAIN (block)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
566 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
567 pp_string (buffer, "FRAGMENT_CHAIN: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
568 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
569 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
570 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
571 pp_string (buffer, " "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
572 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
573 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
574 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
575 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
576 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
577 |
| 0 | 578 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of |
| 579 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 580 tree-pass.h). If IS_STMT is true, the object printed is considered | |
| 581 to be a statement and it is terminated by ';' if appropriate. */ | |
| 582 | |
| 583 int | |
| 584 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, | |
| 585 bool is_stmt) | |
| 586 { | |
| 587 tree type; | |
| 588 tree op0, op1; | |
| 589 const char *str; | |
| 590 bool is_expr; | |
| 591 | |
| 592 if (node == NULL_TREE) | |
| 593 return spc; | |
| 594 | |
| 595 is_expr = EXPR_P (node); | |
| 596 | |
| 597 if (is_stmt && (flags & TDF_STMTADDR)) | |
| 598 pp_printf (buffer, "<&%p> ", (void *)node); | |
| 599 | |
| 600 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
601 dump_location (buffer, EXPR_LOCATION (node)); |
| 0 | 602 |
| 603 switch (TREE_CODE (node)) | |
| 604 { | |
| 605 case ERROR_MARK: | |
| 606 pp_string (buffer, "<<< error >>>"); | |
| 607 break; | |
| 608 | |
| 609 case IDENTIFIER_NODE: | |
| 610 pp_tree_identifier (buffer, node); | |
| 611 break; | |
| 612 | |
| 613 case TREE_LIST: | |
| 614 while (node && node != error_mark_node) | |
| 615 { | |
| 616 if (TREE_PURPOSE (node)) | |
| 617 { | |
| 618 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false); | |
| 619 pp_space (buffer); | |
| 620 } | |
| 621 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false); | |
| 622 node = TREE_CHAIN (node); | |
| 623 if (node && TREE_CODE (node) == TREE_LIST) | |
| 624 { | |
| 625 pp_character (buffer, ','); | |
| 626 pp_space (buffer); | |
| 627 } | |
| 628 } | |
| 629 break; | |
| 630 | |
| 631 case TREE_BINFO: | |
| 632 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
633 break; |
| 0 | 634 |
| 635 case TREE_VEC: | |
| 636 { | |
| 637 size_t i; | |
| 638 if (TREE_VEC_LENGTH (node) > 0) | |
| 639 { | |
| 640 size_t len = TREE_VEC_LENGTH (node); | |
| 641 for (i = 0; i < len - 1; i++) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
642 { |
| 0 | 643 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags, |
| 644 false); | |
| 645 pp_character (buffer, ','); | |
| 646 pp_space (buffer); | |
| 647 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
648 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, |
| 0 | 649 flags, false); |
| 650 } | |
| 651 } | |
| 652 break; | |
| 653 | |
| 654 case VOID_TYPE: | |
| 655 case INTEGER_TYPE: | |
| 656 case REAL_TYPE: | |
| 657 case FIXED_POINT_TYPE: | |
| 658 case COMPLEX_TYPE: | |
| 659 case VECTOR_TYPE: | |
| 660 case ENUMERAL_TYPE: | |
| 661 case BOOLEAN_TYPE: | |
| 662 { | |
| 663 unsigned int quals = TYPE_QUALS (node); | |
| 664 enum tree_code_class tclass; | |
| 665 | |
| 666 if (quals & TYPE_QUAL_CONST) | |
| 667 pp_string (buffer, "const "); | |
| 668 else if (quals & TYPE_QUAL_VOLATILE) | |
| 669 pp_string (buffer, "volatile "); | |
| 670 else if (quals & TYPE_QUAL_RESTRICT) | |
| 671 pp_string (buffer, "restrict "); | |
| 672 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
673 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
|
674 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
675 pp_string (buffer, "<address-space-"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
676 pp_decimal_int (buffer, 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
|
677 pp_string (buffer, "> "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
678 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
679 |
| 0 | 680 tclass = TREE_CODE_CLASS (TREE_CODE (node)); |
| 681 | |
| 682 if (tclass == tcc_declaration) | |
| 683 { | |
| 684 if (DECL_NAME (node)) | |
| 685 dump_decl_name (buffer, node, flags); | |
| 686 else | |
| 687 pp_string (buffer, "<unnamed type decl>"); | |
| 688 } | |
| 689 else if (tclass == tcc_type) | |
| 690 { | |
| 691 if (TYPE_NAME (node)) | |
| 692 { | |
| 693 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) | |
| 694 pp_tree_identifier (buffer, TYPE_NAME (node)); | |
| 695 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL | |
| 696 && DECL_NAME (TYPE_NAME (node))) | |
| 697 dump_decl_name (buffer, TYPE_NAME (node), flags); | |
| 698 else | |
| 699 pp_string (buffer, "<unnamed type>"); | |
| 700 } | |
| 701 else if (TREE_CODE (node) == VECTOR_TYPE) | |
| 702 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
703 pp_string (buffer, "vector"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
704 pp_character (buffer, '('); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
705 pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
706 pp_string (buffer, ") "); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
707 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); |
| 0 | 708 } |
| 709 else if (TREE_CODE (node) == INTEGER_TYPE) | |
| 710 { | |
| 711 pp_string (buffer, (TYPE_UNSIGNED (node) | |
| 712 ? "<unnamed-unsigned:" | |
| 713 : "<unnamed-signed:")); | |
| 714 pp_decimal_int (buffer, TYPE_PRECISION (node)); | |
| 715 pp_string (buffer, ">"); | |
| 716 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
717 else if (TREE_CODE (node) == COMPLEX_TYPE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
718 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
719 pp_string (buffer, "__complex__ "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
720 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
721 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
722 else if (TREE_CODE (node) == REAL_TYPE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
723 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
724 pp_string (buffer, "<float:"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
725 pp_decimal_int (buffer, TYPE_PRECISION (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
726 pp_string (buffer, ">"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
727 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
728 else if (TREE_CODE (node) == FIXED_POINT_TYPE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
729 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
730 pp_string (buffer, "<fixed-point-"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
731 pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
732 pp_decimal_int (buffer, TYPE_PRECISION (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
733 pp_string (buffer, ">"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
734 } |
|
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
|
735 else if (TREE_CODE (node) == VOID_TYPE) |
|
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
|
736 pp_string (buffer, "void"); |
| 0 | 737 else |
| 738 pp_string (buffer, "<unnamed type>"); | |
| 739 } | |
| 740 break; | |
| 741 } | |
| 742 | |
| 743 case POINTER_TYPE: | |
| 744 case REFERENCE_TYPE: | |
| 745 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&"); | |
| 746 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
747 if (TREE_TYPE (node) == NULL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
748 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
749 pp_string (buffer, str); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
750 pp_string (buffer, "<null type>"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
751 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
752 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) |
| 0 | 753 { |
| 754 tree fnode = TREE_TYPE (node); | |
| 755 | |
| 756 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false); | |
| 757 pp_space (buffer); | |
| 758 pp_character (buffer, '('); | |
| 759 pp_string (buffer, str); | |
| 760 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) | |
| 761 dump_decl_name (buffer, TYPE_NAME (node), flags); | |
|
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
|
762 else if (flags & TDF_NOUID) |
|
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
|
763 pp_printf (buffer, "<Txxxx>"); |
| 0 | 764 else |
| 765 pp_printf (buffer, "<T%x>", TYPE_UID (node)); | |
| 766 | |
| 767 pp_character (buffer, ')'); | |
| 768 dump_function_declaration (buffer, fnode, spc, flags); | |
| 769 } | |
| 770 else | |
| 771 { | |
| 772 unsigned int quals = TYPE_QUALS (node); | |
| 773 | |
| 774 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); | |
| 775 pp_space (buffer); | |
| 776 pp_string (buffer, str); | |
| 777 | |
| 778 if (quals & TYPE_QUAL_CONST) | |
| 779 pp_string (buffer, " const"); | |
| 780 if (quals & TYPE_QUAL_VOLATILE) | |
| 781 pp_string (buffer, " volatile"); | |
| 782 if (quals & TYPE_QUAL_RESTRICT) | |
| 783 pp_string (buffer, " restrict"); | |
| 784 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
785 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
|
786 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
787 pp_string (buffer, " <address-space-"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
788 pp_decimal_int (buffer, 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
|
789 pp_string (buffer, ">"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
790 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
791 |
| 0 | 792 if (TYPE_REF_CAN_ALIAS_ALL (node)) |
| 793 pp_string (buffer, " {ref-all}"); | |
| 794 } | |
| 795 break; | |
| 796 | |
| 797 case OFFSET_TYPE: | |
| 798 NIY; | |
| 799 break; | |
| 800 | |
|
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
|
801 case MEM_REF: |
|
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
|
802 { |
|
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
|
803 if (integer_zerop (TREE_OPERAND (node, 1)) |
|
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
|
804 /* Dump the types of INTEGER_CSTs explicitly, for we can't |
|
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
|
805 infer them and MEM_ATTR caching will share MEM_REFs |
|
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
|
806 with differently-typed op0s. */ |
|
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
|
807 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST |
|
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
|
808 /* Same pointer types, but ignoring POINTER_TYPE vs. |
|
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
|
809 REFERENCE_TYPE. */ |
|
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
|
810 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0))) |
|
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
|
811 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
|
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
|
812 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0))) |
|
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
|
813 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1)))) |
|
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
|
814 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0))) |
|
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
|
815 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1)))) |
|
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
|
816 /* Same value types ignoring qualifiers. */ |
|
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
|
817 && (TYPE_MAIN_VARIANT (TREE_TYPE (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
|
818 == TYPE_MAIN_VARIANT |
|
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
|
819 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))) |
|
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
|
820 { |
|
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
|
821 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR) |
|
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
|
822 { |
|
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
|
823 pp_string (buffer, "*"); |
|
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
|
824 dump_generic_node (buffer, TREE_OPERAND (node, 0), |
|
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
|
825 spc, flags, false); |
|
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
|
826 } |
|
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
|
827 else |
|
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
|
828 dump_generic_node (buffer, |
|
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
|
829 TREE_OPERAND (TREE_OPERAND (node, 0), 0), |
|
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
|
830 spc, flags, false); |
|
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
|
831 } |
|
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
|
832 else |
|
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
|
833 { |
|
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
|
834 tree ptype; |
|
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
|
835 |
|
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
|
836 pp_string (buffer, "MEM["); |
|
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
|
837 pp_string (buffer, "("); |
|
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
|
838 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1))); |
|
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
|
839 dump_generic_node (buffer, ptype, |
|
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
|
840 spc, flags | TDF_SLIM, false); |
|
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
|
841 pp_string (buffer, ")"); |
|
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
|
842 dump_generic_node (buffer, TREE_OPERAND (node, 0), |
|
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
|
843 spc, flags, false); |
|
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
|
844 if (!integer_zerop (TREE_OPERAND (node, 1))) |
|
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
|
845 { |
|
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
|
846 pp_string (buffer, " + "); |
|
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
|
847 dump_generic_node (buffer, TREE_OPERAND (node, 1), |
|
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
|
848 spc, flags, false); |
|
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
|
849 } |
|
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
|
850 pp_string (buffer, "]"); |
|
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
|
851 } |
|
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
|
852 break; |
|
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
|
853 } |
|
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
|
854 |
| 0 | 855 case TARGET_MEM_REF: |
| 856 { | |
| 857 const char *sep = ""; | |
| 858 tree tmp; | |
| 859 | |
| 860 pp_string (buffer, "MEM["); | |
| 861 | |
|
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
|
862 if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR) |
| 0 | 863 { |
| 864 pp_string (buffer, sep); | |
| 865 sep = ", "; | |
| 866 pp_string (buffer, "symbol: "); | |
|
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
|
867 dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0), |
|
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
|
868 spc, flags, false); |
| 0 | 869 } |
|
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
|
870 else |
|
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
|
871 { |
|
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
|
872 pp_string (buffer, sep); |
|
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
|
873 sep = ", "; |
|
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
|
874 pp_string (buffer, "base: "); |
|
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
|
875 dump_generic_node (buffer, TMR_BASE (node), spc, flags, false); |
|
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
|
876 } |
|
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
|
877 tmp = TMR_INDEX2 (node); |
| 0 | 878 if (tmp) |
| 879 { | |
| 880 pp_string (buffer, sep); | |
| 881 sep = ", "; | |
| 882 pp_string (buffer, "base: "); | |
| 883 dump_generic_node (buffer, tmp, spc, flags, false); | |
| 884 } | |
| 885 tmp = TMR_INDEX (node); | |
| 886 if (tmp) | |
| 887 { | |
| 888 pp_string (buffer, sep); | |
| 889 sep = ", "; | |
| 890 pp_string (buffer, "index: "); | |
| 891 dump_generic_node (buffer, tmp, spc, flags, false); | |
| 892 } | |
| 893 tmp = TMR_STEP (node); | |
| 894 if (tmp) | |
| 895 { | |
| 896 pp_string (buffer, sep); | |
| 897 sep = ", "; | |
| 898 pp_string (buffer, "step: "); | |
| 899 dump_generic_node (buffer, tmp, spc, flags, false); | |
| 900 } | |
| 901 tmp = TMR_OFFSET (node); | |
| 902 if (tmp) | |
| 903 { | |
| 904 pp_string (buffer, sep); | |
| 905 sep = ", "; | |
| 906 pp_string (buffer, "offset: "); | |
| 907 dump_generic_node (buffer, tmp, spc, flags, false); | |
| 908 } | |
| 909 pp_string (buffer, "]"); | |
| 910 } | |
| 911 break; | |
| 912 | |
| 913 case ARRAY_TYPE: | |
| 914 { | |
| 915 tree tmp; | |
| 916 | |
| 917 /* Print the innermost component type. */ | |
| 918 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE; | |
| 919 tmp = TREE_TYPE (tmp)) | |
| 920 ; | |
| 921 dump_generic_node (buffer, tmp, spc, flags, false); | |
| 922 | |
| 923 /* Print the dimensions. */ | |
| 924 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp)) | |
| 925 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags); | |
| 926 break; | |
| 927 } | |
| 928 | |
| 929 case RECORD_TYPE: | |
| 930 case UNION_TYPE: | |
| 931 case QUAL_UNION_TYPE: | |
| 932 { | |
| 933 unsigned int quals = TYPE_QUALS (node); | |
| 934 | |
| 935 if (quals & TYPE_QUAL_CONST) | |
| 936 pp_string (buffer, "const "); | |
| 937 if (quals & TYPE_QUAL_VOLATILE) | |
| 938 pp_string (buffer, "volatile "); | |
| 939 | |
| 940 /* Print the name of the structure. */ | |
| 941 if (TREE_CODE (node) == RECORD_TYPE) | |
| 942 pp_string (buffer, "struct "); | |
| 943 else if (TREE_CODE (node) == UNION_TYPE) | |
| 944 pp_string (buffer, "union "); | |
| 945 | |
| 946 if (TYPE_NAME (node)) | |
| 947 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
948 else if (!(flags & TDF_SLIM)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
949 /* FIXME: If we eliminate the 'else' above and attempt |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
950 to show the fields for named types, we may get stuck |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
951 following a cycle of pointers to structs. The alleged |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
952 self-reference check in print_struct_decl will not detect |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
953 cycles involving more than one pointer or struct type. */ |
| 0 | 954 print_struct_decl (buffer, node, spc, flags); |
| 955 break; | |
| 956 } | |
| 957 | |
| 958 case LANG_TYPE: | |
| 959 NIY; | |
| 960 break; | |
| 961 | |
| 962 case INTEGER_CST: | |
| 963 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE) | |
| 964 { | |
| 965 /* In the case of a pointer, one may want to divide by the | |
| 966 size of the pointed-to type. Unfortunately, this not | |
| 967 straightforward. The C front-end maps expressions | |
| 968 | |
| 969 (int *) 5 | |
| 970 int *p; (p + 5) | |
| 971 | |
| 972 in such a way that the two INTEGER_CST nodes for "5" have | |
| 973 different values but identical types. In the latter | |
| 974 case, the 5 is multiplied by sizeof (int) in c-common.c | |
| 975 (pointer_int_sum) to convert it to a byte address, and | |
| 976 yet the type of the node is left unchanged. Argh. What | |
| 977 is consistent though is that the number value corresponds | |
| 978 to bytes (UNITS) offset. | |
| 979 | |
| 980 NB: Neither of the following divisors can be trivially | |
| 981 used to recover the original literal: | |
| 982 | |
| 983 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node))) | |
| 984 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */ | |
| 985 pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); | |
| 986 pp_string (buffer, "B"); /* pseudo-unit */ | |
| 987 } | |
| 988 else if (! host_integerp (node, 0)) | |
| 989 { | |
| 990 tree val = node; | |
| 991 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val); | |
| 992 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val); | |
| 993 | |
| 994 if (tree_int_cst_sgn (val) < 0) | |
| 995 { | |
| 996 pp_character (buffer, '-'); | |
| 997 high = ~high + !low; | |
| 998 low = -low; | |
| 999 } | |
| 1000 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all | |
| 1001 systems? */ | |
| 1002 sprintf (pp_buffer (buffer)->digit_buffer, | |
| 1003 HOST_WIDE_INT_PRINT_DOUBLE_HEX, | |
| 1004 (unsigned HOST_WIDE_INT) high, low); | |
| 1005 pp_string (buffer, pp_buffer (buffer)->digit_buffer); | |
| 1006 } | |
| 1007 else | |
| 1008 pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); | |
| 1009 break; | |
| 1010 | |
| 1011 case REAL_CST: | |
| 1012 /* Code copied from print_node. */ | |
| 1013 { | |
| 1014 REAL_VALUE_TYPE d; | |
| 1015 if (TREE_OVERFLOW (node)) | |
| 1016 pp_string (buffer, " overflow"); | |
| 1017 | |
| 1018 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) | |
| 1019 d = TREE_REAL_CST (node); | |
| 1020 if (REAL_VALUE_ISINF (d)) | |
| 1021 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); | |
| 1022 else if (REAL_VALUE_ISNAN (d)) | |
| 1023 pp_string (buffer, " Nan"); | |
| 1024 else | |
| 1025 { | |
| 1026 char string[100]; | |
| 1027 real_to_decimal (string, &d, sizeof (string), 0, 1); | |
| 1028 pp_string (buffer, string); | |
| 1029 } | |
| 1030 #else | |
| 1031 { | |
| 1032 HOST_WIDE_INT i; | |
| 1033 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node); | |
| 1034 pp_string (buffer, "0x"); | |
| 1035 for (i = 0; i < sizeof TREE_REAL_CST (node); i++) | |
| 1036 output_formatted_integer (buffer, "%02x", *p++); | |
| 1037 } | |
| 1038 #endif | |
| 1039 break; | |
| 1040 } | |
| 1041 | |
| 1042 case FIXED_CST: | |
| 1043 { | |
| 1044 char string[100]; | |
| 1045 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string)); | |
| 1046 pp_string (buffer, string); | |
| 1047 break; | |
| 1048 } | |
| 1049 | |
| 1050 case COMPLEX_CST: | |
| 1051 pp_string (buffer, "__complex__ ("); | |
| 1052 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false); | |
| 1053 pp_string (buffer, ", "); | |
| 1054 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false); | |
| 1055 pp_string (buffer, ")"); | |
| 1056 break; | |
| 1057 | |
| 1058 case STRING_CST: | |
| 1059 pp_string (buffer, "\""); | |
| 1060 pretty_print_string (buffer, TREE_STRING_POINTER (node)); | |
| 1061 pp_string (buffer, "\""); | |
| 1062 break; | |
| 1063 | |
| 1064 case VECTOR_CST: | |
| 1065 { | |
| 1066 tree elt; | |
| 1067 pp_string (buffer, "{ "); | |
| 1068 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt)) | |
| 1069 { | |
| 1070 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false); | |
| 1071 if (TREE_CHAIN (elt)) | |
| 1072 pp_string (buffer, ", "); | |
| 1073 } | |
| 1074 pp_string (buffer, " }"); | |
| 1075 } | |
| 1076 break; | |
| 1077 | |
| 1078 case FUNCTION_TYPE: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1079 case METHOD_TYPE: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1080 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1081 pp_space (buffer); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1082 if (TREE_CODE (node) == METHOD_TYPE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1083 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1084 if (TYPE_METHOD_BASETYPE (node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1085 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1086 flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1087 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1088 pp_string (buffer, "<null method basetype>"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1089 pp_string (buffer, "::"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1090 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1091 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1092 dump_decl_name (buffer, TYPE_NAME (node), flags); |
|
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
|
1093 else if (flags & TDF_NOUID) |
|
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
|
1094 pp_printf (buffer, "<Txxxx>"); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1095 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1096 pp_printf (buffer, "<T%x>", TYPE_UID (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1097 dump_function_declaration (buffer, node, spc, flags); |
| 0 | 1098 break; |
| 1099 | |
| 1100 case FUNCTION_DECL: | |
| 1101 case CONST_DECL: | |
| 1102 dump_decl_name (buffer, node, flags); | |
| 1103 break; | |
| 1104 | |
| 1105 case LABEL_DECL: | |
| 1106 if (DECL_NAME (node)) | |
| 1107 dump_decl_name (buffer, node, flags); | |
| 1108 else if (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
|
1109 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node)); |
| 0 | 1110 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1111 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1112 if (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
|
1113 pp_string (buffer, "<D.xxxx>"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1114 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1115 pp_printf (buffer, "<D.%u>", 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
|
1116 } |
| 0 | 1117 break; |
| 1118 | |
| 1119 case TYPE_DECL: | |
| 1120 if (DECL_IS_BUILTIN (node)) | |
| 1121 { | |
| 1122 /* Don't print the declaration of built-in types. */ | |
| 1123 break; | |
| 1124 } | |
| 1125 if (DECL_NAME (node)) | |
| 1126 dump_decl_name (buffer, node, flags); | |
|
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
|
1127 else if (TYPE_NAME (TREE_TYPE (node)) != node) |
| 0 | 1128 { |
| 1129 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE | |
| 1130 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) | |
| 1131 && TYPE_METHODS (TREE_TYPE (node))) | |
| 1132 { | |
| 1133 /* The type is a c++ class: all structures have at least | |
| 1134 4 methods. */ | |
| 1135 pp_string (buffer, "class "); | |
| 1136 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); | |
| 1137 } | |
| 1138 else | |
| 1139 { | |
| 1140 pp_string (buffer, | |
| 1141 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE | |
| 1142 ? "union" : "struct ")); | |
| 1143 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); | |
| 1144 } | |
| 1145 } | |
|
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
|
1146 else |
|
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
|
1147 pp_string (buffer, "<anon>"); |
| 0 | 1148 break; |
| 1149 | |
| 1150 case VAR_DECL: | |
| 1151 case PARM_DECL: | |
| 1152 case FIELD_DECL: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1153 case DEBUG_EXPR_DECL: |
| 0 | 1154 case NAMESPACE_DECL: |
| 1155 dump_decl_name (buffer, node, flags); | |
| 1156 break; | |
| 1157 | |
| 1158 case RESULT_DECL: | |
| 1159 pp_string (buffer, "<retval>"); | |
| 1160 break; | |
| 1161 | |
| 1162 case COMPONENT_REF: | |
| 1163 op0 = TREE_OPERAND (node, 0); | |
| 1164 str = "."; | |
|
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
|
1165 if (op0 |
|
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
|
1166 && (TREE_CODE (op0) == INDIRECT_REF |
|
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
|
1167 || (TREE_CODE (op0) == MEM_REF |
|
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
|
1168 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR |
|
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
|
1169 && integer_zerop (TREE_OPERAND (op0, 1)) |
|
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
|
1170 /* Dump the types of INTEGER_CSTs explicitly, for we |
|
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
|
1171 can't infer them and MEM_ATTR caching will share |
|
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
|
1172 MEM_REFs with differently-typed op0s. */ |
|
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
|
1173 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST |
|
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
|
1174 /* Same pointer types, but ignoring POINTER_TYPE vs. |
|
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
|
1175 REFERENCE_TYPE. */ |
|
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
|
1176 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
|
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
|
1177 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
|
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
|
1178 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0))) |
|
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
|
1179 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
|
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
|
1180 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0))) |
|
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
|
1181 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1)))) |
|
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
|
1182 /* Same value types ignoring qualifiers. */ |
|
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
|
1183 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0)) |
|
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
|
1184 == TYPE_MAIN_VARIANT |
|
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
|
1185 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))))) |
| 0 | 1186 { |
| 1187 op0 = TREE_OPERAND (op0, 0); | |
| 1188 str = "->"; | |
| 1189 } | |
| 1190 if (op_prio (op0) < op_prio (node)) | |
| 1191 pp_character (buffer, '('); | |
| 1192 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1193 if (op_prio (op0) < op_prio (node)) | |
| 1194 pp_character (buffer, ')'); | |
| 1195 pp_string (buffer, str); | |
| 1196 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1197 op0 = component_ref_field_offset (node); | |
| 1198 if (op0 && TREE_CODE (op0) != INTEGER_CST) | |
| 1199 { | |
| 1200 pp_string (buffer, "{off: "); | |
| 1201 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1202 pp_character (buffer, '}'); | |
| 1203 } | |
| 1204 break; | |
| 1205 | |
| 1206 case BIT_FIELD_REF: | |
| 1207 pp_string (buffer, "BIT_FIELD_REF <"); | |
| 1208 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1209 pp_string (buffer, ", "); | |
| 1210 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1211 pp_string (buffer, ", "); | |
| 1212 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); | |
| 1213 pp_string (buffer, ">"); | |
| 1214 break; | |
| 1215 | |
| 1216 case ARRAY_REF: | |
| 1217 case ARRAY_RANGE_REF: | |
| 1218 op0 = TREE_OPERAND (node, 0); | |
| 1219 if (op_prio (op0) < op_prio (node)) | |
| 1220 pp_character (buffer, '('); | |
| 1221 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1222 if (op_prio (op0) < op_prio (node)) | |
| 1223 pp_character (buffer, ')'); | |
| 1224 pp_character (buffer, '['); | |
| 1225 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1226 if (TREE_CODE (node) == ARRAY_RANGE_REF) | |
| 1227 pp_string (buffer, " ..."); | |
| 1228 pp_character (buffer, ']'); | |
| 1229 | |
| 1230 op0 = array_ref_low_bound (node); | |
| 1231 op1 = array_ref_element_size (node); | |
| 1232 | |
| 1233 if (!integer_zerop (op0) | |
| 1234 || TREE_OPERAND (node, 2) | |
| 1235 || TREE_OPERAND (node, 3)) | |
| 1236 { | |
| 1237 pp_string (buffer, "{lb: "); | |
| 1238 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1239 pp_string (buffer, " sz: "); | |
| 1240 dump_generic_node (buffer, op1, spc, flags, false); | |
| 1241 pp_character (buffer, '}'); | |
| 1242 } | |
| 1243 break; | |
| 1244 | |
| 1245 case CONSTRUCTOR: | |
| 1246 { | |
| 1247 unsigned HOST_WIDE_INT ix; | |
| 1248 tree field, val; | |
| 1249 bool is_struct_init = FALSE; | |
| 1250 pp_character (buffer, '{'); | |
| 1251 if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE | |
| 1252 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) | |
| 1253 is_struct_init = TRUE; | |
| 1254 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) | |
| 1255 { | |
| 1256 if (field && is_struct_init) | |
| 1257 { | |
| 1258 pp_character (buffer, '.'); | |
| 1259 dump_generic_node (buffer, field, spc, flags, false); | |
| 1260 pp_string (buffer, "="); | |
| 1261 } | |
| 1262 if (val && TREE_CODE (val) == ADDR_EXPR) | |
| 1263 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) | |
| 1264 val = TREE_OPERAND (val, 0); | |
| 1265 if (val && TREE_CODE (val) == FUNCTION_DECL) | |
| 1266 dump_decl_name (buffer, val, flags); | |
| 1267 else | |
| 1268 dump_generic_node (buffer, val, spc, flags, false); | |
| 1269 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1) | |
| 1270 { | |
| 1271 pp_character (buffer, ','); | |
| 1272 pp_space (buffer); | |
| 1273 } | |
| 1274 } | |
| 1275 pp_character (buffer, '}'); | |
| 1276 } | |
| 1277 break; | |
| 1278 | |
| 1279 case COMPOUND_EXPR: | |
| 1280 { | |
| 1281 tree *tp; | |
| 1282 if (flags & TDF_SLIM) | |
| 1283 { | |
| 1284 pp_string (buffer, "<COMPOUND_EXPR>"); | |
| 1285 break; | |
| 1286 } | |
| 1287 | |
| 1288 dump_generic_node (buffer, TREE_OPERAND (node, 0), | |
| 1289 spc, flags, !(flags & TDF_SLIM)); | |
| 1290 if (flags & TDF_SLIM) | |
| 1291 newline_and_indent (buffer, spc); | |
| 1292 else | |
| 1293 { | |
| 1294 pp_character (buffer, ','); | |
| 1295 pp_space (buffer); | |
| 1296 } | |
| 1297 | |
| 1298 for (tp = &TREE_OPERAND (node, 1); | |
| 1299 TREE_CODE (*tp) == COMPOUND_EXPR; | |
| 1300 tp = &TREE_OPERAND (*tp, 1)) | |
| 1301 { | |
| 1302 dump_generic_node (buffer, TREE_OPERAND (*tp, 0), | |
| 1303 spc, flags, !(flags & TDF_SLIM)); | |
| 1304 if (flags & TDF_SLIM) | |
| 1305 newline_and_indent (buffer, spc); | |
| 1306 else | |
| 1307 { | |
| 1308 pp_character (buffer, ','); | |
| 1309 pp_space (buffer); | |
| 1310 } | |
| 1311 } | |
| 1312 | |
| 1313 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM)); | |
| 1314 } | |
| 1315 break; | |
| 1316 | |
| 1317 case STATEMENT_LIST: | |
| 1318 { | |
| 1319 tree_stmt_iterator si; | |
| 1320 bool first = true; | |
| 1321 | |
| 1322 if (flags & TDF_SLIM) | |
| 1323 { | |
| 1324 pp_string (buffer, "<STATEMENT_LIST>"); | |
| 1325 break; | |
| 1326 } | |
| 1327 | |
| 1328 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si)) | |
| 1329 { | |
| 1330 if (!first) | |
| 1331 newline_and_indent (buffer, spc); | |
| 1332 else | |
| 1333 first = false; | |
| 1334 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true); | |
| 1335 } | |
| 1336 } | |
| 1337 break; | |
| 1338 | |
| 1339 case MODIFY_EXPR: | |
| 1340 case INIT_EXPR: | |
| 1341 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, | |
| 1342 false); | |
| 1343 pp_space (buffer); | |
| 1344 pp_character (buffer, '='); | |
| 1345 if (TREE_CODE (node) == MODIFY_EXPR | |
| 1346 && MOVE_NONTEMPORAL (node)) | |
| 1347 pp_string (buffer, "{nt}"); | |
| 1348 pp_space (buffer); | |
| 1349 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, | |
| 1350 false); | |
| 1351 break; | |
| 1352 | |
| 1353 case TARGET_EXPR: | |
| 1354 pp_string (buffer, "TARGET_EXPR <"); | |
| 1355 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false); | |
| 1356 pp_character (buffer, ','); | |
| 1357 pp_space (buffer); | |
| 1358 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false); | |
| 1359 pp_character (buffer, '>'); | |
| 1360 break; | |
| 1361 | |
| 1362 case DECL_EXPR: | |
| 1363 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags); | |
| 1364 is_stmt = false; | |
| 1365 break; | |
| 1366 | |
| 1367 case COND_EXPR: | |
| 1368 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node) | |
| 1369 { | |
| 1370 pp_string (buffer, "if ("); | |
| 1371 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false); | |
| 1372 pp_character (buffer, ')'); | |
| 1373 /* The lowered cond_exprs should always be printed in full. */ | |
| 1374 if (COND_EXPR_THEN (node) | |
| 1375 && (IS_EMPTY_STMT (COND_EXPR_THEN (node)) | |
| 1376 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR) | |
| 1377 && COND_EXPR_ELSE (node) | |
| 1378 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node)) | |
| 1379 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) | |
| 1380 { | |
| 1381 pp_space (buffer); | |
| 1382 dump_generic_node (buffer, COND_EXPR_THEN (node), | |
| 1383 0, flags, true); | |
| 1384 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node))) | |
| 1385 { | |
| 1386 pp_string (buffer, " else "); | |
| 1387 dump_generic_node (buffer, COND_EXPR_ELSE (node), | |
| 1388 0, flags, true); | |
| 1389 } | |
| 1390 } | |
| 1391 else if (!(flags & TDF_SLIM)) | |
| 1392 { | |
| 1393 /* Output COND_EXPR_THEN. */ | |
| 1394 if (COND_EXPR_THEN (node)) | |
| 1395 { | |
| 1396 newline_and_indent (buffer, spc+2); | |
| 1397 pp_character (buffer, '{'); | |
| 1398 newline_and_indent (buffer, spc+4); | |
| 1399 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4, | |
| 1400 flags, true); | |
| 1401 newline_and_indent (buffer, spc+2); | |
| 1402 pp_character (buffer, '}'); | |
| 1403 } | |
| 1404 | |
| 1405 /* Output COND_EXPR_ELSE. */ | |
| 1406 if (COND_EXPR_ELSE (node) | |
| 1407 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node))) | |
| 1408 { | |
| 1409 newline_and_indent (buffer, spc); | |
| 1410 pp_string (buffer, "else"); | |
| 1411 newline_and_indent (buffer, spc+2); | |
| 1412 pp_character (buffer, '{'); | |
| 1413 newline_and_indent (buffer, spc+4); | |
| 1414 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4, | |
| 1415 flags, true); | |
| 1416 newline_and_indent (buffer, spc+2); | |
| 1417 pp_character (buffer, '}'); | |
| 1418 } | |
| 1419 } | |
| 1420 is_expr = false; | |
| 1421 } | |
| 1422 else | |
| 1423 { | |
| 1424 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1425 pp_space (buffer); | |
| 1426 pp_character (buffer, '?'); | |
| 1427 pp_space (buffer); | |
| 1428 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1429 pp_space (buffer); | |
| 1430 pp_character (buffer, ':'); | |
| 1431 pp_space (buffer); | |
| 1432 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); | |
| 1433 } | |
| 1434 break; | |
| 1435 | |
| 1436 case BIND_EXPR: | |
| 1437 pp_character (buffer, '{'); | |
| 1438 if (!(flags & TDF_SLIM)) | |
| 1439 { | |
| 1440 if (BIND_EXPR_VARS (node)) | |
| 1441 { | |
| 1442 pp_newline (buffer); | |
| 1443 | |
|
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
|
1444 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0)) |
| 0 | 1445 { |
| 1446 print_declaration (buffer, op0, spc+2, flags); | |
| 1447 pp_newline (buffer); | |
| 1448 } | |
| 1449 } | |
| 1450 | |
| 1451 newline_and_indent (buffer, spc+2); | |
| 1452 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true); | |
| 1453 newline_and_indent (buffer, spc); | |
| 1454 pp_character (buffer, '}'); | |
| 1455 } | |
| 1456 is_expr = false; | |
| 1457 break; | |
| 1458 | |
| 1459 case CALL_EXPR: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1460 print_call_name (buffer, CALL_EXPR_FN (node), flags); |
| 0 | 1461 |
| 1462 /* Print parameters. */ | |
| 1463 pp_space (buffer); | |
| 1464 pp_character (buffer, '('); | |
| 1465 { | |
| 1466 tree arg; | |
| 1467 call_expr_arg_iterator iter; | |
| 1468 FOR_EACH_CALL_EXPR_ARG (arg, iter, node) | |
| 1469 { | |
| 1470 dump_generic_node (buffer, arg, spc, flags, false); | |
| 1471 if (more_call_expr_args_p (&iter)) | |
| 1472 { | |
| 1473 pp_character (buffer, ','); | |
| 1474 pp_space (buffer); | |
| 1475 } | |
| 1476 } | |
| 1477 } | |
| 1478 if (CALL_EXPR_VA_ARG_PACK (node)) | |
| 1479 { | |
| 1480 if (call_expr_nargs (node) > 0) | |
| 1481 { | |
| 1482 pp_character (buffer, ','); | |
| 1483 pp_space (buffer); | |
| 1484 } | |
| 1485 pp_string (buffer, "__builtin_va_arg_pack ()"); | |
| 1486 } | |
| 1487 pp_character (buffer, ')'); | |
| 1488 | |
| 1489 op1 = CALL_EXPR_STATIC_CHAIN (node); | |
| 1490 if (op1) | |
| 1491 { | |
| 1492 pp_string (buffer, " [static-chain: "); | |
| 1493 dump_generic_node (buffer, op1, spc, flags, false); | |
| 1494 pp_character (buffer, ']'); | |
| 1495 } | |
| 1496 | |
| 1497 if (CALL_EXPR_RETURN_SLOT_OPT (node)) | |
| 1498 pp_string (buffer, " [return slot optimization]"); | |
| 1499 if (CALL_EXPR_TAILCALL (node)) | |
| 1500 pp_string (buffer, " [tail call]"); | |
| 1501 break; | |
| 1502 | |
| 1503 case WITH_CLEANUP_EXPR: | |
| 1504 NIY; | |
| 1505 break; | |
| 1506 | |
| 1507 case CLEANUP_POINT_EXPR: | |
| 1508 pp_string (buffer, "<<cleanup_point "); | |
| 1509 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1510 pp_string (buffer, ">>"); | |
| 1511 break; | |
| 1512 | |
| 1513 case PLACEHOLDER_EXPR: | |
| 1514 pp_string (buffer, "<PLACEHOLDER_EXPR "); | |
| 1515 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); | |
| 1516 pp_character (buffer, '>'); | |
| 1517 break; | |
| 1518 | |
| 1519 /* Binary arithmetic and logic expressions. */ | |
| 1520 case WIDEN_SUM_EXPR: | |
| 1521 case WIDEN_MULT_EXPR: | |
| 1522 case MULT_EXPR: | |
| 1523 case PLUS_EXPR: | |
| 1524 case POINTER_PLUS_EXPR: | |
| 1525 case MINUS_EXPR: | |
| 1526 case TRUNC_DIV_EXPR: | |
| 1527 case CEIL_DIV_EXPR: | |
| 1528 case FLOOR_DIV_EXPR: | |
| 1529 case ROUND_DIV_EXPR: | |
| 1530 case TRUNC_MOD_EXPR: | |
| 1531 case CEIL_MOD_EXPR: | |
| 1532 case FLOOR_MOD_EXPR: | |
| 1533 case ROUND_MOD_EXPR: | |
| 1534 case RDIV_EXPR: | |
| 1535 case EXACT_DIV_EXPR: | |
| 1536 case LSHIFT_EXPR: | |
| 1537 case RSHIFT_EXPR: | |
| 1538 case LROTATE_EXPR: | |
| 1539 case RROTATE_EXPR: | |
| 1540 case VEC_LSHIFT_EXPR: | |
| 1541 case VEC_RSHIFT_EXPR: | |
| 1542 case BIT_IOR_EXPR: | |
| 1543 case BIT_XOR_EXPR: | |
| 1544 case BIT_AND_EXPR: | |
| 1545 case TRUTH_ANDIF_EXPR: | |
| 1546 case TRUTH_ORIF_EXPR: | |
| 1547 case TRUTH_AND_EXPR: | |
| 1548 case TRUTH_OR_EXPR: | |
| 1549 case TRUTH_XOR_EXPR: | |
| 1550 case LT_EXPR: | |
| 1551 case LE_EXPR: | |
| 1552 case GT_EXPR: | |
| 1553 case GE_EXPR: | |
| 1554 case EQ_EXPR: | |
| 1555 case NE_EXPR: | |
| 1556 case UNLT_EXPR: | |
| 1557 case UNLE_EXPR: | |
| 1558 case UNGT_EXPR: | |
| 1559 case UNGE_EXPR: | |
| 1560 case UNEQ_EXPR: | |
| 1561 case LTGT_EXPR: | |
| 1562 case ORDERED_EXPR: | |
| 1563 case UNORDERED_EXPR: | |
| 1564 { | |
| 1565 const char *op = op_symbol (node); | |
| 1566 op0 = TREE_OPERAND (node, 0); | |
| 1567 op1 = TREE_OPERAND (node, 1); | |
| 1568 | |
| 1569 /* When the operands are expressions with less priority, | |
| 1570 keep semantics of the tree representation. */ | |
| 1571 if (op_prio (op0) <= op_prio (node)) | |
| 1572 { | |
| 1573 pp_character (buffer, '('); | |
| 1574 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1575 pp_character (buffer, ')'); | |
| 1576 } | |
| 1577 else | |
| 1578 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1579 | |
| 1580 pp_space (buffer); | |
| 1581 pp_string (buffer, op); | |
| 1582 pp_space (buffer); | |
| 1583 | |
| 1584 /* When the operands are expressions with less priority, | |
| 1585 keep semantics of the tree representation. */ | |
| 1586 if (op_prio (op1) <= op_prio (node)) | |
| 1587 { | |
| 1588 pp_character (buffer, '('); | |
| 1589 dump_generic_node (buffer, op1, spc, flags, false); | |
| 1590 pp_character (buffer, ')'); | |
| 1591 } | |
| 1592 else | |
| 1593 dump_generic_node (buffer, op1, spc, flags, false); | |
| 1594 } | |
| 1595 break; | |
| 1596 | |
| 1597 /* Unary arithmetic and logic expressions. */ | |
| 1598 case NEGATE_EXPR: | |
| 1599 case BIT_NOT_EXPR: | |
| 1600 case TRUTH_NOT_EXPR: | |
| 1601 case ADDR_EXPR: | |
| 1602 case PREDECREMENT_EXPR: | |
| 1603 case PREINCREMENT_EXPR: | |
| 1604 case INDIRECT_REF: | |
| 1605 if (TREE_CODE (node) == ADDR_EXPR | |
| 1606 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST | |
| 1607 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL)) | |
| 1608 ; /* Do not output '&' for strings and function pointers. */ | |
| 1609 else | |
| 1610 pp_string (buffer, op_symbol (node)); | |
| 1611 | |
| 1612 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) | |
| 1613 { | |
| 1614 pp_character (buffer, '('); | |
| 1615 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1616 pp_character (buffer, ')'); | |
| 1617 } | |
| 1618 else | |
| 1619 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1620 break; | |
| 1621 | |
| 1622 case POSTDECREMENT_EXPR: | |
| 1623 case POSTINCREMENT_EXPR: | |
| 1624 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) | |
| 1625 { | |
| 1626 pp_character (buffer, '('); | |
| 1627 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1628 pp_character (buffer, ')'); | |
| 1629 } | |
| 1630 else | |
| 1631 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1632 pp_string (buffer, op_symbol (node)); | |
| 1633 break; | |
| 1634 | |
| 1635 case MIN_EXPR: | |
| 1636 pp_string (buffer, "MIN_EXPR <"); | |
| 1637 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1638 pp_string (buffer, ", "); | |
| 1639 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1640 pp_character (buffer, '>'); | |
| 1641 break; | |
| 1642 | |
| 1643 case MAX_EXPR: | |
| 1644 pp_string (buffer, "MAX_EXPR <"); | |
| 1645 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1646 pp_string (buffer, ", "); | |
| 1647 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1648 pp_character (buffer, '>'); | |
| 1649 break; | |
| 1650 | |
| 1651 case ABS_EXPR: | |
| 1652 pp_string (buffer, "ABS_EXPR <"); | |
| 1653 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1654 pp_character (buffer, '>'); | |
| 1655 break; | |
| 1656 | |
| 1657 case RANGE_EXPR: | |
| 1658 NIY; | |
| 1659 break; | |
| 1660 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1661 case ADDR_SPACE_CONVERT_EXPR: |
| 0 | 1662 case FIXED_CONVERT_EXPR: |
| 1663 case FIX_TRUNC_EXPR: | |
| 1664 case FLOAT_EXPR: | |
| 1665 CASE_CONVERT: | |
| 1666 type = TREE_TYPE (node); | |
| 1667 op0 = TREE_OPERAND (node, 0); | |
| 1668 if (type != TREE_TYPE (op0)) | |
| 1669 { | |
| 1670 pp_character (buffer, '('); | |
| 1671 dump_generic_node (buffer, type, spc, flags, false); | |
| 1672 pp_string (buffer, ") "); | |
| 1673 } | |
| 1674 if (op_prio (op0) < op_prio (node)) | |
| 1675 pp_character (buffer, '('); | |
| 1676 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1677 if (op_prio (op0) < op_prio (node)) | |
| 1678 pp_character (buffer, ')'); | |
| 1679 break; | |
| 1680 | |
| 1681 case VIEW_CONVERT_EXPR: | |
| 1682 pp_string (buffer, "VIEW_CONVERT_EXPR<"); | |
| 1683 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); | |
| 1684 pp_string (buffer, ">("); | |
| 1685 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1686 pp_character (buffer, ')'); | |
| 1687 break; | |
| 1688 | |
| 1689 case PAREN_EXPR: | |
| 1690 pp_string (buffer, "(("); | |
| 1691 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1692 pp_string (buffer, "))"); | |
| 1693 break; | |
| 1694 | |
| 1695 case NON_LVALUE_EXPR: | |
| 1696 pp_string (buffer, "NON_LVALUE_EXPR <"); | |
| 1697 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1698 pp_character (buffer, '>'); | |
| 1699 break; | |
| 1700 | |
| 1701 case SAVE_EXPR: | |
| 1702 pp_string (buffer, "SAVE_EXPR <"); | |
| 1703 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1704 pp_character (buffer, '>'); | |
| 1705 break; | |
| 1706 | |
| 1707 case COMPLEX_EXPR: | |
| 1708 pp_string (buffer, "COMPLEX_EXPR <"); | |
| 1709 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1710 pp_string (buffer, ", "); | |
| 1711 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1712 pp_string (buffer, ">"); | |
| 1713 break; | |
| 1714 | |
| 1715 case CONJ_EXPR: | |
| 1716 pp_string (buffer, "CONJ_EXPR <"); | |
| 1717 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1718 pp_string (buffer, ">"); | |
| 1719 break; | |
| 1720 | |
| 1721 case REALPART_EXPR: | |
| 1722 pp_string (buffer, "REALPART_EXPR <"); | |
| 1723 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1724 pp_string (buffer, ">"); | |
| 1725 break; | |
| 1726 | |
| 1727 case IMAGPART_EXPR: | |
| 1728 pp_string (buffer, "IMAGPART_EXPR <"); | |
| 1729 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1730 pp_string (buffer, ">"); | |
| 1731 break; | |
| 1732 | |
| 1733 case VA_ARG_EXPR: | |
| 1734 pp_string (buffer, "VA_ARG_EXPR <"); | |
| 1735 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1736 pp_string (buffer, ">"); | |
| 1737 break; | |
| 1738 | |
| 1739 case TRY_FINALLY_EXPR: | |
| 1740 case TRY_CATCH_EXPR: | |
| 1741 pp_string (buffer, "try"); | |
| 1742 newline_and_indent (buffer, spc+2); | |
| 1743 pp_string (buffer, "{"); | |
| 1744 newline_and_indent (buffer, spc+4); | |
| 1745 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true); | |
| 1746 newline_and_indent (buffer, spc+2); | |
| 1747 pp_string (buffer, "}"); | |
| 1748 newline_and_indent (buffer, spc); | |
| 1749 pp_string (buffer, | |
| 1750 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally"); | |
| 1751 newline_and_indent (buffer, spc+2); | |
| 1752 pp_string (buffer, "{"); | |
| 1753 newline_and_indent (buffer, spc+4); | |
| 1754 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true); | |
| 1755 newline_and_indent (buffer, spc+2); | |
| 1756 pp_string (buffer, "}"); | |
| 1757 is_expr = false; | |
| 1758 break; | |
| 1759 | |
| 1760 case CATCH_EXPR: | |
| 1761 pp_string (buffer, "catch ("); | |
| 1762 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false); | |
| 1763 pp_string (buffer, ")"); | |
| 1764 newline_and_indent (buffer, spc+2); | |
| 1765 pp_string (buffer, "{"); | |
| 1766 newline_and_indent (buffer, spc+4); | |
| 1767 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true); | |
| 1768 newline_and_indent (buffer, spc+2); | |
| 1769 pp_string (buffer, "}"); | |
| 1770 is_expr = false; | |
| 1771 break; | |
| 1772 | |
| 1773 case EH_FILTER_EXPR: | |
| 1774 pp_string (buffer, "<<<eh_filter ("); | |
| 1775 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false); | |
| 1776 pp_string (buffer, ")>>>"); | |
| 1777 newline_and_indent (buffer, spc+2); | |
| 1778 pp_string (buffer, "{"); | |
| 1779 newline_and_indent (buffer, spc+4); | |
| 1780 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true); | |
| 1781 newline_and_indent (buffer, spc+2); | |
| 1782 pp_string (buffer, "}"); | |
| 1783 is_expr = false; | |
| 1784 break; | |
| 1785 | |
| 1786 case LABEL_EXPR: | |
| 1787 op0 = TREE_OPERAND (node, 0); | |
| 1788 /* If this is for break or continue, don't bother printing it. */ | |
| 1789 if (DECL_NAME (op0)) | |
| 1790 { | |
| 1791 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); | |
| 1792 if (strcmp (name, "break") == 0 | |
| 1793 || strcmp (name, "continue") == 0) | |
| 1794 break; | |
| 1795 } | |
| 1796 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1797 pp_character (buffer, ':'); | |
| 1798 if (DECL_NONLOCAL (op0)) | |
| 1799 pp_string (buffer, " [non-local]"); | |
| 1800 break; | |
| 1801 | |
| 1802 case LOOP_EXPR: | |
| 1803 pp_string (buffer, "while (1)"); | |
| 1804 if (!(flags & TDF_SLIM)) | |
| 1805 { | |
| 1806 newline_and_indent (buffer, spc+2); | |
| 1807 pp_character (buffer, '{'); | |
| 1808 newline_and_indent (buffer, spc+4); | |
| 1809 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true); | |
| 1810 newline_and_indent (buffer, spc+2); | |
| 1811 pp_character (buffer, '}'); | |
| 1812 } | |
| 1813 is_expr = false; | |
| 1814 break; | |
| 1815 | |
| 1816 case PREDICT_EXPR: | |
| 1817 pp_string (buffer, "// predicted "); | |
| 1818 if (PREDICT_EXPR_OUTCOME (node)) | |
| 1819 pp_string (buffer, "likely by "); | |
| 1820 else | |
| 1821 pp_string (buffer, "unlikely by "); | |
| 1822 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node))); | |
| 1823 pp_string (buffer, " predictor."); | |
| 1824 break; | |
| 1825 | |
| 1826 case RETURN_EXPR: | |
| 1827 pp_string (buffer, "return"); | |
| 1828 op0 = TREE_OPERAND (node, 0); | |
| 1829 if (op0) | |
| 1830 { | |
| 1831 pp_space (buffer); | |
| 1832 if (TREE_CODE (op0) == MODIFY_EXPR) | |
| 1833 dump_generic_node (buffer, TREE_OPERAND (op0, 1), | |
| 1834 spc, flags, false); | |
| 1835 else | |
| 1836 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1837 } | |
| 1838 break; | |
| 1839 | |
| 1840 case EXIT_EXPR: | |
| 1841 pp_string (buffer, "if ("); | |
| 1842 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1843 pp_string (buffer, ") break"); | |
| 1844 break; | |
| 1845 | |
| 1846 case SWITCH_EXPR: | |
| 1847 pp_string (buffer, "switch ("); | |
| 1848 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false); | |
| 1849 pp_character (buffer, ')'); | |
| 1850 if (!(flags & TDF_SLIM)) | |
| 1851 { | |
| 1852 newline_and_indent (buffer, spc+2); | |
| 1853 pp_character (buffer, '{'); | |
| 1854 if (SWITCH_BODY (node)) | |
| 1855 { | |
| 1856 newline_and_indent (buffer, spc+4); | |
| 1857 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, | |
| 1858 true); | |
| 1859 } | |
| 1860 else | |
| 1861 { | |
| 1862 tree vec = SWITCH_LABELS (node); | |
| 1863 size_t i, n = TREE_VEC_LENGTH (vec); | |
| 1864 for (i = 0; i < n; ++i) | |
| 1865 { | |
| 1866 tree elt = TREE_VEC_ELT (vec, i); | |
| 1867 newline_and_indent (buffer, spc+4); | |
| 1868 if (elt) | |
| 1869 { | |
| 1870 dump_generic_node (buffer, elt, spc+4, flags, false); | |
| 1871 pp_string (buffer, " goto "); | |
| 1872 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, | |
| 1873 flags, true); | |
| 1874 pp_semicolon (buffer); | |
| 1875 } | |
| 1876 else | |
| 1877 pp_string (buffer, "case ???: goto ???;"); | |
| 1878 } | |
| 1879 } | |
| 1880 newline_and_indent (buffer, spc+2); | |
| 1881 pp_character (buffer, '}'); | |
| 1882 } | |
| 1883 is_expr = false; | |
| 1884 break; | |
| 1885 | |
| 1886 case GOTO_EXPR: | |
| 1887 op0 = GOTO_DESTINATION (node); | |
| 1888 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0)) | |
| 1889 { | |
| 1890 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); | |
| 1891 if (strcmp (name, "break") == 0 | |
| 1892 || strcmp (name, "continue") == 0) | |
| 1893 { | |
| 1894 pp_string (buffer, name); | |
| 1895 break; | |
| 1896 } | |
| 1897 } | |
| 1898 pp_string (buffer, "goto "); | |
| 1899 dump_generic_node (buffer, op0, spc, flags, false); | |
| 1900 break; | |
| 1901 | |
| 1902 case ASM_EXPR: | |
| 1903 pp_string (buffer, "__asm__"); | |
| 1904 if (ASM_VOLATILE_P (node)) | |
| 1905 pp_string (buffer, " __volatile__"); | |
| 1906 pp_character (buffer, '('); | |
| 1907 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false); | |
| 1908 pp_character (buffer, ':'); | |
| 1909 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false); | |
| 1910 pp_character (buffer, ':'); | |
| 1911 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false); | |
| 1912 if (ASM_CLOBBERS (node)) | |
| 1913 { | |
| 1914 pp_character (buffer, ':'); | |
| 1915 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false); | |
| 1916 } | |
| 1917 pp_string (buffer, ")"); | |
| 1918 break; | |
| 1919 | |
| 1920 case CASE_LABEL_EXPR: | |
| 1921 if (CASE_LOW (node) && CASE_HIGH (node)) | |
| 1922 { | |
| 1923 pp_string (buffer, "case "); | |
| 1924 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false); | |
| 1925 pp_string (buffer, " ... "); | |
| 1926 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false); | |
| 1927 } | |
| 1928 else if (CASE_LOW (node)) | |
| 1929 { | |
| 1930 pp_string (buffer, "case "); | |
| 1931 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false); | |
| 1932 } | |
| 1933 else | |
| 1934 pp_string (buffer, "default"); | |
| 1935 pp_character (buffer, ':'); | |
| 1936 break; | |
| 1937 | |
| 1938 case OBJ_TYPE_REF: | |
| 1939 pp_string (buffer, "OBJ_TYPE_REF("); | |
| 1940 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false); | |
| 1941 pp_character (buffer, ';'); | |
| 1942 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false); | |
| 1943 pp_character (buffer, '-'); | |
| 1944 pp_character (buffer, '>'); | |
| 1945 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false); | |
| 1946 pp_character (buffer, ')'); | |
| 1947 break; | |
| 1948 | |
| 1949 case SSA_NAME: | |
| 1950 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false); | |
| 1951 pp_string (buffer, "_"); | |
| 1952 pp_decimal_int (buffer, SSA_NAME_VERSION (node)); | |
| 1953 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) | |
| 1954 pp_string (buffer, "(ab)"); | |
| 1955 else if (SSA_NAME_IS_DEFAULT_DEF (node)) | |
| 1956 pp_string (buffer, "(D)"); | |
| 1957 break; | |
| 1958 | |
| 1959 case WITH_SIZE_EXPR: | |
| 1960 pp_string (buffer, "WITH_SIZE_EXPR <"); | |
| 1961 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1962 pp_string (buffer, ", "); | |
| 1963 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1964 pp_string (buffer, ">"); | |
| 1965 break; | |
| 1966 | |
| 1967 case ASSERT_EXPR: | |
| 1968 pp_string (buffer, "ASSERT_EXPR <"); | |
| 1969 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false); | |
| 1970 pp_string (buffer, ", "); | |
| 1971 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false); | |
| 1972 pp_string (buffer, ">"); | |
| 1973 break; | |
| 1974 | |
| 1975 case SCEV_KNOWN: | |
| 1976 pp_string (buffer, "scev_known"); | |
| 1977 break; | |
| 1978 | |
| 1979 case SCEV_NOT_KNOWN: | |
| 1980 pp_string (buffer, "scev_not_known"); | |
| 1981 break; | |
| 1982 | |
| 1983 case POLYNOMIAL_CHREC: | |
| 1984 pp_string (buffer, "{"); | |
| 1985 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false); | |
| 1986 pp_string (buffer, ", +, "); | |
| 1987 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false); | |
| 1988 pp_string (buffer, "}_"); | |
| 1989 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false); | |
| 1990 is_stmt = false; | |
| 1991 break; | |
| 1992 | |
| 1993 case REALIGN_LOAD_EXPR: | |
| 1994 pp_string (buffer, "REALIGN_LOAD <"); | |
| 1995 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 1996 pp_string (buffer, ", "); | |
| 1997 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 1998 pp_string (buffer, ", "); | |
| 1999 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); | |
| 2000 pp_string (buffer, ">"); | |
| 2001 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2002 |
| 0 | 2003 case VEC_COND_EXPR: |
| 2004 pp_string (buffer, " VEC_COND_EXPR < "); | |
| 2005 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2006 pp_string (buffer, " , "); | |
| 2007 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2008 pp_string (buffer, " , "); | |
| 2009 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); | |
| 2010 pp_string (buffer, " > "); | |
| 2011 break; | |
| 2012 | |
| 2013 case DOT_PROD_EXPR: | |
| 2014 pp_string (buffer, " DOT_PROD_EXPR < "); | |
| 2015 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2016 pp_string (buffer, ", "); | |
| 2017 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2018 pp_string (buffer, ", "); | |
| 2019 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); | |
| 2020 pp_string (buffer, " > "); | |
| 2021 break; | |
| 2022 | |
|
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
|
2023 case WIDEN_MULT_PLUS_EXPR: |
|
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
|
2024 pp_string (buffer, " WIDEN_MULT_PLUS_EXPR < "); |
|
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
|
2025 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); |
|
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
|
2026 pp_string (buffer, ", "); |
|
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
|
2027 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); |
|
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
|
2028 pp_string (buffer, ", "); |
|
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
|
2029 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); |
|
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
|
2030 pp_string (buffer, " > "); |
|
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
|
2031 break; |
|
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
|
2032 |
|
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
|
2033 case WIDEN_MULT_MINUS_EXPR: |
|
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
|
2034 pp_string (buffer, " WIDEN_MULT_MINUS_EXPR < "); |
|
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
|
2035 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); |
|
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
|
2036 pp_string (buffer, ", "); |
|
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
|
2037 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); |
|
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
|
2038 pp_string (buffer, ", "); |
|
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
|
2039 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); |
|
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
|
2040 pp_string (buffer, " > "); |
|
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
|
2041 break; |
|
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
|
2042 |
|
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
|
2043 case FMA_EXPR: |
|
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
|
2044 pp_string (buffer, " FMA_EXPR < "); |
|
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
|
2045 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); |
|
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
|
2046 pp_string (buffer, ", "); |
|
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
|
2047 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); |
|
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
|
2048 pp_string (buffer, ", "); |
|
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
|
2049 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); |
|
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
|
2050 pp_string (buffer, " > "); |
|
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
|
2051 break; |
|
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
|
2052 |
| 0 | 2053 case OMP_PARALLEL: |
| 2054 pp_string (buffer, "#pragma omp parallel"); | |
| 2055 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); | |
| 2056 | |
| 2057 dump_omp_body: | |
| 2058 if (!(flags & TDF_SLIM) && OMP_BODY (node)) | |
| 2059 { | |
| 2060 newline_and_indent (buffer, spc + 2); | |
| 2061 pp_character (buffer, '{'); | |
| 2062 newline_and_indent (buffer, spc + 4); | |
| 2063 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false); | |
| 2064 newline_and_indent (buffer, spc + 2); | |
| 2065 pp_character (buffer, '}'); | |
| 2066 } | |
| 2067 is_expr = false; | |
| 2068 break; | |
| 2069 | |
| 2070 case OMP_TASK: | |
| 2071 pp_string (buffer, "#pragma omp task"); | |
| 2072 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags); | |
| 2073 goto dump_omp_body; | |
| 2074 | |
| 2075 case OMP_FOR: | |
| 2076 pp_string (buffer, "#pragma omp for"); | |
| 2077 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags); | |
| 2078 | |
| 2079 if (!(flags & TDF_SLIM)) | |
| 2080 { | |
| 2081 int i; | |
| 2082 | |
| 2083 if (OMP_FOR_PRE_BODY (node)) | |
| 2084 { | |
| 2085 newline_and_indent (buffer, spc + 2); | |
| 2086 pp_character (buffer, '{'); | |
| 2087 spc += 4; | |
| 2088 newline_and_indent (buffer, spc); | |
| 2089 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node), | |
| 2090 spc, flags, false); | |
| 2091 } | |
| 2092 spc -= 2; | |
| 2093 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++) | |
| 2094 { | |
| 2095 spc += 2; | |
| 2096 newline_and_indent (buffer, spc); | |
| 2097 pp_string (buffer, "for ("); | |
| 2098 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i), | |
| 2099 spc, flags, false); | |
| 2100 pp_string (buffer, "; "); | |
| 2101 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i), | |
| 2102 spc, flags, false); | |
| 2103 pp_string (buffer, "; "); | |
| 2104 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i), | |
| 2105 spc, flags, false); | |
| 2106 pp_string (buffer, ")"); | |
| 2107 } | |
| 2108 if (OMP_FOR_BODY (node)) | |
| 2109 { | |
| 2110 newline_and_indent (buffer, spc + 2); | |
| 2111 pp_character (buffer, '{'); | |
| 2112 newline_and_indent (buffer, spc + 4); | |
| 2113 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags, | |
| 2114 false); | |
| 2115 newline_and_indent (buffer, spc + 2); | |
| 2116 pp_character (buffer, '}'); | |
| 2117 } | |
| 2118 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2; | |
| 2119 if (OMP_FOR_PRE_BODY (node)) | |
| 2120 { | |
| 2121 spc -= 4; | |
| 2122 newline_and_indent (buffer, spc + 2); | |
| 2123 pp_character (buffer, '}'); | |
| 2124 } | |
| 2125 } | |
| 2126 is_expr = false; | |
| 2127 break; | |
| 2128 | |
| 2129 case OMP_SECTIONS: | |
| 2130 pp_string (buffer, "#pragma omp sections"); | |
| 2131 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags); | |
| 2132 goto dump_omp_body; | |
| 2133 | |
| 2134 case OMP_SECTION: | |
| 2135 pp_string (buffer, "#pragma omp section"); | |
| 2136 goto dump_omp_body; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2137 |
| 0 | 2138 case OMP_MASTER: |
| 2139 pp_string (buffer, "#pragma omp master"); | |
| 2140 goto dump_omp_body; | |
| 2141 | |
| 2142 case OMP_ORDERED: | |
| 2143 pp_string (buffer, "#pragma omp ordered"); | |
| 2144 goto dump_omp_body; | |
| 2145 | |
| 2146 case OMP_CRITICAL: | |
| 2147 pp_string (buffer, "#pragma omp critical"); | |
| 2148 if (OMP_CRITICAL_NAME (node)) | |
| 2149 { | |
| 2150 pp_space (buffer); | |
| 2151 pp_character (buffer, '('); | |
| 2152 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc, | |
| 2153 flags, false); | |
| 2154 pp_character (buffer, ')'); | |
| 2155 } | |
| 2156 goto dump_omp_body; | |
| 2157 | |
| 2158 case OMP_ATOMIC: | |
| 2159 pp_string (buffer, "#pragma omp atomic"); | |
| 2160 newline_and_indent (buffer, spc + 2); | |
| 2161 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2162 pp_space (buffer); | |
| 2163 pp_character (buffer, '='); | |
| 2164 pp_space (buffer); | |
| 2165 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2166 break; | |
| 2167 | |
| 2168 case OMP_SINGLE: | |
| 2169 pp_string (buffer, "#pragma omp single"); | |
| 2170 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags); | |
| 2171 goto dump_omp_body; | |
| 2172 | |
| 2173 case OMP_CLAUSE: | |
| 2174 dump_omp_clause (buffer, node, spc, flags); | |
| 2175 is_expr = false; | |
| 2176 break; | |
| 2177 | |
| 2178 case REDUC_MAX_EXPR: | |
| 2179 pp_string (buffer, " REDUC_MAX_EXPR < "); | |
| 2180 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2181 pp_string (buffer, " > "); | |
| 2182 break; | |
| 2183 | |
| 2184 case REDUC_MIN_EXPR: | |
| 2185 pp_string (buffer, " REDUC_MIN_EXPR < "); | |
| 2186 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2187 pp_string (buffer, " > "); | |
| 2188 break; | |
| 2189 | |
| 2190 case REDUC_PLUS_EXPR: | |
| 2191 pp_string (buffer, " REDUC_PLUS_EXPR < "); | |
| 2192 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2193 pp_string (buffer, " > "); | |
| 2194 break; | |
| 2195 | |
| 2196 case VEC_WIDEN_MULT_HI_EXPR: | |
| 2197 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < "); | |
| 2198 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2199 pp_string (buffer, ", "); | |
| 2200 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2201 pp_string (buffer, " > "); | |
| 2202 break; | |
| 2203 | |
| 2204 case VEC_WIDEN_MULT_LO_EXPR: | |
| 2205 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < "); | |
| 2206 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2207 pp_string (buffer, ", "); | |
| 2208 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2209 pp_string (buffer, " > "); | |
| 2210 break; | |
| 2211 | |
| 2212 case VEC_UNPACK_HI_EXPR: | |
| 2213 pp_string (buffer, " VEC_UNPACK_HI_EXPR < "); | |
| 2214 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2215 pp_string (buffer, " > "); | |
| 2216 break; | |
| 2217 | |
| 2218 case VEC_UNPACK_LO_EXPR: | |
| 2219 pp_string (buffer, " VEC_UNPACK_LO_EXPR < "); | |
| 2220 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2221 pp_string (buffer, " > "); | |
| 2222 break; | |
| 2223 | |
| 2224 case VEC_UNPACK_FLOAT_HI_EXPR: | |
| 2225 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < "); | |
| 2226 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2227 pp_string (buffer, " > "); | |
| 2228 break; | |
| 2229 | |
| 2230 case VEC_UNPACK_FLOAT_LO_EXPR: | |
| 2231 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < "); | |
| 2232 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2233 pp_string (buffer, " > "); | |
| 2234 break; | |
| 2235 | |
| 2236 case VEC_PACK_TRUNC_EXPR: | |
| 2237 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < "); | |
| 2238 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2239 pp_string (buffer, ", "); | |
| 2240 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2241 pp_string (buffer, " > "); | |
| 2242 break; | |
| 2243 | |
| 2244 case VEC_PACK_SAT_EXPR: | |
| 2245 pp_string (buffer, " VEC_PACK_SAT_EXPR < "); | |
| 2246 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2247 pp_string (buffer, ", "); | |
| 2248 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2249 pp_string (buffer, " > "); | |
| 2250 break; | |
| 2251 | |
| 2252 case VEC_PACK_FIX_TRUNC_EXPR: | |
| 2253 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < "); | |
| 2254 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2255 pp_string (buffer, ", "); | |
| 2256 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2257 pp_string (buffer, " > "); | |
| 2258 break; | |
| 2259 | |
| 2260 case BLOCK: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2261 dump_block_node (buffer, node, spc, flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2262 break; |
| 0 | 2263 |
| 2264 case VEC_EXTRACT_EVEN_EXPR: | |
| 2265 pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < "); | |
| 2266 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2267 pp_string (buffer, ", "); | |
| 2268 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2269 pp_string (buffer, " > "); | |
| 2270 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2271 |
| 0 | 2272 case VEC_EXTRACT_ODD_EXPR: |
| 2273 pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < "); | |
| 2274 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2275 pp_string (buffer, ", "); | |
| 2276 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2277 pp_string (buffer, " > "); | |
| 2278 break; | |
| 2279 | |
| 2280 case VEC_INTERLEAVE_HIGH_EXPR: | |
| 2281 pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < "); | |
| 2282 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2283 pp_string (buffer, ", "); | |
| 2284 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2285 pp_string (buffer, " > "); | |
| 2286 break; | |
| 2287 | |
| 2288 case VEC_INTERLEAVE_LOW_EXPR: | |
| 2289 pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < "); | |
| 2290 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); | |
| 2291 pp_string (buffer, ", "); | |
| 2292 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); | |
| 2293 pp_string (buffer, " > "); | |
| 2294 break; | |
| 2295 | |
| 2296 default: | |
| 2297 NIY; | |
| 2298 } | |
| 2299 | |
| 2300 if (is_stmt && is_expr) | |
| 2301 pp_semicolon (buffer); | |
| 2302 | |
| 2303 /* If we're building a diagnostic, the formatted text will be written | |
| 2304 into BUFFER's stream by the caller; otherwise, write it now. */ | |
| 2305 if (!(flags & TDF_DIAGNOSTIC)) | |
| 2306 pp_write_text_to_stream (buffer); | |
| 2307 | |
| 2308 return spc; | |
| 2309 } | |
| 2310 | |
| 2311 /* Print the declaration of a variable. */ | |
| 2312 | |
| 2313 void | |
| 2314 print_declaration (pretty_printer *buffer, tree t, int spc, int flags) | |
| 2315 { | |
| 2316 INDENT (spc); | |
| 2317 | |
| 2318 if (TREE_CODE (t) == TYPE_DECL) | |
| 2319 pp_string (buffer, "typedef "); | |
| 2320 | |
| 2321 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t)) | |
| 2322 pp_string (buffer, "register "); | |
| 2323 | |
| 2324 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t)) | |
| 2325 pp_string (buffer, "extern "); | |
| 2326 else if (TREE_STATIC (t)) | |
| 2327 pp_string (buffer, "static "); | |
| 2328 | |
| 2329 /* Print the type and name. */ | |
|
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
|
2330 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) |
| 0 | 2331 { |
| 2332 tree tmp; | |
| 2333 | |
| 2334 /* Print array's type. */ | |
| 2335 tmp = TREE_TYPE (t); | |
| 2336 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE) | |
| 2337 tmp = TREE_TYPE (tmp); | |
| 2338 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false); | |
| 2339 | |
| 2340 /* Print variable's name. */ | |
| 2341 pp_space (buffer); | |
| 2342 dump_generic_node (buffer, t, spc, flags, false); | |
| 2343 | |
| 2344 /* Print the dimensions. */ | |
| 2345 tmp = TREE_TYPE (t); | |
| 2346 while (TREE_CODE (tmp) == ARRAY_TYPE) | |
| 2347 { | |
| 2348 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags); | |
| 2349 tmp = TREE_TYPE (tmp); | |
| 2350 } | |
| 2351 } | |
| 2352 else if (TREE_CODE (t) == FUNCTION_DECL) | |
| 2353 { | |
| 2354 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false); | |
| 2355 pp_space (buffer); | |
| 2356 dump_decl_name (buffer, t, flags); | |
| 2357 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags); | |
| 2358 } | |
| 2359 else | |
| 2360 { | |
| 2361 /* Print type declaration. */ | |
| 2362 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false); | |
| 2363 | |
| 2364 /* Print variable's name. */ | |
| 2365 pp_space (buffer); | |
| 2366 dump_generic_node (buffer, t, spc, flags, false); | |
| 2367 } | |
| 2368 | |
| 2369 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) | |
| 2370 { | |
| 2371 pp_string (buffer, " __asm__ "); | |
| 2372 pp_character (buffer, '('); | |
| 2373 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false); | |
| 2374 pp_character (buffer, ')'); | |
| 2375 } | |
| 2376 | |
| 2377 /* The initial value of a function serves to determine whether the function | |
| 2378 is declared or defined. So the following does not apply to function | |
| 2379 nodes. */ | |
| 2380 if (TREE_CODE (t) != FUNCTION_DECL) | |
| 2381 { | |
| 2382 /* Print the initial value. */ | |
| 2383 if (DECL_INITIAL (t)) | |
| 2384 { | |
| 2385 pp_space (buffer); | |
| 2386 pp_character (buffer, '='); | |
| 2387 pp_space (buffer); | |
| 2388 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false); | |
| 2389 } | |
| 2390 } | |
| 2391 | |
| 2392 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) | |
| 2393 { | |
| 2394 pp_string (buffer, " [value-expr: "); | |
| 2395 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false); | |
| 2396 pp_character (buffer, ']'); | |
| 2397 } | |
| 2398 | |
| 2399 pp_character (buffer, ';'); | |
| 2400 } | |
| 2401 | |
| 2402 | |
| 2403 /* Prints a structure: name, fields, and methods. | |
| 2404 FIXME: Still incomplete. */ | |
| 2405 | |
| 2406 static void | |
| 2407 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags) | |
| 2408 { | |
| 2409 /* Print the name of the structure. */ | |
| 2410 if (TYPE_NAME (node)) | |
| 2411 { | |
| 2412 INDENT (spc); | |
| 2413 if (TREE_CODE (node) == RECORD_TYPE) | |
| 2414 pp_string (buffer, "struct "); | |
| 2415 else if ((TREE_CODE (node) == UNION_TYPE | |
| 2416 || TREE_CODE (node) == QUAL_UNION_TYPE)) | |
| 2417 pp_string (buffer, "union "); | |
| 2418 | |
| 2419 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false); | |
| 2420 } | |
| 2421 | |
| 2422 /* Print the contents of the structure. */ | |
| 2423 pp_newline (buffer); | |
| 2424 INDENT (spc); | |
| 2425 pp_character (buffer, '{'); | |
| 2426 pp_newline (buffer); | |
| 2427 | |
| 2428 /* Print the fields of the structure. */ | |
| 2429 { | |
| 2430 tree tmp; | |
| 2431 tmp = TYPE_FIELDS (node); | |
| 2432 while (tmp) | |
| 2433 { | |
| 2434 /* Avoid to print recursively the structure. */ | |
| 2435 /* FIXME : Not implemented correctly..., | |
| 2436 what about the case when we have a cycle in the contain graph? ... | |
| 2437 Maybe this could be solved by looking at the scope in which the | |
| 2438 structure was declared. */ | |
| 2439 if (TREE_TYPE (tmp) != node | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2440 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2441 || TREE_TYPE (TREE_TYPE (tmp)) != node)) |
| 0 | 2442 { |
| 2443 print_declaration (buffer, tmp, spc+2, flags); | |
| 2444 pp_newline (buffer); | |
| 2445 } | |
|
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
|
2446 tmp = DECL_CHAIN (tmp); |
| 0 | 2447 } |
| 2448 } | |
| 2449 INDENT (spc); | |
| 2450 pp_character (buffer, '}'); | |
| 2451 } | |
| 2452 | |
| 2453 /* Return the priority of the operator CODE. | |
| 2454 | |
| 2455 From lowest to highest precedence with either left-to-right (L-R) | |
| 2456 or right-to-left (R-L) associativity]: | |
| 2457 | |
| 2458 1 [L-R] , | |
| 2459 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>= | |
| 2460 3 [R-L] ?: | |
| 2461 4 [L-R] || | |
| 2462 5 [L-R] && | |
| 2463 6 [L-R] | | |
| 2464 7 [L-R] ^ | |
| 2465 8 [L-R] & | |
| 2466 9 [L-R] == != | |
| 2467 10 [L-R] < <= > >= | |
| 2468 11 [L-R] << >> | |
| 2469 12 [L-R] + - | |
| 2470 13 [L-R] * / % | |
| 2471 14 [R-L] ! ~ ++ -- + - * & (type) sizeof | |
| 2472 15 [L-R] fn() [] -> . | |
| 2473 | |
| 2474 unary +, - and * have higher precedence than the corresponding binary | |
| 2475 operators. */ | |
| 2476 | |
| 2477 int | |
| 2478 op_code_prio (enum tree_code code) | |
| 2479 { | |
| 2480 switch (code) | |
| 2481 { | |
| 2482 case TREE_LIST: | |
| 2483 case COMPOUND_EXPR: | |
| 2484 case BIND_EXPR: | |
| 2485 return 1; | |
| 2486 | |
| 2487 case MODIFY_EXPR: | |
| 2488 case INIT_EXPR: | |
| 2489 return 2; | |
| 2490 | |
| 2491 case COND_EXPR: | |
| 2492 return 3; | |
| 2493 | |
| 2494 case TRUTH_OR_EXPR: | |
| 2495 case TRUTH_ORIF_EXPR: | |
| 2496 return 4; | |
| 2497 | |
| 2498 case TRUTH_AND_EXPR: | |
| 2499 case TRUTH_ANDIF_EXPR: | |
| 2500 return 5; | |
| 2501 | |
| 2502 case BIT_IOR_EXPR: | |
| 2503 return 6; | |
| 2504 | |
| 2505 case BIT_XOR_EXPR: | |
| 2506 case TRUTH_XOR_EXPR: | |
| 2507 return 7; | |
| 2508 | |
| 2509 case BIT_AND_EXPR: | |
| 2510 return 8; | |
| 2511 | |
| 2512 case EQ_EXPR: | |
| 2513 case NE_EXPR: | |
| 2514 return 9; | |
| 2515 | |
| 2516 case UNLT_EXPR: | |
| 2517 case UNLE_EXPR: | |
| 2518 case UNGT_EXPR: | |
| 2519 case UNGE_EXPR: | |
| 2520 case UNEQ_EXPR: | |
| 2521 case LTGT_EXPR: | |
| 2522 case ORDERED_EXPR: | |
| 2523 case UNORDERED_EXPR: | |
| 2524 case LT_EXPR: | |
| 2525 case LE_EXPR: | |
| 2526 case GT_EXPR: | |
| 2527 case GE_EXPR: | |
| 2528 return 10; | |
| 2529 | |
| 2530 case LSHIFT_EXPR: | |
| 2531 case RSHIFT_EXPR: | |
| 2532 case LROTATE_EXPR: | |
| 2533 case RROTATE_EXPR: | |
| 2534 return 11; | |
| 2535 | |
| 2536 case WIDEN_SUM_EXPR: | |
| 2537 case PLUS_EXPR: | |
| 2538 case POINTER_PLUS_EXPR: | |
| 2539 case MINUS_EXPR: | |
| 2540 return 12; | |
| 2541 | |
| 2542 case VEC_WIDEN_MULT_HI_EXPR: | |
| 2543 case VEC_WIDEN_MULT_LO_EXPR: | |
| 2544 case WIDEN_MULT_EXPR: | |
| 2545 case DOT_PROD_EXPR: | |
|
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
|
2546 case WIDEN_MULT_PLUS_EXPR: |
|
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
|
2547 case WIDEN_MULT_MINUS_EXPR: |
| 0 | 2548 case MULT_EXPR: |
| 2549 case TRUNC_DIV_EXPR: | |
| 2550 case CEIL_DIV_EXPR: | |
| 2551 case FLOOR_DIV_EXPR: | |
| 2552 case ROUND_DIV_EXPR: | |
| 2553 case RDIV_EXPR: | |
| 2554 case EXACT_DIV_EXPR: | |
| 2555 case TRUNC_MOD_EXPR: | |
| 2556 case CEIL_MOD_EXPR: | |
| 2557 case FLOOR_MOD_EXPR: | |
| 2558 case ROUND_MOD_EXPR: | |
|
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
|
2559 case FMA_EXPR: |
| 0 | 2560 return 13; |
| 2561 | |
| 2562 case TRUTH_NOT_EXPR: | |
| 2563 case BIT_NOT_EXPR: | |
| 2564 case POSTINCREMENT_EXPR: | |
| 2565 case POSTDECREMENT_EXPR: | |
| 2566 case PREINCREMENT_EXPR: | |
| 2567 case PREDECREMENT_EXPR: | |
| 2568 case NEGATE_EXPR: | |
| 2569 case INDIRECT_REF: | |
| 2570 case ADDR_EXPR: | |
| 2571 case FLOAT_EXPR: | |
| 2572 CASE_CONVERT: | |
| 2573 case FIX_TRUNC_EXPR: | |
| 2574 case TARGET_EXPR: | |
| 2575 return 14; | |
| 2576 | |
| 2577 case CALL_EXPR: | |
| 2578 case ARRAY_REF: | |
| 2579 case ARRAY_RANGE_REF: | |
| 2580 case COMPONENT_REF: | |
| 2581 return 15; | |
| 2582 | |
| 2583 /* Special expressions. */ | |
| 2584 case MIN_EXPR: | |
| 2585 case MAX_EXPR: | |
| 2586 case ABS_EXPR: | |
| 2587 case REALPART_EXPR: | |
| 2588 case IMAGPART_EXPR: | |
| 2589 case REDUC_MAX_EXPR: | |
| 2590 case REDUC_MIN_EXPR: | |
| 2591 case REDUC_PLUS_EXPR: | |
| 2592 case VEC_LSHIFT_EXPR: | |
| 2593 case VEC_RSHIFT_EXPR: | |
| 2594 case VEC_UNPACK_HI_EXPR: | |
| 2595 case VEC_UNPACK_LO_EXPR: | |
| 2596 case VEC_UNPACK_FLOAT_HI_EXPR: | |
| 2597 case VEC_UNPACK_FLOAT_LO_EXPR: | |
| 2598 case VEC_PACK_TRUNC_EXPR: | |
| 2599 case VEC_PACK_SAT_EXPR: | |
| 2600 return 16; | |
| 2601 | |
| 2602 default: | |
| 2603 /* Return an arbitrarily high precedence to avoid surrounding single | |
| 2604 VAR_DECLs in ()s. */ | |
| 2605 return 9999; | |
| 2606 } | |
| 2607 } | |
| 2608 | |
| 2609 /* Return the priority of the operator OP. */ | |
| 2610 | |
| 2611 int | |
| 2612 op_prio (const_tree op) | |
| 2613 { | |
| 2614 enum tree_code code; | |
| 2615 | |
| 2616 if (op == NULL) | |
| 2617 return 9999; | |
| 2618 | |
| 2619 code = TREE_CODE (op); | |
| 2620 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR) | |
| 2621 return op_prio (TREE_OPERAND (op, 0)); | |
| 2622 | |
| 2623 return op_code_prio (code); | |
| 2624 } | |
| 2625 | |
| 2626 /* Return the symbol associated with operator CODE. */ | |
| 2627 | |
| 2628 const char * | |
| 2629 op_symbol_code (enum tree_code code) | |
| 2630 { | |
| 2631 switch (code) | |
| 2632 { | |
| 2633 case MODIFY_EXPR: | |
| 2634 return "="; | |
| 2635 | |
| 2636 case TRUTH_OR_EXPR: | |
| 2637 case TRUTH_ORIF_EXPR: | |
| 2638 return "||"; | |
| 2639 | |
| 2640 case TRUTH_AND_EXPR: | |
| 2641 case TRUTH_ANDIF_EXPR: | |
| 2642 return "&&"; | |
| 2643 | |
| 2644 case BIT_IOR_EXPR: | |
| 2645 return "|"; | |
| 2646 | |
| 2647 case TRUTH_XOR_EXPR: | |
| 2648 case BIT_XOR_EXPR: | |
| 2649 return "^"; | |
| 2650 | |
| 2651 case ADDR_EXPR: | |
| 2652 case BIT_AND_EXPR: | |
| 2653 return "&"; | |
| 2654 | |
| 2655 case ORDERED_EXPR: | |
| 2656 return "ord"; | |
| 2657 case UNORDERED_EXPR: | |
| 2658 return "unord"; | |
| 2659 | |
| 2660 case EQ_EXPR: | |
| 2661 return "=="; | |
| 2662 case UNEQ_EXPR: | |
| 2663 return "u=="; | |
| 2664 | |
| 2665 case NE_EXPR: | |
| 2666 return "!="; | |
| 2667 | |
| 2668 case LT_EXPR: | |
| 2669 return "<"; | |
| 2670 case UNLT_EXPR: | |
| 2671 return "u<"; | |
| 2672 | |
| 2673 case LE_EXPR: | |
| 2674 return "<="; | |
| 2675 case UNLE_EXPR: | |
| 2676 return "u<="; | |
| 2677 | |
| 2678 case GT_EXPR: | |
| 2679 return ">"; | |
| 2680 case UNGT_EXPR: | |
| 2681 return "u>"; | |
| 2682 | |
| 2683 case GE_EXPR: | |
| 2684 return ">="; | |
| 2685 case UNGE_EXPR: | |
| 2686 return "u>="; | |
| 2687 | |
| 2688 case LTGT_EXPR: | |
| 2689 return "<>"; | |
| 2690 | |
| 2691 case LSHIFT_EXPR: | |
| 2692 return "<<"; | |
| 2693 | |
| 2694 case RSHIFT_EXPR: | |
| 2695 return ">>"; | |
| 2696 | |
| 2697 case LROTATE_EXPR: | |
| 2698 return "r<<"; | |
| 2699 | |
| 2700 case RROTATE_EXPR: | |
| 2701 return "r>>"; | |
| 2702 | |
| 2703 case VEC_LSHIFT_EXPR: | |
| 2704 return "v<<"; | |
| 2705 | |
| 2706 case VEC_RSHIFT_EXPR: | |
| 2707 return "v>>"; | |
| 2708 | |
| 2709 case POINTER_PLUS_EXPR: | |
| 2710 return "+"; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2711 |
| 0 | 2712 case PLUS_EXPR: |
| 2713 return "+"; | |
| 2714 | |
| 2715 case REDUC_PLUS_EXPR: | |
| 2716 return "r+"; | |
| 2717 | |
| 2718 case WIDEN_SUM_EXPR: | |
| 2719 return "w+"; | |
| 2720 | |
| 2721 case WIDEN_MULT_EXPR: | |
| 2722 return "w*"; | |
| 2723 | |
| 2724 case NEGATE_EXPR: | |
| 2725 case MINUS_EXPR: | |
| 2726 return "-"; | |
| 2727 | |
| 2728 case BIT_NOT_EXPR: | |
| 2729 return "~"; | |
| 2730 | |
| 2731 case TRUTH_NOT_EXPR: | |
| 2732 return "!"; | |
| 2733 | |
| 2734 case MULT_EXPR: | |
| 2735 case INDIRECT_REF: | |
| 2736 return "*"; | |
| 2737 | |
| 2738 case TRUNC_DIV_EXPR: | |
| 2739 case RDIV_EXPR: | |
| 2740 return "/"; | |
| 2741 | |
| 2742 case CEIL_DIV_EXPR: | |
| 2743 return "/[cl]"; | |
| 2744 | |
| 2745 case FLOOR_DIV_EXPR: | |
| 2746 return "/[fl]"; | |
| 2747 | |
| 2748 case ROUND_DIV_EXPR: | |
| 2749 return "/[rd]"; | |
| 2750 | |
| 2751 case EXACT_DIV_EXPR: | |
| 2752 return "/[ex]"; | |
| 2753 | |
| 2754 case TRUNC_MOD_EXPR: | |
| 2755 return "%"; | |
| 2756 | |
| 2757 case CEIL_MOD_EXPR: | |
| 2758 return "%[cl]"; | |
| 2759 | |
| 2760 case FLOOR_MOD_EXPR: | |
| 2761 return "%[fl]"; | |
| 2762 | |
| 2763 case ROUND_MOD_EXPR: | |
| 2764 return "%[rd]"; | |
| 2765 | |
| 2766 case PREDECREMENT_EXPR: | |
| 2767 return " --"; | |
| 2768 | |
| 2769 case PREINCREMENT_EXPR: | |
| 2770 return " ++"; | |
| 2771 | |
| 2772 case POSTDECREMENT_EXPR: | |
| 2773 return "-- "; | |
| 2774 | |
| 2775 case POSTINCREMENT_EXPR: | |
| 2776 return "++ "; | |
| 2777 | |
| 2778 case MAX_EXPR: | |
| 2779 return "max"; | |
| 2780 | |
| 2781 case MIN_EXPR: | |
| 2782 return "min"; | |
| 2783 | |
| 2784 default: | |
| 2785 return "<<< ??? >>>"; | |
| 2786 } | |
| 2787 } | |
| 2788 | |
| 2789 /* Return the symbol associated with operator OP. */ | |
| 2790 | |
| 2791 static const char * | |
| 2792 op_symbol (const_tree op) | |
| 2793 { | |
| 2794 return op_symbol_code (TREE_CODE (op)); | |
| 2795 } | |
| 2796 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2797 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2798 the gimple_call_fn of a GIMPLE_CALL. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2799 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2800 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2801 print_call_name (pretty_printer *buffer, tree node, int flags) |
| 0 | 2802 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2803 tree op0 = node; |
| 0 | 2804 |
| 2805 if (TREE_CODE (op0) == NON_LVALUE_EXPR) | |
| 2806 op0 = TREE_OPERAND (op0, 0); | |
| 2807 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2808 again: |
| 0 | 2809 switch (TREE_CODE (op0)) |
| 2810 { | |
| 2811 case VAR_DECL: | |
| 2812 case PARM_DECL: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2813 case FUNCTION_DECL: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2814 dump_function_name (buffer, op0, flags); |
| 0 | 2815 break; |
| 2816 | |
| 2817 case ADDR_EXPR: | |
| 2818 case INDIRECT_REF: | |
| 2819 case NOP_EXPR: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2820 op0 = TREE_OPERAND (op0, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2821 goto again; |
| 0 | 2822 |
| 2823 case COND_EXPR: | |
| 2824 pp_string (buffer, "("); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2825 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false); |
| 0 | 2826 pp_string (buffer, ") ? "); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2827 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false); |
| 0 | 2828 pp_string (buffer, " : "); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2829 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false); |
| 0 | 2830 break; |
| 2831 | |
| 2832 case ARRAY_REF: | |
| 2833 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2834 dump_function_name (buffer, TREE_OPERAND (op0, 0), flags); |
| 0 | 2835 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2836 dump_generic_node (buffer, op0, 0, flags, false); |
| 0 | 2837 break; |
| 2838 | |
|
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
|
2839 case MEM_REF: |
|
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
|
2840 if (integer_zerop (TREE_OPERAND (op0, 1))) |
|
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
|
2841 { |
|
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
|
2842 op0 = TREE_OPERAND (op0, 0); |
|
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
|
2843 goto again; |
|
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
|
2844 } |
|
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
|
2845 /* Fallthru. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2846 case COMPONENT_REF: |
| 0 | 2847 case SSA_NAME: |
| 2848 case OBJ_TYPE_REF: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2849 dump_generic_node (buffer, op0, 0, flags, false); |
| 0 | 2850 break; |
| 2851 | |
| 2852 default: | |
| 2853 NIY; | |
| 2854 } | |
| 2855 } | |
| 2856 | |
| 2857 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */ | |
| 2858 | |
| 2859 static void | |
| 2860 pretty_print_string (pretty_printer *buffer, const char *str) | |
| 2861 { | |
| 2862 if (str == NULL) | |
| 2863 return; | |
| 2864 | |
| 2865 while (*str) | |
| 2866 { | |
| 2867 switch (str[0]) | |
| 2868 { | |
| 2869 case '\b': | |
| 2870 pp_string (buffer, "\\b"); | |
| 2871 break; | |
| 2872 | |
| 2873 case '\f': | |
| 2874 pp_string (buffer, "\\f"); | |
| 2875 break; | |
| 2876 | |
| 2877 case '\n': | |
| 2878 pp_string (buffer, "\\n"); | |
| 2879 break; | |
| 2880 | |
| 2881 case '\r': | |
| 2882 pp_string (buffer, "\\r"); | |
| 2883 break; | |
| 2884 | |
| 2885 case '\t': | |
| 2886 pp_string (buffer, "\\t"); | |
| 2887 break; | |
| 2888 | |
| 2889 case '\v': | |
| 2890 pp_string (buffer, "\\v"); | |
| 2891 break; | |
| 2892 | |
| 2893 case '\\': | |
| 2894 pp_string (buffer, "\\\\"); | |
| 2895 break; | |
| 2896 | |
| 2897 case '\"': | |
| 2898 pp_string (buffer, "\\\""); | |
| 2899 break; | |
| 2900 | |
| 2901 case '\'': | |
| 2902 pp_string (buffer, "\\'"); | |
| 2903 break; | |
| 2904 | |
| 2905 /* No need to handle \0; the loop terminates on \0. */ | |
| 2906 | |
| 2907 case '\1': | |
| 2908 pp_string (buffer, "\\1"); | |
| 2909 break; | |
| 2910 | |
| 2911 case '\2': | |
| 2912 pp_string (buffer, "\\2"); | |
| 2913 break; | |
| 2914 | |
| 2915 case '\3': | |
| 2916 pp_string (buffer, "\\3"); | |
| 2917 break; | |
| 2918 | |
| 2919 case '\4': | |
| 2920 pp_string (buffer, "\\4"); | |
| 2921 break; | |
| 2922 | |
| 2923 case '\5': | |
| 2924 pp_string (buffer, "\\5"); | |
| 2925 break; | |
| 2926 | |
| 2927 case '\6': | |
| 2928 pp_string (buffer, "\\6"); | |
| 2929 break; | |
| 2930 | |
| 2931 case '\7': | |
| 2932 pp_string (buffer, "\\7"); | |
| 2933 break; | |
| 2934 | |
| 2935 default: | |
| 2936 pp_character (buffer, str[0]); | |
| 2937 break; | |
| 2938 } | |
| 2939 str++; | |
| 2940 } | |
| 2941 } | |
| 2942 | |
| 2943 static void | |
| 2944 maybe_init_pretty_print (FILE *file) | |
| 2945 { | |
| 2946 if (!initialized) | |
| 2947 { | |
| 2948 pp_construct (&buffer, /* prefix */NULL, /* line-width */0); | |
| 2949 pp_needs_newline (&buffer) = true; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2950 pp_translate_identifiers (&buffer) = false; |
| 0 | 2951 initialized = 1; |
| 2952 } | |
| 2953 | |
| 2954 buffer.buffer->stream = file; | |
| 2955 } | |
| 2956 | |
| 2957 static void | |
| 2958 newline_and_indent (pretty_printer *buffer, int spc) | |
| 2959 { | |
| 2960 pp_newline (buffer); | |
| 2961 INDENT (spc); | |
| 2962 } | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2963 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2964 /* Handle a %K format for TEXT. Separate from default_tree_printer so |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2965 it can also be used in front ends. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2966 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2967 */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2968 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2969 void |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2970 percent_K_format (text_info *text) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2971 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2972 tree t = va_arg (*text->args_ptr, tree), block; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2973 gcc_assert (text->locus != NULL); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2974 *text->locus = EXPR_LOCATION (t); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2975 gcc_assert (pp_ti_abstract_origin (text) != NULL); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2976 block = TREE_BLOCK (t); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2977 *pp_ti_abstract_origin (text) = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2978 while (block |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2979 && TREE_CODE (block) == BLOCK |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2980 && BLOCK_ABSTRACT_ORIGIN (block)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2981 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2982 tree ao = BLOCK_ABSTRACT_ORIGIN (block); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2983 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2984 while (TREE_CODE (ao) == BLOCK |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2985 && BLOCK_ABSTRACT_ORIGIN (ao) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2986 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2987 ao = BLOCK_ABSTRACT_ORIGIN (ao); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2988 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2989 if (TREE_CODE (ao) == FUNCTION_DECL) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2990 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2991 *pp_ti_abstract_origin (text) = block; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2992 break; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2993 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2994 block = BLOCK_SUPERCONTEXT (block); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2995 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2996 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2997 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2998 /* Print the identifier ID to PRETTY-PRINTER. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2999 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3000 void |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3001 pp_base_tree_identifier (pretty_printer *pp, tree id) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3002 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3003 if (pp_translate_identifiers (pp)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3004 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3005 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3006 pp_append_text (pp, text, text + strlen (text)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3007 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3008 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3009 pp_append_text (pp, IDENTIFIER_POINTER (id), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3010 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3011 } |