Functions
void	debug_generic_expr (tree)
void	debug_generic_stmt (tree)
void	debug_tree_chain (tree)
void	print_generic_decl (FILE *, tree, int)
void	print_generic_stmt (FILE *, tree, int)
void	print_generic_stmt_indented (FILE *, tree, int, int)
void	print_generic_expr (FILE *, tree, int)
void	dump_omp_clauses (pretty_printer *, tree, int, int)
int	dump_generic_node (pretty_printer *, tree, int, int, bool)
void	print_declaration (pretty_printer *, tree, int, int)
int	op_code_prio (enum tree_code)
int	op_prio (const_tree)
const char *	op_symbol_code (enum tree_code)
void	print_call_name (pretty_printer *, tree, int)
void	percent_K_format (text_info *)
void	pp_tree_identifier (pretty_printer *, tree)
void	dump_function_header (FILE *, tree, int)
void	pp_double_int (pretty_printer *pp, double_int d, bool uns)

Function Documentation

void debug_generic_expr ( tree )

void debug_generic_stmt ( tree )

void debug_tree_chain ( tree )

void dump_function_header	(	FILE *	,
		tree	,
		int
	)

int dump_generic_node	(	pretty_printer *	buffer,
		tree	node,
		int	spc,
		int	flags,
		bool	is_stmt
	)

   Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
   indent.  FLAGS specifies details to show in the dump (see TDF_* in
   dumpfile.h).  If IS_STMT is true, the object printed is considered
   to be a statement and it is terminated by ';' if appropriate.

               Dump the types of INTEGER_CSTs explicitly, for we can't
               infer them and MEM_ATTR caching will share MEM_REFs
               with differently-typed op0s.

               Released SSA_NAMES have no TREE_TYPE.

               Same pointer types, but ignoring POINTER_TYPE vs.
               REFERENCE_TYPE.

               Same value types ignoring qualifiers.

           Print the innermost component type.

           Print the dimensions.

           Print the name of the structure.

             FIXME: If we eliminate the 'else' above and attempt
             to show the fields for named types, we may get stuck
             following a cycle of pointers to structs.  The alleged
             self-reference check in print_struct_decl will not detect
             cycles involving more than one pointer or struct type.

             In the case of a pointer, one may want to divide by the
             size of the pointed-to type.  Unfortunately, this not
             straightforward.  The C front-end maps expressions

             (int *) 5
             int *p; (p + 5)

             in such a way that the two INTEGER_CST nodes for "5" have
             different values but identical types.  In the latter
             case, the 5 is multiplied by sizeof (int) in c-common.c
             (pointer_int_sum) to convert it to a byte address, and
             yet the type of the node is left unchanged.  Argh.  What
             is consistent though is that the number value corresponds
             to bytes (UNITS) offset.

             NB: Neither of the following divisors can be trivially
             used to recover the original literal:

             TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
             TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))

         Code copied from print_node.

             Don't print the declaration of built-in types.

                 The type is a c++ class: all structures have at least
                 4 methods.

                     Dump the types of INTEGER_CSTs explicitly, for we
                     can't infer them and MEM_ATTR caching will share
                     MEM_REFs with differently-typed op0s.

                     Released SSA_NAMES have no TREE_TYPE.

                     Same pointer types, but ignoring POINTER_TYPE vs.
                     REFERENCE_TYPE.

                     Same value types ignoring qualifiers.

             The lowered cond_exprs should always be printed in full.

                 Output COND_EXPR_THEN.

                 Output COND_EXPR_ELSE.

         Print parameters.

         Binary arithmetic and logic expressions.

           When the operands are expressions with less priority,
           keep semantics of the tree representation.

           When the operands are expressions with less priority,
           keep semantics of the tree representation.

         Unary arithmetic and logic expressions.

         If this is for break or continue, don't bother printing it.

Referenced by dump_block_node(), dump_gimple_fmt(), dump_gimple_omp_block(), dump_gimple_omp_parallel(), dump_gimple_omp_return(), dump_gimple_omp_teams(), dump_ssaname_info(), print_generic_decl(), and print_generic_stmt().

void dump_omp_clauses	(	pretty_printer *	,
		tree	,
		int	,
		int
	)

int op_code_prio ( enum tree_code )

int op_prio ( const_tree )

const char* op_symbol_code ( enum tree_code )

void percent_K_format ( text_info * )

void pp_double_int	(	pretty_printer *	pp,
		double_int	d,
		bool	uns
	)

void pp_tree_identifier	(	pretty_printer *	,
		tree
	)

void print_call_name	(	pretty_printer *	,
		tree	,
		int
	)

void print_declaration	(	pretty_printer *	,
		tree	,
		int	,
		int
	)

void print_generic_decl	(	FILE *	,
		tree	,
		int
	)

void print_generic_expr	(	FILE *	,
		tree	,
		int
	)

void print_generic_stmt	(	FILE *	,
		tree	,
		int
	)

void print_generic_stmt_indented	(	FILE *	,
		tree	,
		int	,
		int
	)

Functions

Function Documentation