GCC Middle and Back End API Reference
tree-dump.c File Reference


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 void dequeue_and_dump ( )
   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
         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 ( )
   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 void dump_index ( )
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 void dump_maybe_newline ( )
   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 void dump_new_line ( )
   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 ( )
   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  ,

Tree-dumping functionality for intermediate representation. Copyright (C) 1999-2013 Free Software Foundation, Inc. Written by Mark Mitchell mark@.nosp@m.code.nosp@m.sourc.nosp@m.ery..nosp@m.com

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 ( )
   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.