Context Navigation

source: trunk/third/gcc/print-tree.c @ 8834

Visit:

Revision 8834, 20.1 KB checked in by ghudson, 28 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r8833, which included commits to RCS files with non-trunk default branches.

Line
1	/* Prints out tree in human readable form - GNU C-compiler
2	Copyright (C) 1990, 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
3
4	This file is part of GNU CC.
5
6	GNU CC is free software; you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation; either version 2, or (at your option)
9	any later version.
10
11	GNU CC is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with GNU CC; see the file COPYING. If not, write to
18	the Free Software Foundation, 59 Temple Place - Suite 330,
19	Boston, MA 02111-1307, USA. */
20
21
22	#include "config.h"
23	#include "tree.h"
24	#include <stdio.h>
25
26	extern char **tree_code_name;
27
28	extern char *mode_name[];
29
30	void print_node ();
31	void indent_to ();
32
33	/* Define the hash table of nodes already seen.
34	Such nodes are not repeated; brief cross-references are used. */
35
36	#define HASH_SIZE 37
37
38	struct bucket
39	{
40	tree node;
41	struct bucket *next;
42	};
43
44	static struct bucket **table;
45
46	/* Print the node NODE on standard error, for debugging.
47	Most nodes referred to by this one are printed recursively
48	down to a depth of six. */
49
50	void
51	debug_tree (node)
52	tree node;
53	{
54	char object = (char ) oballoc (0);
55
56	table = (struct bucket *) oballoc (HASH_SIZE sizeof (struct bucket *));
57	bzero ((char ) table, HASH_SIZE sizeof (struct bucket *));
58	print_node (stderr, "", node, 0);
59	table = 0;
60	obfree (object);
61	fprintf (stderr, "\n");
62	}
63
64	/* Print a node in brief fashion, with just the code, address and name. */
65
66	void
67	print_node_brief (file, prefix, node, indent)
68	FILE *file;
69	char *prefix;
70	tree node;
71	int indent;
72	{
73	char class;
74
75	if (node == 0)
76	return;
77
78	class = TREE_CODE_CLASS (TREE_CODE (node));
79
80	/* Always print the slot this node is in, and its code, address and
81	name if any. */
82	if (indent > 0)
83	fprintf (file, " ");
84	fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
85	fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node);
86
87	if (class == 'd')
88	{
89	if (DECL_NAME (node))
90	fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
91	}
92	else if (class == 't')
93	{
94	if (TYPE_NAME (node))
95	{
96	if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
97	fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
98	else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
99	&& DECL_NAME (TYPE_NAME (node)))
100	fprintf (file, " %s",
101	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
102	}
103	}
104	if (TREE_CODE (node) == IDENTIFIER_NODE)
105	fprintf (file, " %s", IDENTIFIER_POINTER (node));
106	/* We might as well always print the value of an integer. */
107	if (TREE_CODE (node) == INTEGER_CST)
108	{
109	if (TREE_CONSTANT_OVERFLOW (node))
110	fprintf (file, " overflow");
111
112	if (TREE_INT_CST_HIGH (node) == 0)
113	fprintf (file,
114	#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
115	" %1u",
116	#else
117	" %1lu",
118	#endif
119	TREE_INT_CST_LOW (node));
120	else if (TREE_INT_CST_HIGH (node) == -1
121	&& TREE_INT_CST_LOW (node) != 0)
122	fprintf (file,
123	#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
124	" -%1u",
125	#else
126	" -%1lu",
127	#endif
128	-TREE_INT_CST_LOW (node));
129	else
130	fprintf (file,
131	#if HOST_BITS_PER_WIDE_INT == 64
132	#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
133	" 0x%lx%016lx",
134	#else
135	" 0x%x%016x",
136	#endif
137	#else
138	#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
139	" 0x%lx%08lx",
140	#else
141	" 0x%x%08x",
142	#endif
143	#endif
144	TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
145	}
146	if (TREE_CODE (node) == REAL_CST)
147	{
148	REAL_VALUE_TYPE d;
149
150	if (TREE_OVERFLOW (node))
151	fprintf (file, " overflow");
152
153	#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)
154	d = TREE_REAL_CST (node);
155	if (REAL_VALUE_ISINF (d))
156	fprintf (file, " Inf");
157	else if (REAL_VALUE_ISNAN (d))
158	fprintf (file, " Nan");
159	else
160	{
161	char string[100];
162
163	REAL_VALUE_TO_DECIMAL (d, "%e", string);
164	fprintf (file, " %s", string);
165	}
166	#else
167	{
168	int i;
169	unsigned char p = (unsigned char ) &TREE_REAL_CST (node);
170	fprintf (file, " 0x");
171	for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
172	fprintf (file, "%02x", *p++);
173	fprintf (file, "");
174	}
175	#endif
176	}
177
178	fprintf (file, ">");
179	}
180
181	void
182	indent_to (file, column)
183	FILE *file;
184	int column;
185	{
186	int i;
187
188	/* Since this is the long way, indent to desired column. */
189	if (column > 0)
190	fprintf (file, "\n");
191	for (i = 0; i < column; i++)
192	fprintf (file, " ");
193	}
194
195	/* Print the node NODE in full on file FILE, preceded by PREFIX,
196	starting in column INDENT. */
197
198	void
199	print_node (file, prefix, node, indent)
200	FILE *file;
201	char *prefix;
202	tree node;
203	int indent;
204	{
205	int hash;
206	struct bucket *b;
207	enum machine_mode mode;
208	char class;
209	int len;
210	int first_rtl;
211	int i;
212
213	if (node == 0)
214	return;
215
216	class = TREE_CODE_CLASS (TREE_CODE (node));
217
218	/* Don't get too deep in nesting. If the user wants to see deeper,
219	it is easy to use the address of a lowest-level node
220	as an argument in another call to debug_tree. */
221
222	if (indent > 24)
223	{
224	print_node_brief (file, prefix, node, indent);
225	return;
226	}
227
228	if (indent > 8 && (class == 't' \|\| class == 'd'))
229	{
230	print_node_brief (file, prefix, node, indent);
231	return;
232	}
233
234	/* It is unsafe to look at any other filds of an ERROR_MARK node. */
235	if (TREE_CODE (node) == ERROR_MARK)
236	{
237	print_node_brief (file, prefix, node, indent);
238	return;
239	}
240
241	hash = ((unsigned HOST_WIDE_INT) node) % HASH_SIZE;
242
243	/* If node is in the table, just mention its address. */
244	for (b = table[hash]; b; b = b->next)
245	if (b->node == node)
246	{
247	print_node_brief (file, prefix, node, indent);
248	return;
249	}
250
251	/* Add this node to the table. */
252	b = (struct bucket *) oballoc (sizeof (struct bucket));
253	b->node = node;
254	b->next = table[hash];
255	table[hash] = b;
256
257	/* Indent to the specified column, since this is the long form. */
258	indent_to (file, indent);
259
260	/* Print the slot this node is in, and its code, and address. */
261	fprintf (file, "%s <%s ", prefix, tree_code_name[(int) TREE_CODE (node)]);
262	fprintf (file, HOST_PTR_PRINTF, (HOST_WIDE_INT) node);
263
264	/* Print the name, if any. */
265	if (class == 'd')
266	{
267	if (DECL_NAME (node))
268	fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
269	}
270	else if (class == 't')
271	{
272	if (TYPE_NAME (node))
273	{
274	if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
275	fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
276	else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
277	&& DECL_NAME (TYPE_NAME (node)))
278	fprintf (file, " %s",
279	IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
280	}
281	}
282	if (TREE_CODE (node) == IDENTIFIER_NODE)
283	fprintf (file, " %s", IDENTIFIER_POINTER (node));
284
285	if (TREE_CODE (node) == INTEGER_CST)
286	{
287	if (indent <= 4)
288	print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
289	}
290	else
291	{
292	print_node (file, "type", TREE_TYPE (node), indent + 4);
293	if (TREE_TYPE (node))
294	indent_to (file, indent + 3);
295
296	print_obstack_name ((char *) node, file, "");
297	indent_to (file, indent + 3);
298	}
299
300	/* If a permanent object is in the wrong obstack, or the reverse, warn. */
301	if (object_permanent_p (node) != TREE_PERMANENT (node))
302	{
303	if (TREE_PERMANENT (node))
304	fputs (" !!permanent object in non-permanent obstack!!", file);
305	else
306	fputs (" !!non-permanent object in permanent obstack!!", file);
307	indent_to (file, indent + 3);
308	}
309
310	if (TREE_SIDE_EFFECTS (node))
311	fputs (" side-effects", file);
312	if (TREE_READONLY (node))
313	fputs (" readonly", file);
314	if (TREE_CONSTANT (node))
315	fputs (" constant", file);
316	if (TREE_ADDRESSABLE (node))
317	fputs (" addressable", file);
318	if (TREE_THIS_VOLATILE (node))
319	fputs (" volatile", file);
320	if (TREE_UNSIGNED (node))
321	fputs (" unsigned", file);
322	if (TREE_ASM_WRITTEN (node))
323	fputs (" asm_written", file);
324	if (TREE_USED (node))
325	fputs (" used", file);
326	if (TREE_RAISES (node))
327	fputs (" raises", file);
328	if (TREE_PERMANENT (node))
329	fputs (" permanent", file);
330	if (TREE_PUBLIC (node))
331	fputs (" public", file);
332	if (TREE_STATIC (node))
333	fputs (" static", file);
334	if (TREE_LANG_FLAG_0 (node))
335	fputs (" tree_0", file);
336	if (TREE_LANG_FLAG_1 (node))
337	fputs (" tree_1", file);
338	if (TREE_LANG_FLAG_2 (node))
339	fputs (" tree_2", file);
340	if (TREE_LANG_FLAG_3 (node))
341	fputs (" tree_3", file);
342	if (TREE_LANG_FLAG_4 (node))
343	fputs (" tree_4", file);
344	if (TREE_LANG_FLAG_5 (node))
345	fputs (" tree_5", file);
346	if (TREE_LANG_FLAG_6 (node))
347	fputs (" tree_6", file);
348
349	/* DECL_ nodes have additional attributes. */
350
351	switch (TREE_CODE_CLASS (TREE_CODE (node)))
352	{
353	case 'd':
354	mode = DECL_MODE (node);
355
356	if (DECL_IGNORED_P (node))
357	fputs (" ignored", file);
358	if (DECL_ABSTRACT (node))
359	fputs (" abstract", file);
360	if (DECL_IN_SYSTEM_HEADER (node))
361	fputs (" in_system_header", file);
362	if (DECL_COMMON (node))
363	fputs (" common", file);
364	if (DECL_EXTERNAL (node))
365	fputs (" external", file);
366	if (DECL_REGISTER (node))
367	fputs (" regdecl", file);
368	if (DECL_PACKED (node))
369	fputs (" packed", file);
370	if (DECL_NONLOCAL (node))
371	fputs (" nonlocal", file);
372	if (DECL_INLINE (node))
373	fputs (" inline", file);
374
375	if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
376	fputs (" suppress-debug", file);
377
378	if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
379	fputs (" built-in", file);
380	if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN_NONANSI (node))
381	fputs (" built-in-nonansi", file);
382
383	if (TREE_CODE (node) == FIELD_DECL && DECL_BIT_FIELD (node))
384	fputs (" bit-field", file);
385	if (TREE_CODE (node) == LABEL_DECL && DECL_TOO_LATE (node))
386	fputs (" too-late", file);
387	if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node))
388	fputs (" in-text-section", file);
389
390	if (DECL_VIRTUAL_P (node))
391	fputs (" virtual", file);
392	if (DECL_DEFER_OUTPUT (node))
393	fputs (" defer-output", file);
394	if (DECL_TRANSPARENT_UNION (node))
395	fputs (" transparent-union", file);
396
397	if (DECL_LANG_FLAG_0 (node))
398	fputs (" decl_0", file);
399	if (DECL_LANG_FLAG_1 (node))
400	fputs (" decl_1", file);
401	if (DECL_LANG_FLAG_2 (node))
402	fputs (" decl_2", file);
403	if (DECL_LANG_FLAG_3 (node))
404	fputs (" decl_3", file);
405	if (DECL_LANG_FLAG_4 (node))
406	fputs (" decl_4", file);
407	if (DECL_LANG_FLAG_5 (node))
408	fputs (" decl_5", file);
409	if (DECL_LANG_FLAG_6 (node))
410	fputs (" decl_6", file);
411	if (DECL_LANG_FLAG_7 (node))
412	fputs (" decl_7", file);
413
414	fprintf (file, " %s", mode_name[(int) mode]);
415
416	fprintf (file, " file %s line %d",
417	DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
418
419	print_node (file, "size", DECL_SIZE (node), indent + 4);
420	print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
421	indent_to (file, indent + 3);
422	if (TREE_CODE (node) != FUNCTION_DECL)
423	fprintf (file, " align %d", DECL_ALIGN (node));
424	else if (DECL_INLINE (node))
425	fprintf (file, " frame_size %d", DECL_FRAME_SIZE (node));
426	else if (DECL_BUILT_IN (node))
427	fprintf (file, " built-in code %d", DECL_FUNCTION_CODE (node));
428	if (TREE_CODE (node) == FIELD_DECL)
429	print_node (file, "bitpos", DECL_FIELD_BITPOS (node), indent + 4);
430	print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
431	print_node_brief (file, "machine_attributes", DECL_MACHINE_ATTRIBUTES (node), indent + 4);
432	print_node_brief (file, "abstract_origin",
433	DECL_ABSTRACT_ORIGIN (node), indent + 4);
434
435	print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
436	print_node (file, "result", DECL_RESULT (node), indent + 4);
437	print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
438
439	print_lang_decl (file, node, indent);
440
441	if (DECL_RTL (node) != 0)
442	{
443	indent_to (file, indent + 4);
444	print_rtl (file, DECL_RTL (node));
445	}
446
447	if (DECL_SAVED_INSNS (node) != 0)
448	{
449	indent_to (file, indent + 4);
450	if (TREE_CODE (node) == PARM_DECL)
451	{
452	fprintf (file, "incoming-rtl ");
453	print_rtl (file, DECL_INCOMING_RTL (node));
454	}
455	else if (TREE_CODE (node) == FUNCTION_DECL)
456	{
457	fprintf (file, "saved-insns ");
458	fprintf (file, HOST_PTR_PRINTF,
459	(HOST_WIDE_INT) DECL_SAVED_INSNS (node));
460	}
461	}
462
463	/* Print the decl chain only if decl is at second level. */
464	if (indent == 4)
465	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
466	else
467	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
468	break;
469
470	case 't':
471	if (TYPE_NO_FORCE_BLK (node))
472	fputs (" no-force-blk", file);
473	if (TYPE_STRING_FLAG (node))
474	fputs (" string-flag", file);
475	if (TYPE_NEEDS_CONSTRUCTING (node))
476	fputs (" needs-constructing", file);
477	if (TYPE_TRANSPARENT_UNION (node))
478	fputs (" transparent-union", file);
479	if (TYPE_PACKED (node))
480	fputs (" packed", file);
481
482	if (TYPE_LANG_FLAG_0 (node))
483	fputs (" type_0", file);
484	if (TYPE_LANG_FLAG_1 (node))
485	fputs (" type_1", file);
486	if (TYPE_LANG_FLAG_2 (node))
487	fputs (" type_2", file);
488	if (TYPE_LANG_FLAG_3 (node))
489	fputs (" type_3", file);
490	if (TYPE_LANG_FLAG_4 (node))
491	fputs (" type_4", file);
492	if (TYPE_LANG_FLAG_5 (node))
493	fputs (" type_5", file);
494	if (TYPE_LANG_FLAG_6 (node))
495	fputs (" type_6", file);
496
497	mode = TYPE_MODE (node);
498	fprintf (file, " %s", mode_name[(int) mode]);
499
500	print_node (file, "size", TYPE_SIZE (node), indent + 4);
501	indent_to (file, indent + 3);
502
503	fprintf (file, " align %d", TYPE_ALIGN (node));
504	fprintf (file, " symtab %d", TYPE_SYMTAB_ADDRESS (node));
505
506	print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
507
508	if (TREE_CODE (node) == ARRAY_TYPE \|\| TREE_CODE (node) == SET_TYPE)
509	print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
510	else if (TREE_CODE (node) == INTEGER_TYPE
511	\|\| TREE_CODE (node) == BOOLEAN_TYPE
512	\|\| TREE_CODE (node) == CHAR_TYPE)
513	{
514	fprintf (file, " precision %d", TYPE_PRECISION (node));
515	print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
516	print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
517	}
518	else if (TREE_CODE (node) == ENUMERAL_TYPE)
519	{
520	fprintf (file, " precision %d", TYPE_PRECISION (node));
521	print_node (file, "min", TYPE_MIN_VALUE (node), indent + 4);
522	print_node (file, "max", TYPE_MAX_VALUE (node), indent + 4);
523	print_node (file, "values", TYPE_VALUES (node), indent + 4);
524	}
525	else if (TREE_CODE (node) == REAL_TYPE)
526	fprintf (file, " precision %d", TYPE_PRECISION (node));
527	else if (TREE_CODE (node) == RECORD_TYPE
528	\|\| TREE_CODE (node) == UNION_TYPE
529	\|\| TREE_CODE (node) == QUAL_UNION_TYPE)
530	print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
531	else if (TREE_CODE (node) == FUNCTION_TYPE \|\| TREE_CODE (node) == METHOD_TYPE)
532	{
533	if (TYPE_METHOD_BASETYPE (node))
534	print_node_brief (file, "method basetype", TYPE_METHOD_BASETYPE (node), indent + 4);
535	print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
536	}
537	if (TYPE_CONTEXT (node))
538	print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
539
540	print_lang_type (file, node, indent);
541
542	if (TYPE_POINTER_TO (node) \|\| TREE_CHAIN (node))
543	indent_to (file, indent + 3);
544	print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node), indent + 4);
545	print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node), indent + 4);
546	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
547	break;
548
549	case 'b':
550	print_node (file, "vars", BLOCK_VARS (node), indent + 4);
551	print_node (file, "tags", BLOCK_TYPE_TAGS (node), indent + 4);
552	print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node), indent + 4);
553	print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
554	print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
555	print_node (file, "abstract_origin",
556	BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
557	return;
558
559	case 'e':
560	case '<':
561	case '1':
562	case '2':
563	case 'r':
564	case 's':
565	switch (TREE_CODE (node))
566	{
567	case BIND_EXPR:
568	print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
569	print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
570	print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
571	return;
572	}
573
574	first_rtl = len = tree_code_length[(int) TREE_CODE (node)];
575	/* These kinds of nodes contain rtx's, not trees,
576	after a certain point. Print the rtx's as rtx's. */
577	switch (TREE_CODE (node))
578	{
579	case SAVE_EXPR:
580	first_rtl = 2;
581	break;
582	case CALL_EXPR:
583	first_rtl = 2;
584	break;
585	case METHOD_CALL_EXPR:
586	first_rtl = 3;
587	break;
588	case WITH_CLEANUP_EXPR:
589	/* Should be defined to be 2. */
590	first_rtl = 1;
591	break;
592	case RTL_EXPR:
593	first_rtl = 0;
594	}
595	for (i = 0; i < len; i++)
596	{
597	if (i >= first_rtl)
598	{
599	indent_to (file, indent + 4);
600	fprintf (file, "rtl %d ", i);
601	if (TREE_OPERAND (node, i))
602	print_rtl (file, (struct rtx_def *) TREE_OPERAND (node, i));
603	else
604	fprintf (file, "(nil)");
605	fprintf (file, "\n");
606	}
607	else
608	{
609	char temp[10];
610
611	sprintf (temp, "arg %d", i);
612	print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
613	}
614	}
615	break;
616
617	case 'c':
618	case 'x':
619	switch (TREE_CODE (node))
620	{
621	case INTEGER_CST:
622	if (TREE_CONSTANT_OVERFLOW (node))
623	fprintf (file, " overflow");
624
625	if (TREE_INT_CST_HIGH (node) == 0)
626	fprintf (file,
627	#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
628	" %1u",
629	#else
630	" %1lu",
631	#endif
632	TREE_INT_CST_LOW (node));
633	else if (TREE_INT_CST_HIGH (node) == -1
634	&& TREE_INT_CST_LOW (node) != 0)
635	fprintf (file,
636	#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
637	" -%1u",
638	#else
639	" -%1lu",
640	#endif
641	-TREE_INT_CST_LOW (node));
642	else
643	fprintf (file,
644	#if HOST_BITS_PER_WIDE_INT == 64
645	#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
646	" 0x%lx%016lx",
647	#else
648	" 0x%x%016x",
649	#endif
650	#else
651	#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
652	" 0x%lx%08lx",
653	#else
654	" 0x%x%08x",
655	#endif
656	#endif
657	TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
658	break;
659
660	case REAL_CST:
661	{
662	REAL_VALUE_TYPE d;
663
664	if (TREE_OVERFLOW (node))
665	fprintf (file, " overflow");
666
667	#if !defined(REAL_IS_NOT_DOUBLE) \|\| defined(REAL_ARITHMETIC)
668	d = TREE_REAL_CST (node);
669	if (REAL_VALUE_ISINF (d))
670	fprintf (file, " Inf");
671	else if (REAL_VALUE_ISNAN (d))
672	fprintf (file, " Nan");
673	else
674	{
675	char string[100];
676
677	REAL_VALUE_TO_DECIMAL (d, "%e", string);
678	fprintf (file, " %s", string);
679	}
680	#else
681	{
682	int i;
683	unsigned char p = (unsigned char ) &TREE_REAL_CST (node);
684	fprintf (file, " 0x");
685	for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
686	fprintf (file, "%02x", *p++);
687	fprintf (file, "");
688	}
689	#endif
690	}
691	break;
692
693	case COMPLEX_CST:
694	print_node (file, "real", TREE_REALPART (node), indent + 4);
695	print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
696	break;
697
698	case STRING_CST:
699	fprintf (file, " \"%s\"", TREE_STRING_POINTER (node));
700	/* Print the chain at second level. */
701	if (indent == 4)
702	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
703	else
704	print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
705	break;
706
707	case IDENTIFIER_NODE:
708	print_lang_identifier (file, node, indent);
709	break;
710
711	case TREE_LIST:
712	print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
713	print_node (file, "value", TREE_VALUE (node), indent + 4);
714	print_node (file, "chain", TREE_CHAIN (node), indent + 4);
715	break;
716
717	case TREE_VEC:
718	len = TREE_VEC_LENGTH (node);
719	for (i = 0; i < len; i++)
720	if (TREE_VEC_ELT (node, i))
721	{
722	char temp[10];
723	sprintf (temp, "elt %d", i);
724	indent_to (file, indent + 4);
725	print_node_brief (file, temp, TREE_VEC_ELT (node, i), 0);
726	}
727	break;
728
729	case OP_IDENTIFIER:
730	print_node (file, "op1", TREE_PURPOSE (node), indent + 4);
731	print_node (file, "op2", TREE_VALUE (node), indent + 4);
732	}
733
734	break;
735	}
736
737	fprintf (file, ">");
738	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: