Functions
static unsigned int	queue (dump_info_p, const_tree, int)
static void	dump_index (dump_info_p, unsigned int)
static void	dequeue_and_dump (dump_info_p)
static void	dump_new_line (dump_info_p)
static void	dump_maybe_newline (dump_info_p)
static unsigned int	queue ()
static void	dump_index ()
void	queue_and_dump_index ()
void	queue_and_dump_type ()
static void	dump_new_line ()
static void	dump_maybe_newline ()
void	dump_function ()
void	dump_pointer ()
void	dump_int ()
static void	dump_real ()
static void	dump_fixed ()
void	dump_string ()
void	dump_string_field ()
static void	dequeue_and_dump ()
int	dump_flag (dump_info_p di, int flag, const_tree node)
void	dump_node ()

Function Documentation

static void dequeue_and_dump ( dump_info_p )

static

static void dequeue_and_dump ( )

static

   Dump the next node in the queue.

     Get the next node from the queue.

     Remove the node from the queue, and put it on the free list.

     Print the node index.

     And the type of node this is.

     Figure out what kind of node this is.

     Although BINFOs are TREE_VECs, we dump them specially so as to be
     more informative.

     We can knock off a bunch of expression nodes in exactly the same
     way.

         If we're dumping children, dump them now.

             These nodes are handled explicitly below.

         All declarations have names.

         And types.

         And a source position.

         And any declaration can be compiler-generated.

         All types have qualifiers.

         All types have associated declarations.

         All types have a main variant.

         And sizes.

         All types have alignments.

       All constants can have types.

     Give the language-specific code a chance to print something.  If
     it's completely taken care of things, don't bother printing
     anything more ourselves.

     Now handle the various kinds of nodes.

         Fall through.

         Fall through.

         These nodes are unary, but do not have code class `1'.

         These nodes are binary, but do not have code class `2'.

         There really are two possible places the initializer can be.
         After RTL expansion, the second operand is moved to the
         position of the fourth operand, and the second operand
         becomes NULL.

         There are no additional fields to print.

     Terminate the line.

static void dump_fixed ( )

static

   Dump the fixed-point value F, using FIELD to identify it.

References dump_info::column, dump_maybe_newline(), dump_info::stream, and strlen().

int dump_flag	(	dump_info_p	di,
		int	flag,
		const_tree	node
	)

   Return nonzero if FLAG has been specified for the dump, and NODE
   is not the root node of the dump.

void dump_function ( )

   Dump FUNCTION_DECL FN as tree dump PHASE.

static void dump_index	(	dump_info_p	,
		unsigned	int
	)

static

static void dump_index ( )

static

void dump_int ( )

   Dump integer I using FIELD to identify it.

References dump_info::column, dump_maybe_newline(), fixed_to_decimal(), dump_info::stream, and strlen().

static void dump_maybe_newline ( dump_info_p )

static

Referenced by dump_fixed(), dump_int(), dump_pointer(), and dump_real().

static void dump_maybe_newline ( )

static

   If necessary, insert a new line.

     See if we need a new line.

     See if we need any padding.

References dump_begin(), dump_end(), and dump_function_to_file().

static void dump_new_line ( dump_info_p )

static

static void dump_new_line ( )

static

   Insert a new line in the dump output, and indent to an appropriate
   place to start printing more fields.

void dump_node ( )

   Dump T, and all its children, on STREAM.

     Initialize the dump-information structure.

     Queue up the first node.

     Until the queue is empty, keep dumping nodes.

     Now, clean up.

void dump_pointer ( )

   Dump pointer PTR using FIELD to identify it.

References dump_info::column, dump_maybe_newline(), real_to_decimal(), dump_info::stream, and strlen().

static void dump_real ( )

static

   Dump the floating point value R, using FIELD to identify it.

References dump_info::column, dump_maybe_newline(), dump_info::stream, and strlen().

void dump_string ( )

   Dump the string S.

void dump_string_field ( )

   Dump the string field S.

static unsigned int queue	(	dump_info_p	,
		const_tree	,
		int
	)

static

@verbatim

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/.

static unsigned int queue ( )

static

   Add T to the end of the queue of nodes to dump.  Returns the index
   assigned to T.

     Assign the next available index to T.

     Obtain a new queue node.

     Create a new entry in the splay-tree.

     Add it to the end of the queue.

     Return the index.

References dump_info::free_list, and dump_queue::next.

void queue_and_dump_index ( )

   If T has not already been output, queue it for subsequent output.
   FIELD is a string to print before printing the index.  Then, the
   index of T is printed.

     If there's no node, just return.  This makes for fewer checks in
     our callers.

     See if we've already queued or dumped this node.

       If we haven't, add it to the queue.

     Print the index of the node.

void queue_and_dump_type ( )

   Dump the type of T.

References dump_info::column, and dump_info::stream.

Functions

Function Documentation