/* Instruction scheduling pass. Log dumping infrastructure.
|
/* Instruction scheduling pass. Log dumping infrastructure.
|
Copyright (C) 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
|
Copyright (C) 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "function.h"
|
#include "function.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "insn-attr.h"
|
#include "insn-attr.h"
|
#include "params.h"
|
#include "params.h"
|
#include "output.h"
|
#include "output.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "cselib.h"
|
#include "cselib.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
#ifdef INSN_SCHEDULING
|
#ifdef INSN_SCHEDULING
|
#include "sel-sched-ir.h"
|
#include "sel-sched-ir.h"
|
#include "sel-sched-dump.h"
|
#include "sel-sched-dump.h"
|
|
|
|
|
/* These variables control high-level pretty printing. */
|
/* These variables control high-level pretty printing. */
|
static int sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
static int sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
static int sel_debug_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
static int sel_debug_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
|
|
/* True when a cfg should be dumped. */
|
/* True when a cfg should be dumped. */
|
static bool sel_dump_cfg_p;
|
static bool sel_dump_cfg_p;
|
|
|
/* Variables that are used to build the cfg dump file name. */
|
/* Variables that are used to build the cfg dump file name. */
|
static const char * const sel_debug_cfg_root = "./";
|
static const char * const sel_debug_cfg_root = "./";
|
static const char * const sel_debug_cfg_root_postfix_default = "";
|
static const char * const sel_debug_cfg_root_postfix_default = "";
|
static const char *sel_debug_cfg_root_postfix = "";
|
static const char *sel_debug_cfg_root_postfix = "";
|
static int sel_dump_cfg_fileno = -1;
|
static int sel_dump_cfg_fileno = -1;
|
static int sel_debug_cfg_fileno = -1;
|
static int sel_debug_cfg_fileno = -1;
|
|
|
/* When this flag is on, we are dumping to the .dot file.
|
/* When this flag is on, we are dumping to the .dot file.
|
When it is off, we are dumping to log.
|
When it is off, we are dumping to log.
|
This is useful to differentiate formatting between log and .dot
|
This is useful to differentiate formatting between log and .dot
|
files. */
|
files. */
|
bool sched_dump_to_dot_p = false;
|
bool sched_dump_to_dot_p = false;
|
|
|
/* Controls how insns from a fence list should be dumped. */
|
/* Controls how insns from a fence list should be dumped. */
|
static int dump_flist_insn_flags = (DUMP_INSN_UID | DUMP_INSN_BBN
|
static int dump_flist_insn_flags = (DUMP_INSN_UID | DUMP_INSN_BBN
|
| DUMP_INSN_SEQNO);
|
| DUMP_INSN_SEQNO);
|
|
|
|
|
/* The variable used to hold the value of sched_dump when temporarily
|
/* The variable used to hold the value of sched_dump when temporarily
|
switching dump output to the other source, e.g. the .dot file. */
|
switching dump output to the other source, e.g. the .dot file. */
|
static FILE *saved_sched_dump = NULL;
|
static FILE *saved_sched_dump = NULL;
|
|
|
/* Switch sched_dump to TO. It must not be called twice. */
|
/* Switch sched_dump to TO. It must not be called twice. */
|
static void
|
static void
|
switch_dump (FILE *to)
|
switch_dump (FILE *to)
|
{
|
{
|
gcc_assert (saved_sched_dump == NULL);
|
gcc_assert (saved_sched_dump == NULL);
|
|
|
saved_sched_dump = sched_dump;
|
saved_sched_dump = sched_dump;
|
sched_dump = to;
|
sched_dump = to;
|
}
|
}
|
|
|
/* Restore previously switched dump. */
|
/* Restore previously switched dump. */
|
static void
|
static void
|
restore_dump (void)
|
restore_dump (void)
|
{
|
{
|
sched_dump = saved_sched_dump;
|
sched_dump = saved_sched_dump;
|
saved_sched_dump = NULL;
|
saved_sched_dump = NULL;
|
}
|
}
|
|
|
|
|
/* Functions for dumping instructions, av sets, and exprs. */
|
/* Functions for dumping instructions, av sets, and exprs. */
|
|
|
/* Default flags for dumping insns. */
|
/* Default flags for dumping insns. */
|
static int dump_insn_rtx_flags = DUMP_INSN_RTX_PATTERN;
|
static int dump_insn_rtx_flags = DUMP_INSN_RTX_PATTERN;
|
|
|
/* Default flags for dumping vinsns. */
|
/* Default flags for dumping vinsns. */
|
static int dump_vinsn_flags = (DUMP_VINSN_INSN_RTX | DUMP_VINSN_TYPE
|
static int dump_vinsn_flags = (DUMP_VINSN_INSN_RTX | DUMP_VINSN_TYPE
|
| DUMP_VINSN_COUNT);
|
| DUMP_VINSN_COUNT);
|
|
|
/* Default flags for dumping expressions. */
|
/* Default flags for dumping expressions. */
|
static int dump_expr_flags = DUMP_EXPR_ALL;
|
static int dump_expr_flags = DUMP_EXPR_ALL;
|
|
|
/* Default flags for dumping insns when debugging. */
|
/* Default flags for dumping insns when debugging. */
|
static int debug_insn_rtx_flags = DUMP_INSN_RTX_ALL;
|
static int debug_insn_rtx_flags = DUMP_INSN_RTX_ALL;
|
|
|
/* Default flags for dumping vinsns when debugging. */
|
/* Default flags for dumping vinsns when debugging. */
|
static int debug_vinsn_flags = DUMP_VINSN_ALL;
|
static int debug_vinsn_flags = DUMP_VINSN_ALL;
|
|
|
/* Default flags for dumping expressions when debugging. */
|
/* Default flags for dumping expressions when debugging. */
|
static int debug_expr_flags = DUMP_EXPR_ALL;
|
static int debug_expr_flags = DUMP_EXPR_ALL;
|
|
|
/* Controls how an insn from stream should be dumped when debugging. */
|
/* Controls how an insn from stream should be dumped when debugging. */
|
static int debug_insn_flags = DUMP_INSN_ALL;
|
static int debug_insn_flags = DUMP_INSN_ALL;
|
|
|
/* Print an rtx X. */
|
/* Print an rtx X. */
|
void
|
void
|
sel_print_rtl (rtx x)
|
sel_print_rtl (rtx x)
|
{
|
{
|
print_rtl_single (sched_dump, x);
|
print_rtl_single (sched_dump, x);
|
}
|
}
|
|
|
/* Dump insn INSN honoring FLAGS. */
|
/* Dump insn INSN honoring FLAGS. */
|
void
|
void
|
dump_insn_rtx_1 (rtx insn, int flags)
|
dump_insn_rtx_1 (rtx insn, int flags)
|
{
|
{
|
int all;
|
int all;
|
|
|
/* flags == -1 also means dumping all. */
|
/* flags == -1 also means dumping all. */
|
all = (flags & 1);;
|
all = (flags & 1);;
|
if (all)
|
if (all)
|
flags |= DUMP_INSN_RTX_ALL;
|
flags |= DUMP_INSN_RTX_ALL;
|
|
|
sel_print ("(");
|
sel_print ("(");
|
|
|
if (flags & DUMP_INSN_RTX_UID)
|
if (flags & DUMP_INSN_RTX_UID)
|
sel_print ("%d;", INSN_UID (insn));
|
sel_print ("%d;", INSN_UID (insn));
|
|
|
if (flags & DUMP_INSN_RTX_PATTERN)
|
if (flags & DUMP_INSN_RTX_PATTERN)
|
{
|
{
|
char buf[2048];
|
char buf[2048];
|
|
|
print_insn (buf, insn, 0);
|
print_insn (buf, insn, 0);
|
sel_print ("%s;", buf);
|
sel_print ("%s;", buf);
|
}
|
}
|
|
|
if (flags & DUMP_INSN_RTX_BBN)
|
if (flags & DUMP_INSN_RTX_BBN)
|
{
|
{
|
basic_block bb = BLOCK_FOR_INSN (insn);
|
basic_block bb = BLOCK_FOR_INSN (insn);
|
|
|
sel_print ("bb:%d;", bb != NULL ? bb->index : -1);
|
sel_print ("bb:%d;", bb != NULL ? bb->index : -1);
|
}
|
}
|
|
|
sel_print (")");
|
sel_print (")");
|
}
|
}
|
|
|
|
|
/* Dump INSN with default flags. */
|
/* Dump INSN with default flags. */
|
void
|
void
|
dump_insn_rtx (rtx insn)
|
dump_insn_rtx (rtx insn)
|
{
|
{
|
dump_insn_rtx_1 (insn, dump_insn_rtx_flags);
|
dump_insn_rtx_1 (insn, dump_insn_rtx_flags);
|
}
|
}
|
|
|
|
|
/* Dump INSN to stderr. */
|
/* Dump INSN to stderr. */
|
void
|
void
|
debug_insn_rtx (rtx insn)
|
debug_insn_rtx (rtx insn)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_insn_rtx_1 (insn, debug_insn_rtx_flags);
|
dump_insn_rtx_1 (insn, debug_insn_rtx_flags);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump vinsn VI honoring flags. */
|
/* Dump vinsn VI honoring flags. */
|
void
|
void
|
dump_vinsn_1 (vinsn_t vi, int flags)
|
dump_vinsn_1 (vinsn_t vi, int flags)
|
{
|
{
|
int all;
|
int all;
|
|
|
/* flags == -1 also means dumping all. */
|
/* flags == -1 also means dumping all. */
|
all = flags & 1;
|
all = flags & 1;
|
if (all)
|
if (all)
|
flags |= DUMP_VINSN_ALL;
|
flags |= DUMP_VINSN_ALL;
|
|
|
sel_print ("(");
|
sel_print ("(");
|
|
|
if (flags & DUMP_VINSN_INSN_RTX)
|
if (flags & DUMP_VINSN_INSN_RTX)
|
dump_insn_rtx_1 (VINSN_INSN_RTX (vi), dump_insn_rtx_flags | all);
|
dump_insn_rtx_1 (VINSN_INSN_RTX (vi), dump_insn_rtx_flags | all);
|
|
|
if (flags & DUMP_VINSN_TYPE)
|
if (flags & DUMP_VINSN_TYPE)
|
sel_print ("type:%s;", GET_RTX_NAME (VINSN_TYPE (vi)));
|
sel_print ("type:%s;", GET_RTX_NAME (VINSN_TYPE (vi)));
|
|
|
if (flags & DUMP_VINSN_COUNT)
|
if (flags & DUMP_VINSN_COUNT)
|
sel_print ("count:%d;", VINSN_COUNT (vi));
|
sel_print ("count:%d;", VINSN_COUNT (vi));
|
|
|
if (flags & DUMP_VINSN_COST)
|
if (flags & DUMP_VINSN_COST)
|
{
|
{
|
int cost = vi->cost;
|
int cost = vi->cost;
|
|
|
if (cost != -1)
|
if (cost != -1)
|
sel_print ("cost:%d;", cost);
|
sel_print ("cost:%d;", cost);
|
}
|
}
|
|
|
sel_print (")");
|
sel_print (")");
|
}
|
}
|
|
|
/* Dump vinsn VI with default flags. */
|
/* Dump vinsn VI with default flags. */
|
void
|
void
|
dump_vinsn (vinsn_t vi)
|
dump_vinsn (vinsn_t vi)
|
{
|
{
|
dump_vinsn_1 (vi, dump_vinsn_flags);
|
dump_vinsn_1 (vi, dump_vinsn_flags);
|
}
|
}
|
|
|
/* Dump vinsn VI to stderr. */
|
/* Dump vinsn VI to stderr. */
|
void
|
void
|
debug_vinsn (vinsn_t vi)
|
debug_vinsn (vinsn_t vi)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_vinsn_1 (vi, debug_vinsn_flags);
|
dump_vinsn_1 (vi, debug_vinsn_flags);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump EXPR honoring flags. */
|
/* Dump EXPR honoring flags. */
|
void
|
void
|
dump_expr_1 (expr_t expr, int flags)
|
dump_expr_1 (expr_t expr, int flags)
|
{
|
{
|
int all;
|
int all;
|
|
|
/* flags == -1 also means dumping all. */
|
/* flags == -1 also means dumping all. */
|
all = flags & 1;
|
all = flags & 1;
|
if (all)
|
if (all)
|
flags |= DUMP_EXPR_ALL;
|
flags |= DUMP_EXPR_ALL;
|
|
|
sel_print ("[");
|
sel_print ("[");
|
|
|
if (flags & DUMP_EXPR_VINSN)
|
if (flags & DUMP_EXPR_VINSN)
|
dump_vinsn_1 (EXPR_VINSN (expr), dump_vinsn_flags | all);
|
dump_vinsn_1 (EXPR_VINSN (expr), dump_vinsn_flags | all);
|
|
|
if (flags & DUMP_EXPR_SPEC)
|
if (flags & DUMP_EXPR_SPEC)
|
{
|
{
|
int spec = EXPR_SPEC (expr);
|
int spec = EXPR_SPEC (expr);
|
|
|
if (spec != 0)
|
if (spec != 0)
|
sel_print ("spec:%d;", spec);
|
sel_print ("spec:%d;", spec);
|
}
|
}
|
|
|
if (flags & DUMP_EXPR_USEFULNESS)
|
if (flags & DUMP_EXPR_USEFULNESS)
|
{
|
{
|
int use = EXPR_USEFULNESS (expr);
|
int use = EXPR_USEFULNESS (expr);
|
|
|
if (use != REG_BR_PROB_BASE)
|
if (use != REG_BR_PROB_BASE)
|
sel_print ("use:%d;", use);
|
sel_print ("use:%d;", use);
|
}
|
}
|
|
|
if (flags & DUMP_EXPR_PRIORITY)
|
if (flags & DUMP_EXPR_PRIORITY)
|
sel_print ("prio:%d;", EXPR_PRIORITY (expr));
|
sel_print ("prio:%d;", EXPR_PRIORITY (expr));
|
|
|
if (flags & DUMP_EXPR_SCHED_TIMES)
|
if (flags & DUMP_EXPR_SCHED_TIMES)
|
{
|
{
|
int times = EXPR_SCHED_TIMES (expr);
|
int times = EXPR_SCHED_TIMES (expr);
|
|
|
if (times != 0)
|
if (times != 0)
|
sel_print ("times:%d;", times);
|
sel_print ("times:%d;", times);
|
}
|
}
|
|
|
if (flags & DUMP_EXPR_SPEC_DONE_DS)
|
if (flags & DUMP_EXPR_SPEC_DONE_DS)
|
{
|
{
|
ds_t spec_done_ds = EXPR_SPEC_DONE_DS (expr);
|
ds_t spec_done_ds = EXPR_SPEC_DONE_DS (expr);
|
|
|
if (spec_done_ds != 0)
|
if (spec_done_ds != 0)
|
sel_print ("ds:%d;", spec_done_ds);
|
sel_print ("ds:%d;", spec_done_ds);
|
}
|
}
|
|
|
if (flags & DUMP_EXPR_ORIG_BB)
|
if (flags & DUMP_EXPR_ORIG_BB)
|
{
|
{
|
int orig_bb = EXPR_ORIG_BB_INDEX (expr);
|
int orig_bb = EXPR_ORIG_BB_INDEX (expr);
|
|
|
if (orig_bb != 0)
|
if (orig_bb != 0)
|
sel_print ("orig_bb:%d;", orig_bb);
|
sel_print ("orig_bb:%d;", orig_bb);
|
}
|
}
|
|
|
if (EXPR_TARGET_AVAILABLE (expr) < 1)
|
if (EXPR_TARGET_AVAILABLE (expr) < 1)
|
sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr));
|
sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr));
|
sel_print ("]");
|
sel_print ("]");
|
}
|
}
|
|
|
/* Dump expression EXPR with default flags. */
|
/* Dump expression EXPR with default flags. */
|
void
|
void
|
dump_expr (expr_t expr)
|
dump_expr (expr_t expr)
|
{
|
{
|
dump_expr_1 (expr, dump_expr_flags);
|
dump_expr_1 (expr, dump_expr_flags);
|
}
|
}
|
|
|
/* Dump expression EXPR to stderr. */
|
/* Dump expression EXPR to stderr. */
|
void
|
void
|
debug_expr (expr_t expr)
|
debug_expr (expr_t expr)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_expr_1 (expr, debug_expr_flags);
|
dump_expr_1 (expr, debug_expr_flags);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump insn I honoring FLAGS. */
|
/* Dump insn I honoring FLAGS. */
|
void
|
void
|
dump_insn_1 (insn_t i, int flags)
|
dump_insn_1 (insn_t i, int flags)
|
{
|
{
|
int all;
|
int all;
|
|
|
all = flags & 1;
|
all = flags & 1;
|
if (all)
|
if (all)
|
flags |= DUMP_INSN_ALL;
|
flags |= DUMP_INSN_ALL;
|
|
|
if (!sched_dump_to_dot_p)
|
if (!sched_dump_to_dot_p)
|
sel_print ("(");
|
sel_print ("(");
|
|
|
if (flags & DUMP_INSN_EXPR)
|
if (flags & DUMP_INSN_EXPR)
|
{
|
{
|
dump_expr_1 (INSN_EXPR (i), dump_expr_flags | all);
|
dump_expr_1 (INSN_EXPR (i), dump_expr_flags | all);
|
sel_print (";");
|
sel_print (";");
|
}
|
}
|
else if (flags & DUMP_INSN_PATTERN)
|
else if (flags & DUMP_INSN_PATTERN)
|
{
|
{
|
dump_insn_rtx_1 (i, DUMP_INSN_RTX_PATTERN | all);
|
dump_insn_rtx_1 (i, DUMP_INSN_RTX_PATTERN | all);
|
sel_print (";");
|
sel_print (";");
|
}
|
}
|
else if (flags & DUMP_INSN_UID)
|
else if (flags & DUMP_INSN_UID)
|
sel_print ("uid:%d;", INSN_UID (i));
|
sel_print ("uid:%d;", INSN_UID (i));
|
|
|
if (flags & DUMP_INSN_SEQNO)
|
if (flags & DUMP_INSN_SEQNO)
|
sel_print ("seqno:%d;", INSN_SEQNO (i));
|
sel_print ("seqno:%d;", INSN_SEQNO (i));
|
|
|
if (flags & DUMP_INSN_SCHED_CYCLE)
|
if (flags & DUMP_INSN_SCHED_CYCLE)
|
{
|
{
|
int cycle = INSN_SCHED_CYCLE (i);
|
int cycle = INSN_SCHED_CYCLE (i);
|
|
|
if (cycle != 0)
|
if (cycle != 0)
|
sel_print ("cycle:%d;", cycle);
|
sel_print ("cycle:%d;", cycle);
|
}
|
}
|
|
|
if (!sched_dump_to_dot_p)
|
if (!sched_dump_to_dot_p)
|
sel_print (")");
|
sel_print (")");
|
}
|
}
|
|
|
/* Dump insn I with default flags. */
|
/* Dump insn I with default flags. */
|
void
|
void
|
dump_insn (insn_t i)
|
dump_insn (insn_t i)
|
{
|
{
|
dump_insn_1 (i, DUMP_INSN_EXPR | DUMP_INSN_SCHED_CYCLE);
|
dump_insn_1 (i, DUMP_INSN_EXPR | DUMP_INSN_SCHED_CYCLE);
|
}
|
}
|
|
|
/* Dump INSN to stderr. */
|
/* Dump INSN to stderr. */
|
void
|
void
|
debug_insn (insn_t insn)
|
debug_insn (insn_t insn)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_insn_1 (insn, debug_insn_flags);
|
dump_insn_1 (insn, debug_insn_flags);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dumps av_set AV. */
|
/* Dumps av_set AV. */
|
void
|
void
|
dump_av_set (av_set_t av)
|
dump_av_set (av_set_t av)
|
{
|
{
|
av_set_iterator i;
|
av_set_iterator i;
|
expr_t expr;
|
expr_t expr;
|
|
|
if (!sched_dump_to_dot_p)
|
if (!sched_dump_to_dot_p)
|
sel_print ("{");
|
sel_print ("{");
|
|
|
FOR_EACH_EXPR (expr, i, av)
|
FOR_EACH_EXPR (expr, i, av)
|
{
|
{
|
dump_expr (expr);
|
dump_expr (expr);
|
if (!sched_dump_to_dot_p)
|
if (!sched_dump_to_dot_p)
|
sel_print (" ");
|
sel_print (" ");
|
else
|
else
|
sel_print ("\n");
|
sel_print ("\n");
|
}
|
}
|
|
|
if (!sched_dump_to_dot_p)
|
if (!sched_dump_to_dot_p)
|
sel_print ("}");
|
sel_print ("}");
|
}
|
}
|
|
|
/* Dumps lvset LV. */
|
/* Dumps lvset LV. */
|
void
|
void
|
dump_lv_set (regset lv)
|
dump_lv_set (regset lv)
|
{
|
{
|
sel_print ("{");
|
sel_print ("{");
|
|
|
/* This code was adapted from cfg.c: dump_regset (). */
|
/* This code was adapted from cfg.c: dump_regset (). */
|
if (lv == NULL)
|
if (lv == NULL)
|
sel_print ("nil");
|
sel_print ("nil");
|
else
|
else
|
{
|
{
|
unsigned i;
|
unsigned i;
|
reg_set_iterator rsi;
|
reg_set_iterator rsi;
|
int count = 0;
|
int count = 0;
|
|
|
EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi)
|
EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi)
|
{
|
{
|
sel_print (" %d", i);
|
sel_print (" %d", i);
|
if (i < FIRST_PSEUDO_REGISTER)
|
if (i < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
sel_print (" [%s]", reg_names[i]);
|
sel_print (" [%s]", reg_names[i]);
|
++count;
|
++count;
|
}
|
}
|
|
|
++count;
|
++count;
|
|
|
if (sched_dump_to_dot_p && count == 12)
|
if (sched_dump_to_dot_p && count == 12)
|
{
|
{
|
count = 0;
|
count = 0;
|
sel_print ("\n");
|
sel_print ("\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
sel_print ("}\n");
|
sel_print ("}\n");
|
}
|
}
|
|
|
/* Dumps a list of instructions pointed to by P. */
|
/* Dumps a list of instructions pointed to by P. */
|
static void
|
static void
|
dump_ilist (ilist_t p)
|
dump_ilist (ilist_t p)
|
{
|
{
|
while (p)
|
while (p)
|
{
|
{
|
dump_insn (ILIST_INSN (p));
|
dump_insn (ILIST_INSN (p));
|
p = ILIST_NEXT (p);
|
p = ILIST_NEXT (p);
|
}
|
}
|
}
|
}
|
|
|
/* Dumps a list of boundaries pointed to by BNDS. */
|
/* Dumps a list of boundaries pointed to by BNDS. */
|
void
|
void
|
dump_blist (blist_t bnds)
|
dump_blist (blist_t bnds)
|
{
|
{
|
for (; bnds; bnds = BLIST_NEXT (bnds))
|
for (; bnds; bnds = BLIST_NEXT (bnds))
|
{
|
{
|
bnd_t bnd = BLIST_BND (bnds);
|
bnd_t bnd = BLIST_BND (bnds);
|
|
|
sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd)));
|
sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd)));
|
dump_ilist (BND_PTR (bnd));
|
dump_ilist (BND_PTR (bnd));
|
sel_print ("] ");
|
sel_print ("] ");
|
}
|
}
|
}
|
}
|
|
|
/* Dumps a list of fences pointed to by L. */
|
/* Dumps a list of fences pointed to by L. */
|
void
|
void
|
dump_flist (flist_t l)
|
dump_flist (flist_t l)
|
{
|
{
|
while (l)
|
while (l)
|
{
|
{
|
dump_insn_1 (FENCE_INSN (FLIST_FENCE (l)), dump_flist_insn_flags);
|
dump_insn_1 (FENCE_INSN (FLIST_FENCE (l)), dump_flist_insn_flags);
|
sel_print (" ");
|
sel_print (" ");
|
l = FLIST_NEXT (l);
|
l = FLIST_NEXT (l);
|
}
|
}
|
}
|
}
|
|
|
/* Dumps an insn vector SUCCS. */
|
/* Dumps an insn vector SUCCS. */
|
void
|
void
|
dump_insn_vector (rtx_vec_t succs)
|
dump_insn_vector (rtx_vec_t succs)
|
{
|
{
|
int i;
|
int i;
|
rtx succ;
|
rtx succ;
|
|
|
for (i = 0; VEC_iterate (rtx, succs, i, succ); i++)
|
for (i = 0; VEC_iterate (rtx, succs, i, succ); i++)
|
if (succ)
|
if (succ)
|
dump_insn (succ);
|
dump_insn (succ);
|
else
|
else
|
sel_print ("NULL ");
|
sel_print ("NULL ");
|
}
|
}
|
|
|
/* Dumps a hard reg set SET to FILE using PREFIX. */
|
/* Dumps a hard reg set SET to FILE using PREFIX. */
|
static void
|
static void
|
print_hard_reg_set (FILE *file, const char *prefix, HARD_REG_SET set)
|
print_hard_reg_set (FILE *file, const char *prefix, HARD_REG_SET set)
|
{
|
{
|
int i;
|
int i;
|
|
|
fprintf (file, "%s{ ", prefix);
|
fprintf (file, "%s{ ", prefix);
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
{
|
{
|
if (TEST_HARD_REG_BIT (set, i))
|
if (TEST_HARD_REG_BIT (set, i))
|
fprintf (file, "%d ", i);
|
fprintf (file, "%d ", i);
|
}
|
}
|
fprintf (file, "}\n");
|
fprintf (file, "}\n");
|
}
|
}
|
|
|
/* Dumps a hard reg set SET using PREFIX. */
|
/* Dumps a hard reg set SET using PREFIX. */
|
void
|
void
|
dump_hard_reg_set (const char *prefix, HARD_REG_SET set)
|
dump_hard_reg_set (const char *prefix, HARD_REG_SET set)
|
{
|
{
|
print_hard_reg_set (sched_dump, prefix, set);
|
print_hard_reg_set (sched_dump, prefix, set);
|
}
|
}
|
|
|
/* Pretty print INSN. This is used as a hook. */
|
/* Pretty print INSN. This is used as a hook. */
|
const char *
|
const char *
|
sel_print_insn (const_rtx insn, int aligned ATTRIBUTE_UNUSED)
|
sel_print_insn (const_rtx insn, int aligned ATTRIBUTE_UNUSED)
|
{
|
{
|
static char buf[80];
|
static char buf[80];
|
|
|
/* '+' before insn means it is a new cycle start and it's not been
|
/* '+' before insn means it is a new cycle start and it's not been
|
scheduled yet. '>' - has been scheduled. */
|
scheduled yet. '>' - has been scheduled. */
|
if (s_i_d && INSN_LUID (insn) > 0)
|
if (s_i_d && INSN_LUID (insn) > 0)
|
if (GET_MODE (insn) == TImode)
|
if (GET_MODE (insn) == TImode)
|
sprintf (buf, "%s %4d",
|
sprintf (buf, "%s %4d",
|
INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
|
INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
|
INSN_UID (insn));
|
INSN_UID (insn));
|
else
|
else
|
sprintf (buf, "%s %4d",
|
sprintf (buf, "%s %4d",
|
INSN_SCHED_TIMES (insn) > 0 ? "! " : " ",
|
INSN_SCHED_TIMES (insn) > 0 ? "! " : " ",
|
INSN_UID (insn));
|
INSN_UID (insn));
|
else
|
else
|
if (GET_MODE (insn) == TImode)
|
if (GET_MODE (insn) == TImode)
|
sprintf (buf, "+ %4d", INSN_UID (insn));
|
sprintf (buf, "+ %4d", INSN_UID (insn));
|
else
|
else
|
sprintf (buf, " %4d", INSN_UID (insn));
|
sprintf (buf, " %4d", INSN_UID (insn));
|
|
|
return buf;
|
return buf;
|
}
|
}
|
|
|
|
|
/* Functions for pretty printing of CFG. */
|
/* Functions for pretty printing of CFG. */
|
|
|
/* Replace all occurencies of STR1 to STR2 in BUF.
|
/* Replace all occurencies of STR1 to STR2 in BUF.
|
The BUF must be large enough to hold the result. */
|
The BUF must be large enough to hold the result. */
|
static void
|
static void
|
replace_str_in_buf (char *buf, const char *str1, const char *str2)
|
replace_str_in_buf (char *buf, const char *str1, const char *str2)
|
{
|
{
|
int buf_len = strlen (buf);
|
int buf_len = strlen (buf);
|
int str1_len = strlen (str1);
|
int str1_len = strlen (str1);
|
int str2_len = strlen (str2);
|
int str2_len = strlen (str2);
|
int diff = str2_len - str1_len;
|
int diff = str2_len - str1_len;
|
|
|
char *p = buf;
|
char *p = buf;
|
do
|
do
|
{
|
{
|
p = strstr (p, str1);
|
p = strstr (p, str1);
|
if (p)
|
if (p)
|
{
|
{
|
char *p1 = p + str1_len;
|
char *p1 = p + str1_len;
|
/* Copy the rest of buf and '\0'. */
|
/* Copy the rest of buf and '\0'. */
|
int n = buf + buf_len - p1;
|
int n = buf + buf_len - p1;
|
int i;
|
int i;
|
|
|
/* Shift str by DIFF chars. */
|
/* Shift str by DIFF chars. */
|
if (diff > 0)
|
if (diff > 0)
|
for (i = n; i >= 0; i--)
|
for (i = n; i >= 0; i--)
|
p1[i + diff] = p1[i];
|
p1[i + diff] = p1[i];
|
else
|
else
|
for (i = 0; i <= n; i++)
|
for (i = 0; i <= n; i++)
|
p1[i + diff] = p1[i];
|
p1[i + diff] = p1[i];
|
|
|
/* Copy str2. */
|
/* Copy str2. */
|
for (i = 0; i < str2_len; i++)
|
for (i = 0; i < str2_len; i++)
|
p[i] = str2[i];
|
p[i] = str2[i];
|
|
|
p += str2_len;
|
p += str2_len;
|
buf_len += diff;
|
buf_len += diff;
|
}
|
}
|
|
|
}
|
}
|
while (p);
|
while (p);
|
}
|
}
|
|
|
/* Replace characters in BUF that have special meaning in .dot file. */
|
/* Replace characters in BUF that have special meaning in .dot file. */
|
static void
|
static void
|
sel_prepare_string_for_dot_label (char *buf)
|
sel_prepare_string_for_dot_label (char *buf)
|
{
|
{
|
static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"",
|
static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"",
|
"\n" };
|
"\n" };
|
static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}",
|
static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}",
|
"\\\"", "\\l" };
|
"\\\"", "\\l" };
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; i < 7; i++)
|
for (i = 0; i < 7; i++)
|
replace_str_in_buf (buf, specials_from[i], specials_to[i]);
|
replace_str_in_buf (buf, specials_from[i], specials_to[i]);
|
}
|
}
|
|
|
/* This function acts like printf but dumps to the sched_dump file. */
|
/* This function acts like printf but dumps to the sched_dump file. */
|
void
|
void
|
sel_print (const char *fmt, ...)
|
sel_print (const char *fmt, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
va_start (ap, fmt);
|
va_start (ap, fmt);
|
if (sched_dump_to_dot_p)
|
if (sched_dump_to_dot_p)
|
{
|
{
|
char *message;
|
char *message;
|
if (vasprintf (&message, fmt, ap) >= 0 && message != NULL)
|
if (vasprintf (&message, fmt, ap) >= 0 && message != NULL)
|
{
|
{
|
message = (char *) xrealloc (message, 2 * strlen (message) + 1);
|
message = (char *) xrealloc (message, 2 * strlen (message) + 1);
|
sel_prepare_string_for_dot_label (message);
|
sel_prepare_string_for_dot_label (message);
|
fprintf (sched_dump, "%s", message);
|
fprintf (sched_dump, "%s", message);
|
free (message);
|
free (message);
|
}
|
}
|
}
|
}
|
else
|
else
|
vfprintf (sched_dump, fmt, ap);
|
vfprintf (sched_dump, fmt, ap);
|
va_end (ap);
|
va_end (ap);
|
}
|
}
|
|
|
/* Dump INSN with FLAGS. */
|
/* Dump INSN with FLAGS. */
|
static void
|
static void
|
sel_dump_cfg_insn (insn_t insn, int flags)
|
sel_dump_cfg_insn (insn_t insn, int flags)
|
{
|
{
|
int insn_flags = DUMP_INSN_UID | DUMP_INSN_PATTERN;
|
int insn_flags = DUMP_INSN_UID | DUMP_INSN_PATTERN;
|
|
|
if (sched_luids != NULL && INSN_LUID (insn) > 0)
|
if (sched_luids != NULL && INSN_LUID (insn) > 0)
|
{
|
{
|
if (flags & SEL_DUMP_CFG_INSN_SEQNO)
|
if (flags & SEL_DUMP_CFG_INSN_SEQNO)
|
insn_flags |= DUMP_INSN_SEQNO | DUMP_INSN_SCHED_CYCLE | DUMP_INSN_EXPR;
|
insn_flags |= DUMP_INSN_SEQNO | DUMP_INSN_SCHED_CYCLE | DUMP_INSN_EXPR;
|
}
|
}
|
|
|
dump_insn_1 (insn, insn_flags);
|
dump_insn_1 (insn, insn_flags);
|
}
|
}
|
|
|
/* Dump E to the dot file F. */
|
/* Dump E to the dot file F. */
|
static void
|
static void
|
sel_dump_cfg_edge (FILE *f, edge e)
|
sel_dump_cfg_edge (FILE *f, edge e)
|
{
|
{
|
int w;
|
int w;
|
const char *color;
|
const char *color;
|
|
|
if (e->flags & EDGE_FALLTHRU)
|
if (e->flags & EDGE_FALLTHRU)
|
{
|
{
|
w = 10;
|
w = 10;
|
color = ", color = red";
|
color = ", color = red";
|
}
|
}
|
else if (e->src->next_bb == e->dest)
|
else if (e->src->next_bb == e->dest)
|
{
|
{
|
w = 3;
|
w = 3;
|
color = ", color = blue";
|
color = ", color = blue";
|
}
|
}
|
else
|
else
|
{
|
{
|
w = 1;
|
w = 1;
|
color = "";
|
color = "";
|
}
|
}
|
|
|
fprintf (f, "\tbb%d -> bb%d [weight = %d%s];\n",
|
fprintf (f, "\tbb%d -> bb%d [weight = %d%s];\n",
|
e->src->index, e->dest->index, w, color);
|
e->src->index, e->dest->index, w, color);
|
}
|
}
|
|
|
|
|
/* Return true if BB has a predesessor from current region.
|
/* Return true if BB has a predesessor from current region.
|
TODO: Either make this function to trace back through empty block
|
TODO: Either make this function to trace back through empty block
|
or just remove those empty blocks. */
|
or just remove those empty blocks. */
|
static bool
|
static bool
|
has_preds_in_current_region_p (basic_block bb)
|
has_preds_in_current_region_p (basic_block bb)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
gcc_assert (!in_current_region_p (bb));
|
gcc_assert (!in_current_region_p (bb));
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
if (in_current_region_p (e->src))
|
if (in_current_region_p (e->src))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Dump a cfg region to the dot file F honoring FLAGS. */
|
/* Dump a cfg region to the dot file F honoring FLAGS. */
|
static void
|
static void
|
sel_dump_cfg_2 (FILE *f, int flags)
|
sel_dump_cfg_2 (FILE *f, int flags)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
sched_dump_to_dot_p = true;
|
sched_dump_to_dot_p = true;
|
switch_dump (f);
|
switch_dump (f);
|
|
|
fprintf (f, "digraph G {\n"
|
fprintf (f, "digraph G {\n"
|
"\tratio = 2.25;\n"
|
"\tratio = 2.25;\n"
|
"\tnode [shape = record, fontsize = 9];\n");
|
"\tnode [shape = record, fontsize = 9];\n");
|
|
|
if (flags & SEL_DUMP_CFG_FUNCTION_NAME)
|
if (flags & SEL_DUMP_CFG_FUNCTION_NAME)
|
fprintf (f, "function [label = \"%s\"];\n", current_function_name ());
|
fprintf (f, "function [label = \"%s\"];\n", current_function_name ());
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
insn_t insn = BB_HEAD (bb);
|
insn_t insn = BB_HEAD (bb);
|
insn_t next_tail = NEXT_INSN (BB_END (bb));
|
insn_t next_tail = NEXT_INSN (BB_END (bb));
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
bool in_region_p = ((flags & SEL_DUMP_CFG_CURRENT_REGION)
|
bool in_region_p = ((flags & SEL_DUMP_CFG_CURRENT_REGION)
|
&& in_current_region_p (bb));
|
&& in_current_region_p (bb));
|
bool full_p = (!(flags & SEL_DUMP_CFG_CURRENT_REGION)
|
bool full_p = (!(flags & SEL_DUMP_CFG_CURRENT_REGION)
|
|| in_region_p);
|
|| in_region_p);
|
bool some_p = full_p || has_preds_in_current_region_p (bb);
|
bool some_p = full_p || has_preds_in_current_region_p (bb);
|
const char *color;
|
const char *color;
|
const char *style;
|
const char *style;
|
|
|
if (!some_p)
|
if (!some_p)
|
continue;
|
continue;
|
|
|
if ((flags & SEL_DUMP_CFG_CURRENT_REGION)
|
if ((flags & SEL_DUMP_CFG_CURRENT_REGION)
|
&& in_current_region_p (bb)
|
&& in_current_region_p (bb)
|
&& BLOCK_TO_BB (bb->index) == 0)
|
&& BLOCK_TO_BB (bb->index) == 0)
|
color = "color = green, ";
|
color = "color = green, ";
|
else
|
else
|
color = "";
|
color = "";
|
|
|
if ((flags & SEL_DUMP_CFG_FENCES)
|
if ((flags & SEL_DUMP_CFG_FENCES)
|
&& in_region_p)
|
&& in_region_p)
|
{
|
{
|
style = "";
|
style = "";
|
|
|
if (!sel_bb_empty_p (bb))
|
if (!sel_bb_empty_p (bb))
|
{
|
{
|
bool first_p = true;
|
bool first_p = true;
|
insn_t tail = BB_END (bb);
|
insn_t tail = BB_END (bb);
|
insn_t cur_insn;
|
insn_t cur_insn;
|
|
|
cur_insn = bb_note (bb);
|
cur_insn = bb_note (bb);
|
|
|
do
|
do
|
{
|
{
|
fence_t fence;
|
fence_t fence;
|
|
|
cur_insn = NEXT_INSN (cur_insn);
|
cur_insn = NEXT_INSN (cur_insn);
|
fence = flist_lookup (fences, cur_insn);
|
fence = flist_lookup (fences, cur_insn);
|
|
|
if (fence != NULL)
|
if (fence != NULL)
|
{
|
{
|
if (!FENCE_SCHEDULED_P (fence))
|
if (!FENCE_SCHEDULED_P (fence))
|
{
|
{
|
if (first_p)
|
if (first_p)
|
color = "color = red, ";
|
color = "color = red, ";
|
else
|
else
|
color = "color = yellow, ";
|
color = "color = yellow, ";
|
}
|
}
|
else
|
else
|
color = "color = blue, ";
|
color = "color = blue, ";
|
}
|
}
|
|
|
first_p = false;
|
first_p = false;
|
}
|
}
|
while (cur_insn != tail);
|
while (cur_insn != tail);
|
}
|
}
|
}
|
}
|
else if (!full_p)
|
else if (!full_p)
|
style = "style = dashed, ";
|
style = "style = dashed, ";
|
else
|
else
|
style = "";
|
style = "";
|
|
|
fprintf (f, "\tbb%d [%s%slabel = \"{Basic block %d", bb->index,
|
fprintf (f, "\tbb%d [%s%slabel = \"{Basic block %d", bb->index,
|
style, color, bb->index);
|
style, color, bb->index);
|
|
|
if ((flags & SEL_DUMP_CFG_BB_LOOP)
|
if ((flags & SEL_DUMP_CFG_BB_LOOP)
|
&& bb->loop_father != NULL)
|
&& bb->loop_father != NULL)
|
fprintf (f, ", loop %d", bb->loop_father->num);
|
fprintf (f, ", loop %d", bb->loop_father->num);
|
|
|
if (full_p
|
if (full_p
|
&& (flags & SEL_DUMP_CFG_BB_NOTES_LIST))
|
&& (flags & SEL_DUMP_CFG_BB_NOTES_LIST))
|
{
|
{
|
insn_t notes = BB_NOTE_LIST (bb);
|
insn_t notes = BB_NOTE_LIST (bb);
|
|
|
if (notes != NULL_RTX)
|
if (notes != NULL_RTX)
|
{
|
{
|
fprintf (f, "|");
|
fprintf (f, "|");
|
|
|
/* For simplicity, we dump notes from note_list in reversed order
|
/* For simplicity, we dump notes from note_list in reversed order
|
to that what they will appear in the code. */
|
to that what they will appear in the code. */
|
while (notes != NULL_RTX)
|
while (notes != NULL_RTX)
|
{
|
{
|
sel_dump_cfg_insn (notes, flags);
|
sel_dump_cfg_insn (notes, flags);
|
fprintf (f, "\\l");
|
fprintf (f, "\\l");
|
|
|
notes = PREV_INSN (notes);
|
notes = PREV_INSN (notes);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (full_p
|
if (full_p
|
&& (flags & SEL_DUMP_CFG_AV_SET)
|
&& (flags & SEL_DUMP_CFG_AV_SET)
|
&& in_current_region_p (bb)
|
&& in_current_region_p (bb)
|
&& !sel_bb_empty_p (bb))
|
&& !sel_bb_empty_p (bb))
|
{
|
{
|
fprintf (f, "|");
|
fprintf (f, "|");
|
|
|
if (BB_AV_SET_VALID_P (bb))
|
if (BB_AV_SET_VALID_P (bb))
|
dump_av_set (BB_AV_SET (bb));
|
dump_av_set (BB_AV_SET (bb));
|
else if (BB_AV_LEVEL (bb) == -1)
|
else if (BB_AV_LEVEL (bb) == -1)
|
fprintf (f, "AV_SET needs update");
|
fprintf (f, "AV_SET needs update");
|
}
|
}
|
|
|
if ((flags & SEL_DUMP_CFG_LV_SET)
|
if ((flags & SEL_DUMP_CFG_LV_SET)
|
&& !sel_bb_empty_p (bb))
|
&& !sel_bb_empty_p (bb))
|
{
|
{
|
fprintf (f, "|");
|
fprintf (f, "|");
|
|
|
if (BB_LV_SET_VALID_P (bb))
|
if (BB_LV_SET_VALID_P (bb))
|
dump_lv_set (BB_LV_SET (bb));
|
dump_lv_set (BB_LV_SET (bb));
|
else
|
else
|
fprintf (f, "LV_SET needs update");
|
fprintf (f, "LV_SET needs update");
|
}
|
}
|
|
|
if (full_p
|
if (full_p
|
&& (flags & SEL_DUMP_CFG_BB_INSNS))
|
&& (flags & SEL_DUMP_CFG_BB_INSNS))
|
{
|
{
|
fprintf (f, "|");
|
fprintf (f, "|");
|
while (insn != next_tail)
|
while (insn != next_tail)
|
{
|
{
|
sel_dump_cfg_insn (insn, flags);
|
sel_dump_cfg_insn (insn, flags);
|
fprintf (f, "\\l");
|
fprintf (f, "\\l");
|
|
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
}
|
}
|
}
|
}
|
|
|
fprintf (f, "}\"];\n");
|
fprintf (f, "}\"];\n");
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
if (full_p || in_current_region_p (e->dest))
|
if (full_p || in_current_region_p (e->dest))
|
sel_dump_cfg_edge (f, e);
|
sel_dump_cfg_edge (f, e);
|
}
|
}
|
|
|
fprintf (f, "}");
|
fprintf (f, "}");
|
|
|
restore_dump ();
|
restore_dump ();
|
sched_dump_to_dot_p = false;
|
sched_dump_to_dot_p = false;
|
}
|
}
|
|
|
/* Dump a cfg region to the file specified by TAG honoring flags.
|
/* Dump a cfg region to the file specified by TAG honoring flags.
|
The file is created by the function. */
|
The file is created by the function. */
|
static void
|
static void
|
sel_dump_cfg_1 (const char *tag, int flags)
|
sel_dump_cfg_1 (const char *tag, int flags)
|
{
|
{
|
char *buf;
|
char *buf;
|
int i;
|
int i;
|
FILE *f;
|
FILE *f;
|
|
|
++sel_dump_cfg_fileno;
|
++sel_dump_cfg_fileno;
|
|
|
if (!sel_dump_cfg_p)
|
if (!sel_dump_cfg_p)
|
return;
|
return;
|
|
|
i = 1 + snprintf (NULL, 0, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
|
i = 1 + snprintf (NULL, 0, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
|
sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
|
sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
|
buf = XNEWVEC (char, i);
|
buf = XNEWVEC (char, i);
|
snprintf (buf, i, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
|
snprintf (buf, i, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
|
sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
|
sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
|
|
|
f = fopen (buf, "w");
|
f = fopen (buf, "w");
|
|
|
if (f == NULL)
|
if (f == NULL)
|
fprintf (stderr, "Can't create file: %s.\n", buf);
|
fprintf (stderr, "Can't create file: %s.\n", buf);
|
else
|
else
|
{
|
{
|
sel_dump_cfg_2 (f, flags);
|
sel_dump_cfg_2 (f, flags);
|
|
|
fclose (f);
|
fclose (f);
|
}
|
}
|
|
|
free (buf);
|
free (buf);
|
}
|
}
|
|
|
/* Setup cfg dumping flags. Used for debugging. */
|
/* Setup cfg dumping flags. Used for debugging. */
|
void
|
void
|
setup_dump_cfg_params (void)
|
setup_dump_cfg_params (void)
|
{
|
{
|
sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
|
sel_dump_cfg_p = 0;
|
sel_dump_cfg_p = 0;
|
sel_debug_cfg_root_postfix = sel_debug_cfg_root_postfix_default;
|
sel_debug_cfg_root_postfix = sel_debug_cfg_root_postfix_default;
|
}
|
}
|
|
|
/* Debug a cfg region with FLAGS. */
|
/* Debug a cfg region with FLAGS. */
|
void
|
void
|
sel_debug_cfg_1 (int flags)
|
sel_debug_cfg_1 (int flags)
|
{
|
{
|
bool t1 = sel_dump_cfg_p;
|
bool t1 = sel_dump_cfg_p;
|
int t2 = sel_dump_cfg_fileno;
|
int t2 = sel_dump_cfg_fileno;
|
|
|
sel_dump_cfg_p = true;
|
sel_dump_cfg_p = true;
|
sel_dump_cfg_fileno = ++sel_debug_cfg_fileno;
|
sel_dump_cfg_fileno = ++sel_debug_cfg_fileno;
|
|
|
sel_dump_cfg_1 ("sel-debug-cfg", flags);
|
sel_dump_cfg_1 ("sel-debug-cfg", flags);
|
|
|
sel_dump_cfg_fileno = t2;
|
sel_dump_cfg_fileno = t2;
|
sel_dump_cfg_p = t1;
|
sel_dump_cfg_p = t1;
|
}
|
}
|
|
|
/* Dumps av_set AV to stderr. */
|
/* Dumps av_set AV to stderr. */
|
void
|
void
|
debug_av_set (av_set_t av)
|
debug_av_set (av_set_t av)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_av_set (av);
|
dump_av_set (av);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump LV to stderr. */
|
/* Dump LV to stderr. */
|
void
|
void
|
debug_lv_set (regset lv)
|
debug_lv_set (regset lv)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_lv_set (lv);
|
dump_lv_set (lv);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump an instruction list P to stderr. */
|
/* Dump an instruction list P to stderr. */
|
void
|
void
|
debug_ilist (ilist_t p)
|
debug_ilist (ilist_t p)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_ilist (p);
|
dump_ilist (p);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump a boundary list BNDS to stderr. */
|
/* Dump a boundary list BNDS to stderr. */
|
void
|
void
|
debug_blist (blist_t bnds)
|
debug_blist (blist_t bnds)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_blist (bnds);
|
dump_blist (bnds);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump an insn vector SUCCS. */
|
/* Dump an insn vector SUCCS. */
|
void
|
void
|
debug_insn_vector (rtx_vec_t succs)
|
debug_insn_vector (rtx_vec_t succs)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_insn_vector (succs);
|
dump_insn_vector (succs);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Dump a hard reg set SET to stderr. */
|
/* Dump a hard reg set SET to stderr. */
|
void
|
void
|
debug_hard_reg_set (HARD_REG_SET set)
|
debug_hard_reg_set (HARD_REG_SET set)
|
{
|
{
|
switch_dump (stderr);
|
switch_dump (stderr);
|
dump_hard_reg_set ("", set);
|
dump_hard_reg_set ("", set);
|
sel_print ("\n");
|
sel_print ("\n");
|
restore_dump ();
|
restore_dump ();
|
}
|
}
|
|
|
/* Debug a cfg region with default flags. */
|
/* Debug a cfg region with default flags. */
|
void
|
void
|
sel_debug_cfg (void)
|
sel_debug_cfg (void)
|
{
|
{
|
sel_debug_cfg_1 (sel_debug_cfg_flags);
|
sel_debug_cfg_1 (sel_debug_cfg_flags);
|
}
|
}
|
|
|
/* Print a current cselib value for X's address to stderr. */
|
/* Print a current cselib value for X's address to stderr. */
|
rtx
|
rtx
|
debug_mem_addr_value (rtx x)
|
debug_mem_addr_value (rtx x)
|
{
|
{
|
rtx t, addr;
|
rtx t, addr;
|
enum machine_mode address_mode;
|
enum machine_mode address_mode;
|
|
|
gcc_assert (MEM_P (x));
|
gcc_assert (MEM_P (x));
|
address_mode = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
|
address_mode = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
|
|
|
t = shallow_copy_rtx (x);
|
t = shallow_copy_rtx (x);
|
if (cselib_lookup (XEXP (t, 0), address_mode, 0))
|
if (cselib_lookup (XEXP (t, 0), address_mode, 0))
|
XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0));
|
XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0));
|
|
|
t = canon_rtx (t);
|
t = canon_rtx (t);
|
addr = get_addr (XEXP (t, 0));
|
addr = get_addr (XEXP (t, 0));
|
debug_rtx (t);
|
debug_rtx (t);
|
debug_rtx (addr);
|
debug_rtx (addr);
|
return t;
|
return t;
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|