print-rtl-function.cc File Reference

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "alias.h"
#include "tree.h"
#include "flags.h"
#include "predict.h"
#include "function.h"
#include "basic-block.h"
#include "print-rtl.h"
#include "langhooks.h"
#include "memmodel.h"
#include "emit-rtl.h"
#include "varasm.h"
#include "cfg-flags.def"

Include dependency graph for print-rtl-function.cc:

Macros
#define	DEF_EDGE_FLAG(NAME, IDX)

Functions
static void	print_edge (FILE *outfile, edge e, bool from)
static void	begin_any_block (FILE *outfile, basic_block bb)
static void	end_any_block (FILE *outfile, basic_block bb)
static bool	can_have_basic_block_p (const rtx_insn *insn)
static void	print_any_param_name (FILE *outfile, tree arg)
static void	print_param (FILE *outfile, rtx_writer &w, tree arg)
DEBUG_FUNCTION void	print_rtx_function (FILE *outfile, function *fn, bool compact)

Macro Definition Documentation

DEF_EDGE_FLAG

#define DEF_EDGE_FLAG	(		NAME,
			IDX )

Value:

  do {                                          \
    if (e->flags & EDGE_##NAME)                 \
      {                                         \
        if (seen_flag)                          \
          fprintf (outfile, " | ");             \
        fprintf (outfile, "%s", (#NAME));       \
        seen_flag = true;                       \
      }                                         \
  } while (0);

Function Documentation

begin_any_block()

static void begin_any_block ( FILE * outfile, basic_block bb )

static

If BB is non-NULL, print the start of a "(block)" directive for it
to OUTFILE, otherwise do nothing.   

References FOR_EACH_EDGE, basic_block_def::index, basic_block_def::preds, and print_edge().

Referenced by print_rtx_function().

can_have_basic_block_p()

static bool can_have_basic_block_p ( const rtx_insn * insn )

static

Determine if INSN is of a kind that can have a basic block.   

References gcc_assert, GET_CODE, and GET_RTX_FORMAT.

Referenced by print_rtx_function().

end_any_block()

static void end_any_block ( FILE * outfile, basic_block bb )

static

If BB is non-NULL, print the end of a "(block)" directive for it
to OUTFILE, otherwise do nothing.   

References FOR_EACH_EDGE, basic_block_def::index, print_edge(), and basic_block_def::succs.

Referenced by print_rtx_function().

print_any_param_name()

static void print_any_param_name ( FILE * outfile, tree arg )

static

Subroutine of print_param.  Write the name of ARG, if any, to OUTFILE.   

References DECL_NAME, and IDENTIFIER_POINTER.

Referenced by print_param().

print_edge()

static void print_edge ( FILE * outfile, edge e, bool from )

static

Print RTL functions for GCC.
   Copyright (C) 2016-2024 Free Software Foundation, Inc.

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/>.   

Print an "(edge-from)" or "(edge-to)" directive describing E
to OUTFILE.   

Flags on basic blocks and edges.
   Copyright (C) 2012-2024 Free Software Foundation, Inc.

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/>.   

This file defines flags that may appear on basic blocks or on
edges.  Source files define DEF_BASIC_BLOCK_FLAG or DEF_EDGE_FLAG
appropriately before including this file.   

Masks for edge.flags.

The format of this file is: DEF_EDGE_FLAG(NAME, IDX, STRING).
NAME is the name of the edge flag.  A flag EDGE_#NAME will be
created and the name is used in dump_edge_info.
IDX is a sequence number that is used to determine the value
of the flag, which is 1 << IDX).   

'Straight line' flow.  In GIMPLE and in cfglayout mode, all normal
edges are fallthru edges.  In cfgrtl mode, this flag really means
that control flow falls through to the next basic block in the line.   

Strange flow, like a computed jump or exception handling.  Usually
this means that the edge cannot be split.   

Edge out of a basic block that ends with a CALL_INSN with abnormal
exit, like an exception or a non-local goto.
ABNORMAL_CALL edges also have ABNORMAL set.
This flag is only used for the RTL CFG.   

Exception edge.  Exception handling edges represent possible control
transfers from a trapping instruction to an exception handler.
EH edges also have ABNORMAL set for the RTL CFG.   

Never merge blocks via this edge.  This is used for exception handling,
to prevent merging away edges to the post-landing-pad basic block.
This flag is only used for the RTL CFG.   

Not a real edge.  This is used to connect parts of the CFG that do
not halt, such as infinite loops and noreturn functions, to the
EXIT_BLOCK, so that traversing of the reverse CFG is possible.   

A back edge, marked in a depth-first search of the CFG.  Back edges
are hints that this edge may be part of a loop in the CFG.   

Edge in a part of the CFG that is an irreducible loop.   

Edge taken when controlling predicate is nonzero.
This is only used for the GIMPLE CFG.   

Edge taken when controlling predicate is zero.
This is only used for the GIMPLE CFG.   

Edge is executable.  This is only used in GIMPLE SSA-CCP and VRP.
This is only used for the GIMPLE CFG.   

Edge crosses between hot and cold sections, when we do partitioning.
This flag is only used for the RTL CFG.   

Edge from a sibcall CALL_INSN to exit.
SIBCALL edges also have ABNORMAL set.
This flag is only used for the RTL CFG.   

Candidate for straight line flow.  Only used in bb-reorder.cc.
This flag is only used for the RTL CFG.   

Exit of a loop.  This is only used in ifcvt.cc.
This flag is only used for the RTL CFG.   

Uninstrumented edge out of a GIMPLE_TRANSACTION statement.   

Abort (over) edge out of a GIMPLE_TRANSACTION statement.   

An edge we should ignore.  It should be entirely local to
passes.  ie, it is never set on any edge upon the completion
of any pass.   

References ENTRY_BLOCK, EXIT_BLOCK, gcc_assert, and basic_block_def::index.

Referenced by begin_any_block(), and end_any_block().

print_param()

static void print_param ( FILE * outfile, rtx_writer & w, tree arg )

static

Print a "(param)" directive for ARG to OUTFILE.   

References DECL_INCOMING_RTL, DECL_RTL_IF_SET, rtx_writer::finish_directive(), print_any_param_name(), and rtx_writer::print_rtx().

Referenced by print_rtx_function().

print_rtx_function()

DEBUG_FUNCTION void print_rtx_function	(	FILE *	outfile,
		function *	fn,
		bool	compact )

Write FN to OUTFILE in a form suitable for parsing, with indentation
  and comments to make the structure easy for a human to grok.  Track
  the basic blocks of insns in the chain, wrapping those that are within
  blocks within "(block)" directives.

  If COMPACT, then instructions are printed in a compact form:
  - INSN_UIDs are omitted, except for jumps and CODE_LABELs,
  - INSN_CODEs are omitted,
  - register numbers are omitted for hard and virtual regs, and
    non-virtual pseudos are offset relative to the first such reg, and
    printed with a '%' sigil e.g. "%0" for (LAST_VIRTUAL_REGISTER + 1),
  - insn names are prefixed with "c" (e.g. "cinsn", "cnote", etc)

  Example output (with COMPACT==true):

  (function "times_two"
    (param "i"
      (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
          (const_int -4)) [1 i+0 S4 A32]))
      (DECL_RTL_INCOMING (reg:SI di [ i ])))
    (insn-chain
      (cnote 1 NOTE_INSN_DELETED)
      (block 2
        (edge-from entry (flags "FALLTHRU"))
        (cnote 4 [bb 2] NOTE_INSN_BASIC_BLOCK)
        (cinsn 2 (set (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
                       (const_int -4)) [1 i+0 S4 A32])
               (reg:SI di [ i ])) "t.c":2)
        (cnote 3 NOTE_INSN_FUNCTION_BEG)
        (cinsn 6 (set (reg:SI <2>)
               (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
                       (const_int -4)) [1 i+0 S4 A32])) "t.c":3)
        (cinsn 7 (parallel [
                   (set (reg:SI <0> [ _2 ])
                       (ashift:SI (reg:SI <2>)
                           (const_int 1)))
                   (clobber (reg:CC flags))
               ]) "t.c":3
            (expr_list:REG_EQUAL (ashift:SI (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars)
                           (const_int -4)) [1 i+0 S4 A32])
                   (const_int 1))))
        (cinsn 10 (set (reg:SI <1> [ <retval> ])
               (reg:SI <0> [ _2 ])) "t.c":3)
        (cinsn 14 (set (reg/i:SI ax)
               (reg:SI <1> [ <retval> ])) "t.c":4)
        (cinsn 15 (use (reg/i:SI ax)) "t.c":4)
        (edge-to exit (flags "FALLTHRU"))
      ) ;; block 2
    ) ;; insn-chain
    (crtl
      (return_rtx
        (reg/i:SI ax)
      ) ;; return_rtx
    ) ;; crtl
  ) ;; function "times_two"

References begin_any_block(), BLOCK_FOR_INSN(), can_have_basic_block_p(), crtl, curr_bb, function::decl, DECL_ARGUMENTS, DECL_CHAIN, lang_hooks::decl_printable_name, end_any_block(), get_insns(), NEXT_INSN(), NULL, print_param(), rtx_writer::print_rtl_single_with_indent(), and r.