/* Basic block reordering routines for the GNU compiler.
- Copyright (C) 2000 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
- This file is part of GNU CC.
+ This file is part of GCC.
- GNU CC is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ 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 2, or (at your option)
any later version.
- GNU CC 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.
+ 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 GNU CC; see the file COPYING. If not, write to
- the Free Software Foundation, 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with GCC; see the file COPYING. If not, write to the Free
+ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
+
+/* This (greedy) algorithm constructs traces in several rounds.
+ The construction starts from "seeds". The seed for the first round
+ is the entry point of function. When there are more than one seed
+ that one is selected first that has the lowest key in the heap
+ (see function bb_to_key). Then the algorithm repeatedly adds the most
+ probable successor to the end of a trace. Finally it connects the traces.
+
+ There are two parameters: Branch Threshold and Exec Threshold.
+ If the edge to a successor of the actual basic block is lower than
+ Branch Threshold or the frequency of the successor is lower than
+ Exec Threshold the successor will be the seed in one of the next rounds.
+ Each round has these parameters lower than the previous one.
+ The last round has to have these parameters set to zero
+ so that the remaining blocks are picked up.
+
+ The algorithm selects the most probable successor from all unvisited
+ successors and successors that have been added to this trace.
+ The other successors (that has not been "sent" to the next round) will be
+ other seeds for this round and the secondary traces will start in them.
+ If the successor has not been visited in this trace it is added to the trace
+ (however, there is some heuristic for simple branches).
+ If the successor has been visited in this trace the loop has been found.
+ If the loop has many iterations the loop is rotated so that the
+ source block of the most probable edge going out from the loop
+ is the last block of the trace.
+ If the loop has few iterations and there is no edge from the last block of
+ the loop going out from loop the loop header is duplicated.
+ Finally, the construction of the trace is terminated.
+
+ When connecting traces it first checks whether there is an edge from the
+ last block of one trace to the first block of another trace.
+ When there are still some unconnected traces it checks whether there exists
+ a basic block BB such that BB is a successor of the last bb of one trace
+ and BB is a predecessor of the first block of another trace. In this case,
+ BB is duplicated and the traces are connected through this duplicate.
+ The rest of traces are simply connected so there will be a jump to the
+ beginning of the rest of trace.
+
+
+ References:
+
+ "Software Trace Cache"
+ A. Ramirez, J. Larriba-Pey, C. Navarro, J. Torrellas and M. Valero; 1999
+ http://citeseer.nj.nec.com/15361.html
-/* References:
-
- "Profile Guided Code Positioning"
- Pettis and Hanson; PLDI '90.
*/
#include "config.h"
#include "system.h"
-#include "tree.h"
+#include "coretypes.h"
+#include "tm.h"
#include "rtl.h"
-#include "tm_p.h"
#include "basic-block.h"
-#include "insn-config.h"
-#include "regs.h"
-#include "hard-reg-set.h"
#include "flags.h"
#include "output.h"
-#include "function.h"
-#include "except.h"
-#include "toplev.h"
-#include "recog.h"
-#include "insn-flags.h"
-#include "expr.h"
-#include "obstack.h"
-
+#include "cfglayout.h"
+#include "fibheap.h"
+#include "target.h"
-/* The contents of the current function definition are allocated
- in this obstack, and all are freed at the end of the function.
- For top-level functions, this is temporary_obstack.
- Separate obstacks are made for nested functions. */
+/* The number of rounds. */
+#define N_ROUNDS 4
-extern struct obstack *function_obstack;
+/* Branch thresholds in thousandths (per mille) of the REG_BR_PROB_BASE. */
+static int branch_threshold[N_ROUNDS] = {400, 200, 100, 0};
+/* Exec thresholds in thousandths (per mille) of the frequency of bb 0. */
+static int exec_threshold[N_ROUNDS] = {500, 200, 50, 0};
-typedef struct reorder_block_def {
- int flags;
- int index;
- basic_block add_jump;
- edge succ;
- rtx end;
- int block_begin;
- int block_end;
-} *reorder_block_def;
+/* If edge frequency is lower than DUPLICATION_THRESHOLD per mille of entry
+ block the edge destination is not duplicated while connecting traces. */
+#define DUPLICATION_THRESHOLD 100
-#define REORDER_BLOCK_HEAD 0x1
-#define REORDER_BLOCK_VISITED 0x2
-#define REORDER_MOVED_BLOCK_END 0x3
-
-#define REORDER_BLOCK_FLAGS(bb) \
- ((reorder_block_def) (bb)->aux)->flags
+/* Length of unconditional jump instruction. */
+static int uncond_jump_length;
-#define REORDER_BLOCK_INDEX(bb) \
- ((reorder_block_def) (bb)->aux)->index
+/* Structure to hold needed information for each basic block. */
+typedef struct bbro_basic_block_data_def
+{
+ /* Which trace is the bb start of (-1 means it is not a start of a trace). */
+ int start_of_trace;
-#define REORDER_BLOCK_ADD_JUMP(bb) \
- ((reorder_block_def) (bb)->aux)->add_jump
+ /* Which trace is the bb end of (-1 means it is not an end of a trace). */
+ int end_of_trace;
-#define REORDER_BLOCK_SUCC(bb) \
- ((reorder_block_def) (bb)->aux)->succ
+ /* Which heap is BB in (if any)? */
+ fibheap_t heap;
-#define REORDER_BLOCK_OLD_END(bb) \
- ((reorder_block_def) (bb)->aux)->end
+ /* Which heap node is BB in (if any)? */
+ fibnode_t node;
+} bbro_basic_block_data;
-#define REORDER_BLOCK_BEGIN(bb) \
- ((reorder_block_def) (bb)->aux)->block_begin
+/* The current size of the following dynamic array. */
+static int array_size;
-#define REORDER_BLOCK_END(bb) \
- ((reorder_block_def) (bb)->aux)->block_end
+/* The array which holds needed information for basic blocks. */
+static bbro_basic_block_data *bbd;
+/* To avoid frequent reallocation the size of arrays is greater than needed,
+ the number of elements is (not less than) 1.25 * size_wanted. */
+#define GET_ARRAY_SIZE(X) ((((X) / 4) + 1) * 5)
-static int reorder_index;
-static basic_block reorder_last_visited;
+/* Free the memory and set the pointer to NULL. */
+#define FREE(P) \
+ do { if (P) { free (P); P = 0; } else { abort (); } } while (0)
-enum reorder_skip_type {REORDER_SKIP_BEFORE, REORDER_SKIP_AFTER,
- REORDER_SKIP_BLOCK_END};
+/* Structure for holding information about a trace. */
+struct trace
+{
+ /* First and last basic block of the trace. */
+ basic_block first, last;
+ /* The round of the STC creation which this trace was found in. */
+ int round;
-/* Local function prototypes. */
-static rtx skip_insns_between_block PARAMS ((basic_block,
- enum reorder_skip_type));
-static basic_block get_common_dest PARAMS ((basic_block, basic_block));
-static basic_block chain_reorder_blocks PARAMS ((edge, basic_block));
-static void make_reorder_chain PARAMS ((basic_block));
-static void fixup_reorder_chain PARAMS ((void));
+ /* The length (i.e. the number of basic blocks) of the trace. */
+ int length;
+};
+/* Maximum frequency and count of one of the entry blocks. */
+int max_entry_frequency;
+gcov_type max_entry_count;
-/* Skip over insns BEFORE or AFTER BB which are typically associated with
- basic block BB. */
+/* Local function prototypes. */
+static void find_traces PARAMS ((int *, struct trace *));
+static basic_block rotate_loop PARAMS ((edge, struct trace *, int));
+static void mark_bb_visited PARAMS ((basic_block, int));
+static void find_traces_1_round PARAMS ((int, int, gcov_type,
+ struct trace *, int *, int,
+ fibheap_t *));
+static basic_block copy_bb PARAMS ((basic_block, edge,
+ basic_block, int));
+static fibheapkey_t bb_to_key PARAMS ((basic_block));
+static bool better_edge_p PARAMS ((basic_block, edge, int, int,
+ int, int));
+static void connect_traces PARAMS ((int, struct trace *));
+static bool copy_bb_p PARAMS ((basic_block, int));
+static int get_uncond_jump_length PARAMS ((void));
+\f
+/* Find the traces for Software Trace Cache. Chain each trace through
+ RBI()->next. Store the number of traces to N_TRACES and description of
+ traces to TRACES. */
-static rtx
-skip_insns_between_block (bb, skip_type)
- basic_block bb;
- enum reorder_skip_type skip_type;
+static void
+find_traces (n_traces, traces)
+ int *n_traces;
+ struct trace *traces;
{
- rtx insn, last_insn;
+ int i;
+ edge e;
+ fibheap_t heap;
- if (skip_type == REORDER_SKIP_BEFORE)
+ /* Insert entry points of function into heap. */
+ heap = fibheap_new ();
+ max_entry_frequency = 0;
+ max_entry_count = 0;
+ for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
{
- if (bb == ENTRY_BLOCK_PTR)
- return 0;
-
- last_insn = bb->head;
- for (insn = PREV_INSN (bb->head);
- insn && insn != BASIC_BLOCK (bb->index - 1)->end;
- last_insn = insn, insn = PREV_INSN (insn))
- {
- if (NEXT_INSN (insn) != last_insn)
- break;
-
- if (GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_END
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_END)
- continue;
-
- break;
- }
+ bbd[e->dest->index].heap = heap;
+ bbd[e->dest->index].node = fibheap_insert (heap, bb_to_key (e->dest),
+ e->dest);
+ if (e->dest->frequency > max_entry_frequency)
+ max_entry_frequency = e->dest->frequency;
+ if (e->dest->count > max_entry_count)
+ max_entry_count = e->dest->count;
}
- else
+ /* Find the traces. */
+ for (i = 0; i < N_ROUNDS; i++)
{
- last_insn = bb->end;
+ gcov_type count_threshold;
- if (bb == EXIT_BLOCK_PTR)
- return 0;
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "STC - round %d\n", i + 1);
- for (insn = NEXT_INSN (bb->end);
- insn;
- last_insn = insn, insn = NEXT_INSN (insn))
+ if (max_entry_count < INT_MAX / 1000)
+ count_threshold = max_entry_count * exec_threshold[i] / 1000;
+ else
+ count_threshold = max_entry_count / 1000 * exec_threshold[i];
+
+ find_traces_1_round (REG_BR_PROB_BASE * branch_threshold[i] / 1000,
+ max_entry_frequency * exec_threshold[i] / 1000,
+ count_threshold, traces, n_traces, i, &heap);
+ }
+ fibheap_delete (heap);
+
+ if (rtl_dump_file)
+ {
+ for (i = 0; i < *n_traces; i++)
{
- if (bb->index + 1 != n_basic_blocks
- && insn == BASIC_BLOCK (bb->index + 1)->head)
- break;
+ basic_block bb;
+ fprintf (rtl_dump_file, "Trace %d (round %d): ", i + 1,
+ traces[i].round + 1);
+ for (bb = traces[i].first; bb != traces[i].last; bb = RBI (bb)->next)
+ fprintf (rtl_dump_file, "%d [%d] ", bb->index, bb->frequency);
+ fprintf (rtl_dump_file, "%d [%d]\n", bb->index, bb->frequency);
+ }
+ fflush (rtl_dump_file);
+ }
+}
- if (GET_CODE (insn) == BARRIER
- || GET_CODE (insn) == JUMP_INSN
- || (GET_CODE (insn) == NOTE
- && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
- || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)))
- continue;
+/* Rotate loop whose back edge is BACK_EDGE in the tail of trace TRACE
+ (with sequential number TRACE_N). */
- if (GET_CODE (insn) == CODE_LABEL
- && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
- && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
- || GET_CODE (PATTERN
- (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
+static basic_block
+rotate_loop (back_edge, trace, trace_n)
+ edge back_edge;
+ struct trace *trace;
+ int trace_n;
+{
+ basic_block bb;
+
+ /* Information about the best end (end after rotation) of the loop. */
+ basic_block best_bb = NULL;
+ edge best_edge = NULL;
+ int best_freq = -1;
+ gcov_type best_count = -1;
+ /* The best edge is preferred when its destination is not visited yet
+ or is a start block of some trace. */
+ bool is_preferred = false;
+
+ /* Find the most frequent edge that goes out from current trace. */
+ bb = back_edge->dest;
+ do
+ {
+ edge e;
+ for (e = bb->succ; e; e = e->succ_next)
+ if (e->dest != EXIT_BLOCK_PTR
+ && RBI (e->dest)->visited != trace_n
+ && (e->flags & EDGE_CAN_FALLTHRU)
+ && !(e->flags & EDGE_COMPLEX))
+ {
+ if (is_preferred)
{
- insn = NEXT_INSN (insn);
- continue;
+ /* The best edge is preferred. */
+ if (!RBI (e->dest)->visited
+ || bbd[e->dest->index].start_of_trace >= 0)
+ {
+ /* The current edge E is also preferred. */
+ int freq = EDGE_FREQUENCY (e);
+ if (freq > best_freq || e->count > best_count)
+ {
+ best_freq = freq;
+ best_count = e->count;
+ best_edge = e;
+ best_bb = bb;
+ }
+ }
+ }
+ else
+ {
+ if (!RBI (e->dest)->visited
+ || bbd[e->dest->index].start_of_trace >= 0)
+ {
+ /* The current edge E is preferred. */
+ is_preferred = true;
+ best_freq = EDGE_FREQUENCY (e);
+ best_count = e->count;
+ best_edge = e;
+ best_bb = bb;
+ }
+ else
+ {
+ int freq = EDGE_FREQUENCY (e);
+ if (!best_edge || freq > best_freq || e->count > best_count)
+ {
+ best_freq = freq;
+ best_count = e->count;
+ best_edge = e;
+ best_bb = bb;
+ }
+ }
}
- break;
}
+ bb = RBI (bb)->next;
+ }
+ while (bb != back_edge->dest);
- if (skip_type == REORDER_SKIP_BLOCK_END)
+ if (best_bb)
+ {
+ /* Rotate the loop so that the BEST_EDGE goes out from the last block of
+ the trace. */
+ if (back_edge->dest == trace->first)
+ {
+ trace->first = RBI (best_bb)->next;
+ }
+ else
{
- int found_block_end = 0;
+ basic_block prev_bb;
- for (; insn; last_insn = insn, insn = NEXT_INSN (insn))
+ for (prev_bb = trace->first;
+ RBI (prev_bb)->next != back_edge->dest;
+ prev_bb = RBI (prev_bb)->next)
+ ;
+ RBI (prev_bb)->next = RBI (best_bb)->next;
+
+ /* Try to get rid of uncond jump to cond jump. */
+ if (prev_bb->succ && !prev_bb->succ->succ_next)
{
- if (bb->index + 1 != n_basic_blocks
- && insn == BASIC_BLOCK (bb->index + 1)->head)
- break;
+ basic_block header = prev_bb->succ->dest;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ /* Duplicate HEADER if it is a small block containing cond jump
+ in the end. */
+ if (any_condjump_p (header->end) && copy_bb_p (header, 0))
{
- found_block_end = 1;
- continue;
+ copy_bb (header, prev_bb->succ, prev_bb, trace_n);
}
-
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
- continue;
-
- if (GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) >= 0
- && NEXT_INSN (insn)
- && (NOTE_LINE_NUMBER (NEXT_INSN (insn))
- == NOTE_INSN_BLOCK_END))
- continue;
- break;
}
-
- if (! found_block_end)
- last_insn = 0;
}
}
-
- return last_insn;
+ else
+ {
+ /* We have not found suitable loop tail so do no rotation. */
+ best_bb = back_edge->src;
+ }
+ RBI (best_bb)->next = NULL;
+ return best_bb;
}
+/* This function marks BB that it was visited in trace number TRACE. */
-/* Return common destination for blocks BB0 and BB1. */
+static void
+mark_bb_visited (bb, trace)
+ basic_block bb;
+ int trace;
+{
+ RBI (bb)->visited = trace;
+ if (bbd[bb->index].heap)
+ {
+ fibheap_delete_node (bbd[bb->index].heap, bbd[bb->index].node);
+ bbd[bb->index].heap = NULL;
+ bbd[bb->index].node = NULL;
+ }
+}
-static basic_block
-get_common_dest (bb0, bb1)
- basic_block bb0, bb1;
+/* One round of finding traces. Find traces for BRANCH_TH and EXEC_TH i.e. do
+ not include basic blocks their probability is lower than BRANCH_TH or their
+ frequency is lower than EXEC_TH into traces (or count is lower than
+ COUNT_TH). It stores the new traces into TRACES and modifies the number of
+ traces *N_TRACES. Sets the round (which the trace belongs to) to ROUND. It
+ expects that starting basic blocks are in *HEAP and at the end it deletes
+ *HEAP and stores starting points for the next round into new *HEAP. */
+
+static void
+find_traces_1_round (branch_th, exec_th, count_th, traces, n_traces, round,
+ heap)
+ int branch_th;
+ int exec_th;
+ gcov_type count_th;
+ struct trace *traces;
+ int *n_traces;
+ int round;
+ fibheap_t *heap;
{
- edge e0, e1;
+ /* Heap for discarded basic blocks which are possible starting points for
+ the next round. */
+ fibheap_t new_heap = fibheap_new ();
- for (e0 = bb0->succ; e0; e0 = e0->succ_next)
+ while (!fibheap_empty (*heap))
{
- for (e1 = bb1->succ; e1; e1 = e1->succ_next)
+ basic_block bb;
+ struct trace *trace;
+ edge best_edge, e;
+ fibheapkey_t key;
+
+ bb = fibheap_extract_min (*heap);
+ bbd[bb->index].heap = NULL;
+ bbd[bb->index].node = NULL;
+
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Getting bb %d\n", bb->index);
+
+ /* If the BB's frequency is too low send BB to the next round. */
+ if (bb->frequency < exec_th || bb->count < count_th
+ || ((round < N_ROUNDS - 1) && probably_never_executed_bb_p (bb)))
{
- if (e0->dest == e1->dest)
- {
- return e0->dest;
- }
+ int key = bb_to_key (bb);
+ bbd[bb->index].heap = new_heap;
+ bbd[bb->index].node = fibheap_insert (new_heap, key, bb);
+
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file,
+ " Possible start point of next round: %d (key: %d)\n",
+ bb->index, key);
+ continue;
}
- }
- return 0;
-}
+ trace = traces + *n_traces;
+ trace->first = bb;
+ trace->round = round;
+ trace->length = 0;
+ (*n_traces)++;
-/* Move the destination block for edge E after chain end block CEB
- Adding jumps and labels is deferred until fixup_reorder_chain. */
+ do
+ {
+ int prob, freq;
-static basic_block
-chain_reorder_blocks (e, ceb)
- edge e;
- basic_block ceb;
-{
- basic_block sb = e->src;
- basic_block db = e->dest;
- rtx cebe_insn, cebbe_insn, dbh_insn, dbe_insn;
- edge ee, last_edge;
-
- enum cond_types {NO_COND, PREDICT_THEN_WITH_ELSE, PREDICT_ELSE,
- PREDICT_THEN_NO_ELSE, PREDICT_NOT_THEN_NO_ELSE};
- enum cond_types cond_type;
- enum cond_block_types {NO_COND_BLOCK, THEN_BLOCK, ELSE_BLOCK,
- NO_ELSE_BLOCK};
- enum cond_block_types cond_block_type;
+ /* The probability and frequency of the best edge. */
+ int best_prob = INT_MIN / 2;
+ int best_freq = INT_MIN / 2;
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
- "Edge from basic block %d to basic block %d last visited %d\n",
- sb->index, db->index, ceb->index);
-
- dbh_insn = skip_insns_between_block (db, REORDER_SKIP_BEFORE);
- cebe_insn = skip_insns_between_block (ceb, REORDER_SKIP_AFTER);
- cebbe_insn = skip_insns_between_block (ceb, REORDER_SKIP_BLOCK_END);
-
- {
- int block_begins = 0;
- rtx insn;
-
- for (insn = dbh_insn; insn && insn != db->end; insn = NEXT_INSN (insn))
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
- {
- block_begins += 1;
- break;
- }
- }
- REORDER_BLOCK_BEGIN (sb) = block_begins;
- }
+ best_edge = NULL;
+ mark_bb_visited (bb, *n_traces);
+ trace->length++;
- if (cebbe_insn)
- {
- int block_ends = 0;
- rtx insn;
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Basic block %d was visited in trace %d\n",
+ bb->index, *n_traces - 1);
- for (insn = cebe_insn; insn; insn = NEXT_INSN (insn))
- {
- if (PREV_INSN (insn) == cebbe_insn)
- break;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ /* Select the successor that will be placed after BB. */
+ for (e = bb->succ; e; e = e->succ_next)
{
- block_ends += 1;
- continue;
+ if (e->flags & EDGE_FAKE)
+ abort ();
+
+ if (e->dest == EXIT_BLOCK_PTR)
+ continue;
+
+ if (RBI (e->dest)->visited
+ && RBI (e->dest)->visited != *n_traces)
+ continue;
+
+ prob = e->probability;
+ freq = EDGE_FREQUENCY (e);
+
+ /* Edge that cannot be fallthru or improbable or infrequent
+ successor (ie. it is unsuitable successor). */
+ if (!(e->flags & EDGE_CAN_FALLTHRU) || (e->flags & EDGE_COMPLEX)
+ || prob < branch_th || freq < exec_th || e->count < count_th)
+ continue;
+
+ if (better_edge_p (bb, e, prob, freq, best_prob, best_freq))
+ {
+ best_edge = e;
+ best_prob = prob;
+ best_freq = freq;
+ }
}
- }
- REORDER_BLOCK_END (ceb) = block_ends;
- }
- /* Blocks are in original order. */
- if (sb->index == ceb->index
- && ceb->index + 1 == db->index && NEXT_INSN (cebe_insn))
- return db;
+ /* If the best destination has multiple predecessors, and can be
+ duplicated cheaper than a jump, don't allow it to be added
+ to a trace. We'll duplicate it when connecting traces. */
+ if (best_edge && best_edge->dest->pred->pred_next
+ && copy_bb_p (best_edge->dest, 0))
+ best_edge = NULL;
- /* Get the type of block and type of condition. */
- cond_type = NO_COND;
- cond_block_type = NO_COND_BLOCK;
- if (GET_CODE (sb->end) == JUMP_INSN && ! simplejump_p (sb->end)
- && condjump_p (sb->end))
- {
- if (e->flags & EDGE_FALLTHRU)
- cond_block_type = THEN_BLOCK;
- else if (get_common_dest (sb->succ->dest, sb))
- cond_block_type = NO_ELSE_BLOCK;
- else
- cond_block_type = ELSE_BLOCK;
-
- if (sb->succ->succ_next
- && get_common_dest (sb->succ->dest, sb))
- {
- if (cond_block_type == THEN_BLOCK)
+ /* Add all non-selected successors to the heaps. */
+ for (e = bb->succ; e; e = e->succ_next)
{
- if (! (REORDER_BLOCK_FLAGS (sb->succ->succ_next->dest)
- & REORDER_BLOCK_VISITED))
- cond_type = PREDICT_THEN_NO_ELSE;
+ if (e == best_edge
+ || e->dest == EXIT_BLOCK_PTR
+ || RBI (e->dest)->visited)
+ continue;
+
+ key = bb_to_key (e->dest);
+
+ if (bbd[e->dest->index].heap)
+ {
+ /* E->DEST is already in some heap. */
+ if (key != bbd[e->dest->index].node->key)
+ {
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ "Changing key for bb %d from %ld to %ld.\n",
+ e->dest->index,
+ (long) bbd[e->dest->index].node->key,
+ key);
+ }
+ fibheap_replace_key (bbd[e->dest->index].heap,
+ bbd[e->dest->index].node, key);
+ }
+ }
else
- cond_type = PREDICT_NOT_THEN_NO_ELSE;
+ {
+ fibheap_t which_heap = *heap;
+
+ prob = e->probability;
+ freq = EDGE_FREQUENCY (e);
+
+ if (!(e->flags & EDGE_CAN_FALLTHRU)
+ || (e->flags & EDGE_COMPLEX)
+ || prob < branch_th || freq < exec_th
+ || e->count < count_th)
+ {
+ if (round < N_ROUNDS - 1)
+ which_heap = new_heap;
+ }
+
+ bbd[e->dest->index].heap = which_heap;
+ bbd[e->dest->index].node = fibheap_insert (which_heap,
+ key, e->dest);
+
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ " Possible start of %s round: %d (key: %ld)\n",
+ (which_heap == new_heap) ? "next" : "this",
+ e->dest->index, (long) key);
+ }
+
+ }
}
- else if (cond_block_type == NO_ELSE_BLOCK)
+
+ if (best_edge) /* Suitable successor was found. */
{
- if (! (REORDER_BLOCK_FLAGS (sb->succ->dest)
- & REORDER_BLOCK_VISITED))
- cond_type = PREDICT_NOT_THEN_NO_ELSE;
+ if (RBI (best_edge->dest)->visited == *n_traces)
+ {
+ /* We do nothing with one basic block loops. */
+ if (best_edge->dest != bb)
+ {
+ if (EDGE_FREQUENCY (best_edge)
+ > 4 * best_edge->dest->frequency / 5)
+ {
+ /* The loop has at least 4 iterations. If the loop
+ header is not the first block of the function
+ we can rotate the loop. */
+
+ if (best_edge->dest != ENTRY_BLOCK_PTR->next_bb)
+ {
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ "Rotating loop %d - %d\n",
+ best_edge->dest->index, bb->index);
+ }
+ RBI (bb)->next = best_edge->dest;
+ bb = rotate_loop (best_edge, trace, *n_traces);
+ }
+ }
+ else
+ {
+ /* The loop has less than 4 iterations. */
+
+ /* Check whether there is another edge from BB. */
+ edge another_edge;
+ for (another_edge = bb->succ;
+ another_edge;
+ another_edge = another_edge->succ_next)
+ if (another_edge != best_edge)
+ break;
+
+ if (!another_edge && copy_bb_p (best_edge->dest,
+ !optimize_size))
+ {
+ bb = copy_bb (best_edge->dest, best_edge, bb,
+ *n_traces);
+ }
+ }
+ }
+
+ /* Terminate the trace. */
+ break;
+ }
else
- cond_type = PREDICT_THEN_NO_ELSE;
+ {
+ /* Check for a situation
+
+ A
+ /|
+ B |
+ \|
+ C
+
+ where
+ EDGE_FREQUENCY (AB) + EDGE_FREQUENCY (BC)
+ >= EDGE_FREQUENCY (AC).
+ (i.e. 2 * B->frequency >= EDGE_FREQUENCY (AC) )
+ Best ordering is then A B C.
+
+ This situation is created for example by:
+
+ if (A) B;
+ C;
+
+ */
+
+ for (e = bb->succ; e; e = e->succ_next)
+ if (e != best_edge
+ && (e->flags & EDGE_CAN_FALLTHRU)
+ && !(e->flags & EDGE_COMPLEX)
+ && !RBI (e->dest)->visited
+ && !e->dest->pred->pred_next
+ && e->dest->succ
+ && (e->dest->succ->flags & EDGE_CAN_FALLTHRU)
+ && !(e->dest->succ->flags & EDGE_COMPLEX)
+ && !e->dest->succ->succ_next
+ && e->dest->succ->dest == best_edge->dest
+ && 2 * e->dest->frequency >= EDGE_FREQUENCY (best_edge))
+ {
+ best_edge = e;
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file, "Selecting BB %d\n",
+ best_edge->dest->index);
+ break;
+ }
+
+ RBI (bb)->next = best_edge->dest;
+ bb = best_edge->dest;
+ }
}
}
- else
+ while (best_edge);
+ trace->last = bb;
+ bbd[trace->first->index].start_of_trace = *n_traces - 1;
+ bbd[trace->last->index].end_of_trace = *n_traces - 1;
+
+ /* The trace is terminated so we have to recount the keys in heap
+ (some block can have a lower key because now one of its predecessors
+ is an end of the trace). */
+ for (e = bb->succ; e; e = e->succ_next)
{
- if (cond_block_type == THEN_BLOCK)
- {
- if (! (REORDER_BLOCK_FLAGS (sb->succ->succ_next->dest)
- & REORDER_BLOCK_VISITED))
- cond_type = PREDICT_THEN_WITH_ELSE;
- else
- cond_type = PREDICT_ELSE;
- }
- else if (cond_block_type == ELSE_BLOCK
- && sb->succ->dest != EXIT_BLOCK_PTR)
+ if (e->dest == EXIT_BLOCK_PTR
+ || RBI (e->dest)->visited)
+ continue;
+
+ if (bbd[e->dest->index].heap)
{
- if (! (REORDER_BLOCK_FLAGS (sb->succ->dest)
- & REORDER_BLOCK_VISITED))
- cond_type = PREDICT_ELSE;
- else
- cond_type = PREDICT_THEN_WITH_ELSE;
+ key = bb_to_key (e->dest);
+ if (key != bbd[e->dest->index].node->key)
+ {
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ "Changing key for bb %d from %ld to %ld.\n",
+ e->dest->index,
+ (long) bbd[e->dest->index].node->key, key);
+ }
+ fibheap_replace_key (bbd[e->dest->index].heap,
+ bbd[e->dest->index].node,
+ key);
+ }
}
}
}
-
- if (rtl_dump_file)
- {
- static const char * cond_type_str [] = {"not cond jump", "predict then",
- "predict else",
- "predict then w/o else",
- "predict not then w/o else"};
- static const char * cond_block_type_str [] = {"not then or else block",
- "then block",
- "else block",
- "then w/o else block"};
-
- fprintf (rtl_dump_file, " %s (looking at %s)\n",
- cond_type_str[(int)cond_type],
- cond_block_type_str[(int)cond_block_type]);
- }
- /* Reflect that then block will move and we'll jump to it. */
- if (cond_block_type != THEN_BLOCK
- && (cond_type == PREDICT_ELSE
- || cond_type == PREDICT_NOT_THEN_NO_ELSE))
- {
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
- " then jump from block %d to block %d\n",
- sb->index, sb->succ->dest->index);
+ fibheap_delete (*heap);
- /* Jump to reordered then block. */
- REORDER_BLOCK_ADD_JUMP (sb) = sb->succ->dest;
- }
-
- /* Reflect that then block will jump back when we have no else. */
- if (cond_block_type != THEN_BLOCK
- && cond_type == PREDICT_NOT_THEN_NO_ELSE)
- {
- for (ee = sb->succ->dest->succ;
- ee && ! (ee->flags & EDGE_FALLTHRU);
- ee = ee->succ_next)
- continue;
+ /* "Return" the new heap. */
+ *heap = new_heap;
+}
- if (ee && ! (GET_CODE (sb->succ->dest->end) == JUMP_INSN
- && ! simplejump_p (sb->succ->dest->end)))
- {
- REORDER_BLOCK_ADD_JUMP (sb->succ->dest) = ee->dest;
- }
- }
+/* Create a duplicate of the basic block OLD_BB and redirect edge E to it, add
+ it to trace after BB, mark OLD_BB visited and update pass' data structures
+ (TRACE is a number of trace which OLD_BB is duplicated to). */
- /* Reflect that else block will jump back. */
- if (cond_block_type == ELSE_BLOCK
- && (cond_type == PREDICT_THEN_WITH_ELSE || cond_type == PREDICT_ELSE))
+static basic_block
+copy_bb (old_bb, e, bb, trace)
+ basic_block old_bb;
+ edge e;
+ basic_block bb;
+ int trace;
+{
+ basic_block new_bb;
+
+ new_bb = cfg_layout_duplicate_bb (old_bb, e);
+ if (e->dest != new_bb)
+ abort ();
+ if (RBI (e->dest)->visited)
+ abort ();
+ if (rtl_dump_file)
+ fprintf (rtl_dump_file,
+ "Duplicated bb %d (created bb %d)\n",
+ old_bb->index, new_bb->index);
+ RBI (new_bb)->visited = trace;
+ RBI (new_bb)->next = RBI (bb)->next;
+ RBI (bb)->next = new_bb;
+
+ if (new_bb->index >= array_size || last_basic_block > array_size)
{
- last_edge=db->succ;
+ int i;
+ int new_size;
- if (last_edge
- && last_edge->dest != EXIT_BLOCK_PTR
- && GET_CODE (last_edge->dest->head) == CODE_LABEL
- && ! (GET_CODE (db->end) == JUMP_INSN))
+ new_size = MAX (last_basic_block, new_bb->index + 1);
+ new_size = GET_ARRAY_SIZE (new_size);
+ bbd = xrealloc (bbd, new_size * sizeof (bbro_basic_block_data));
+ for (i = array_size; i < new_size; i++)
{
- if (rtl_dump_file)
- fprintf (rtl_dump_file,
- " else jump from block %d to block %d\n",
- db->index, last_edge->dest->index);
-
- REORDER_BLOCK_ADD_JUMP (db) = last_edge->dest;
+ bbd[i].start_of_trace = -1;
+ bbd[i].end_of_trace = -1;
+ bbd[i].heap = NULL;
+ bbd[i].node = NULL;
}
- }
+ array_size = new_size;
- /* This block's successor has already been reordered. This can happen
- when we reorder a chain starting at a then or else. */
- for (last_edge = db->succ;
- last_edge && ! (last_edge->flags & EDGE_FALLTHRU);
- last_edge = last_edge->succ_next)
- continue;
-
- if (last_edge
- && last_edge->dest != EXIT_BLOCK_PTR
- && (REORDER_BLOCK_FLAGS (last_edge->dest)
- & REORDER_BLOCK_VISITED))
- {
if (rtl_dump_file)
- fprintf (rtl_dump_file,
- " end of chain jump from block %d to block %d\n",
- db->index, last_edge->dest->index);
-
- REORDER_BLOCK_ADD_JUMP (db) = last_edge->dest;
- }
-
- dbh_insn = skip_insns_between_block (db, REORDER_SKIP_BEFORE);
- cebe_insn = skip_insns_between_block (ceb, REORDER_SKIP_AFTER);
- dbe_insn = skip_insns_between_block (db, REORDER_SKIP_AFTER);
-
- /* Leave behind any lexical block markers. */
- if (debug_info_level > DINFO_LEVEL_TERSE
- && ceb->index + 1 < db->index)
- {
- rtx insn, last_insn = get_last_insn ();
- insn = NEXT_INSN (ceb->end);
- if (! insn)
- insn = REORDER_BLOCK_OLD_END (ceb);
-
- if (NEXT_INSN (cebe_insn) == 0)
- set_last_insn (cebe_insn);
- for (; insn && insn != db->head/*dbh_insn*/;
- insn = NEXT_INSN (insn))
{
- if (GET_CODE (insn) == NOTE
- && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG))
- {
- cebe_insn = emit_note_after (NOTE_INSN_BLOCK_BEG, cebe_insn);
- delete_insn (insn);
- }
- if (GET_CODE (insn) == NOTE
- && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
- {
- cebe_insn = emit_note_after (NOTE_INSN_BLOCK_END, cebe_insn);
- delete_insn (insn);
- }
+ fprintf (rtl_dump_file,
+ "Growing the dynamic array to %d elements.\n",
+ array_size);
}
- set_last_insn (last_insn);
}
- /* Rechain predicted block. */
- NEXT_INSN (cebe_insn) = dbh_insn;
- PREV_INSN (dbh_insn) = cebe_insn;
-
- REORDER_BLOCK_OLD_END (db) = NEXT_INSN (dbe_insn);
- if (db->index != n_basic_blocks - 1)
- NEXT_INSN (dbe_insn) = 0;
-
- return db;
+ return new_bb;
}
+/* Compute and return the key (for the heap) of the basic block BB. */
-/* Reorder blocks starting at block B. */
-
-static void
-make_reorder_chain (bb)
+static fibheapkey_t
+bb_to_key (bb)
basic_block bb;
{
edge e;
- basic_block visited_edge = NULL;
- rtx block_end;
- int probability;
- if (bb == EXIT_BLOCK_PTR)
- return;
+ int priority = 0;
- /* Find the most probable block. */
- e = bb->succ;
- block_end = bb->end;
- if (GET_CODE (block_end) == JUMP_INSN && condjump_p (block_end))
- {
- rtx note = find_reg_note (block_end, REG_BR_PROB, 0);
+ /* Do not start in probably never executed blocks. */
+ if (probably_never_executed_bb_p (bb))
+ return BB_FREQ_MAX;
- if (note)
- probability = XINT (XEXP (note, 0), 0);
- else
- probability = 0;
-
- if (probability >= REG_BR_PROB_BASE / 2)
- e = bb->succ->succ_next;
- }
-
- /* Add chosen successor to chain and recurse on it. */
- if (e && e->dest != EXIT_BLOCK_PTR
- && e->dest != e->src
- && (! (REORDER_BLOCK_FLAGS (e->dest) & REORDER_BLOCK_VISITED)
- || (REORDER_BLOCK_FLAGS (e->dest) == REORDER_BLOCK_HEAD)))
+ /* Prefer blocks whose predecessor is an end of some trace
+ or whose predecessor edge is EDGE_DFS_BACK. */
+ for (e = bb->pred; e; e = e->pred_next)
{
- if (! (REORDER_BLOCK_FLAGS (bb) & REORDER_BLOCK_VISITED))
+ if ((e->src != ENTRY_BLOCK_PTR && bbd[e->src->index].end_of_trace >= 0)
+ || (e->flags & EDGE_DFS_BACK))
{
- REORDER_BLOCK_FLAGS (bb) |= REORDER_BLOCK_HEAD;
- REORDER_BLOCK_INDEX (bb) = reorder_index++;
- REORDER_BLOCK_FLAGS (bb) |= REORDER_BLOCK_VISITED;
- }
+ int edge_freq = EDGE_FREQUENCY (e);
- if (REORDER_BLOCK_FLAGS (e->dest) & REORDER_BLOCK_VISITED)
- REORDER_BLOCK_FLAGS (e->dest) &= ~REORDER_BLOCK_HEAD;
-
- REORDER_BLOCK_SUCC (bb) = e;
+ if (edge_freq > priority)
+ priority = edge_freq;
+ }
+ }
- visited_edge = e->dest;
+ if (priority)
+ /* The block with priority should have significantly lower key. */
+ return -(100 * BB_FREQ_MAX + 100 * priority + bb->frequency);
+ return -bb->frequency;
+}
- reorder_last_visited = chain_reorder_blocks (e, bb);
+/* Return true when the edge E from basic block BB is better than the temporary
+ best edge (details are in function). The probability of edge E is PROB. The
+ frequency of the successor is FREQ. The current best probability is
+ BEST_PROB, the best frequency is BEST_FREQ.
+ The edge is considered to be equivalent when PROB does not differ much from
+ BEST_PROB; similarly for frequency. */
- if (e->dest
- && ! (REORDER_BLOCK_FLAGS (e->dest)
- & REORDER_BLOCK_VISITED))
- make_reorder_chain (e->dest);
- }
+static bool
+better_edge_p (bb, e, prob, freq, best_prob, best_freq)
+ basic_block bb;
+ edge e;
+ int prob;
+ int freq;
+ int best_prob;
+ int best_freq;
+{
+ bool is_better_edge;
+
+ /* The BEST_* values do not have to be best, but can be a bit smaller than
+ maximum values. */
+ int diff_prob = best_prob / 10;
+ int diff_freq = best_freq / 10;
+
+ if (prob > best_prob + diff_prob)
+ /* The edge has higher probability than the temporary best edge. */
+ is_better_edge = true;
+ else if (prob < best_prob - diff_prob)
+ /* The edge has lower probability than the temporary best edge. */
+ is_better_edge = false;
+ else if (freq < best_freq - diff_freq)
+ /* The edge and the temporary best edge have almost equivalent
+ probabilities. The higher frequency of a successor now means
+ that there is another edge going into that successor.
+ This successor has lower frequency so it is better. */
+ is_better_edge = true;
+ else if (freq > best_freq + diff_freq)
+ /* This successor has higher frequency so it is worse. */
+ is_better_edge = false;
+ else if (e->dest->prev_bb == bb)
+ /* The edges have equivalent probabilities and the successors
+ have equivalent frequencies. Select the previous successor. */
+ is_better_edge = true;
else
- {
- if (! (REORDER_BLOCK_FLAGS (bb) & REORDER_BLOCK_VISITED))
- {
- REORDER_BLOCK_INDEX (bb) = reorder_index++;
- REORDER_BLOCK_FLAGS (bb) |= REORDER_BLOCK_VISITED;
- }
- }
+ is_better_edge = false;
- /* Recurse on the successors. */
- for (e = bb->succ; e; e = e->succ_next)
- {
- if (e->dest && e->dest == EXIT_BLOCK_PTR)
- continue;
-
- if (e->dest
- && e->dest != e->src
- && e->dest != visited_edge
- && ! (REORDER_BLOCK_FLAGS (e->dest)
- & REORDER_BLOCK_VISITED))
- {
- reorder_last_visited
- = chain_reorder_blocks (e, reorder_last_visited);
- make_reorder_chain (e->dest);
- }
- }
+ return is_better_edge;
}
-
-/* Fixup jumps and labels after reordering basic blocks. */
+/* Connect traces in array TRACES, N_TRACES is the count of traces. */
static void
-fixup_reorder_chain ()
+connect_traces (n_traces, traces)
+ int n_traces;
+ struct trace *traces;
{
- int i, j;
- rtx insn;
+ int i;
+ bool *connected;
+ int last_trace;
+ int freq_threshold;
+ gcov_type count_threshold;
+
+ freq_threshold = max_entry_frequency * DUPLICATION_THRESHOLD / 1000;
+ if (max_entry_count < INT_MAX / 1000)
+ count_threshold = max_entry_count * DUPLICATION_THRESHOLD / 1000;
+ else
+ count_threshold = max_entry_count / 1000 * DUPLICATION_THRESHOLD;
- /* Set the new last insn. */
- for (i = 0;
- i < n_basic_blocks - 1
- && REORDER_BLOCK_INDEX (BASIC_BLOCK (i)) != n_basic_blocks;
- i++)
- continue;
+ connected = xcalloc (n_traces, sizeof (bool));
+ last_trace = -1;
+ for (i = 0; i < n_traces; i++)
+ {
+ int t = i;
+ int t2;
+ edge e, best;
+ int best_len;
- for (insn = BASIC_BLOCK (i)->head;
- NEXT_INSN (insn) != 0;
- insn = NEXT_INSN (insn))
- continue;
+ if (connected[t])
+ continue;
- set_last_insn (insn);
+ connected[t] = true;
- /* Add jumps and labels to fixup blocks. */
- for (i = 0; i < n_basic_blocks - 1; i++)
- {
- basic_block bbi = BASIC_BLOCK (i);
- if (REORDER_BLOCK_ADD_JUMP (bbi))
+ /* Find the predecessor traces. */
+ for (t2 = t; t2 > 0;)
{
- rtx label_insn, jump_insn, barrier_insn;
-
- if (GET_CODE (REORDER_BLOCK_ADD_JUMP (bbi)->head)
- == CODE_LABEL)
- label_insn = REORDER_BLOCK_ADD_JUMP (bbi)->head;
+ best = NULL;
+ best_len = 0;
+ for (e = traces[t2].first->pred; e; e = e->pred_next)
+ {
+ int si = e->src->index;
+
+ if (e->src != ENTRY_BLOCK_PTR
+ && (e->flags & EDGE_CAN_FALLTHRU)
+ && !(e->flags & EDGE_COMPLEX)
+ && bbd[si].end_of_trace >= 0
+ && !connected[bbd[si].end_of_trace]
+ && (!best
+ || e->probability > best->probability
+ || (e->probability == best->probability
+ && traces[bbd[si].end_of_trace].length > best_len)))
+ {
+ best = e;
+ best_len = traces[bbd[si].end_of_trace].length;
+ }
+ }
+ if (best)
+ {
+ RBI (best->src)->next = best->dest;
+ t2 = bbd[best->src->index].end_of_trace;
+ connected[t2] = true;
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file, "Connection: %d %d\n",
+ best->src->index, best->dest->index);
+ }
+ }
else
+ break;
+ }
+
+ if (last_trace >= 0)
+ RBI (traces[last_trace].last)->next = traces[t2].first;
+ last_trace = t;
+
+ /* Find the successor traces. */
+ while (1)
+ {
+ /* Find the continuation of the chain. */
+ best = NULL;
+ best_len = 0;
+ for (e = traces[t].last->succ; e; e = e->succ_next)
{
- rtx new_label = gen_label_rtx ();
- label_insn = emit_label_before (new_label,
- REORDER_BLOCK_ADD_JUMP (bbi)->head);
+ int di = e->dest->index;
+
+ if (e->dest != EXIT_BLOCK_PTR
+ && (e->flags & EDGE_CAN_FALLTHRU)
+ && !(e->flags & EDGE_COMPLEX)
+ && bbd[di].start_of_trace >= 0
+ && !connected[bbd[di].start_of_trace]
+ && (!best
+ || e->probability > best->probability
+ || (e->probability == best->probability
+ && traces[bbd[di].start_of_trace].length > best_len)))
+ {
+ best = e;
+ best_len = traces[bbd[di].start_of_trace].length;
+ }
}
- REORDER_BLOCK_ADD_JUMP (bbi)->head = label_insn;
-
- jump_insn = emit_jump_insn_after (gen_jump (label_insn),
- bbi->end);
- JUMP_LABEL (jump_insn) = label_insn;
- ++LABEL_NUSES (label_insn);
- barrier_insn = emit_barrier_after (jump_insn);
- if (GET_CODE (bbi->end) != JUMP_INSN)
- bbi->end = jump_insn;
- /* Add block for jump. Typically this is when a then is not
- predicted and we are jumping to the moved then block. */
- else
+
+ if (best)
{
- basic_block nb;
-
- VARRAY_GROW (basic_block_info, ++n_basic_blocks);
- create_basic_block (n_basic_blocks - 1, jump_insn,
- jump_insn, NULL);
- nb = BASIC_BLOCK (n_basic_blocks - 1);
- nb->global_live_at_start
- = OBSTACK_ALLOC_REG_SET (function_obstack);
- nb->global_live_at_end
- = OBSTACK_ALLOC_REG_SET (function_obstack);
-
- COPY_REG_SET (nb->global_live_at_start,
- bbi->global_live_at_start);
- COPY_REG_SET (nb->global_live_at_end,
- bbi->global_live_at_start);
- BASIC_BLOCK (nb->index)->local_set = 0;
-
- nb->aux = xcalloc (1, sizeof (struct reorder_block_def));
- REORDER_BLOCK_INDEX (BASIC_BLOCK (n_basic_blocks - 1))
- = REORDER_BLOCK_INDEX (bbi) + 1;
- /* Relink to new block. */
- nb->succ = bbi->succ;
- nb->succ->src = nb;
-
- make_edge (NULL, bbi, nb, 0);
- bbi->succ->succ_next
- = bbi->succ->succ_next->succ_next;
- nb->succ->succ_next = 0;
- /* Fix reorder block index to reflect new block. */
- for (j = 0; j < n_basic_blocks - 1; j++)
+ if (rtl_dump_file)
{
- basic_block bbj = BASIC_BLOCK (j);
- if (REORDER_BLOCK_INDEX (bbj)
- >= REORDER_BLOCK_INDEX (bbi) + 1)
- REORDER_BLOCK_INDEX (bbj)++;
+ fprintf (rtl_dump_file, "Connection: %d %d\n",
+ best->src->index, best->dest->index);
}
+ t = bbd[best->dest->index].start_of_trace;
+ RBI (traces[last_trace].last)->next = traces[t].first;
+ connected[t] = true;
+ last_trace = t;
+ }
+ else
+ {
+ /* Try to connect the traces by duplication of 1 block. */
+ edge e2;
+ basic_block next_bb = NULL;
+ bool try_copy = false;
+
+ for (e = traces[t].last->succ; e; e = e->succ_next)
+ if (e->dest != EXIT_BLOCK_PTR
+ && (e->flags & EDGE_CAN_FALLTHRU)
+ && !(e->flags & EDGE_COMPLEX)
+ && (!best || e->probability > best->probability))
+ {
+ edge best2 = NULL;
+ int best2_len = 0;
+
+ /* If the destination is a start of a trace which is only
+ one block long, then no need to search the successor
+ blocks of the trace. Accept it. */
+ if (bbd[e->dest->index].start_of_trace >= 0
+ && traces[bbd[e->dest->index].start_of_trace].length
+ == 1)
+ {
+ best = e;
+ try_copy = true;
+ continue;
+ }
+
+ for (e2 = e->dest->succ; e2; e2 = e2->succ_next)
+ {
+ int di = e2->dest->index;
+
+ if (e2->dest == EXIT_BLOCK_PTR
+ || ((e2->flags & EDGE_CAN_FALLTHRU)
+ && !(e2->flags & EDGE_COMPLEX)
+ && bbd[di].start_of_trace >= 0
+ && !connected[bbd[di].start_of_trace]
+ && (EDGE_FREQUENCY (e2) >= freq_threshold)
+ && (e2->count >= count_threshold)
+ && (!best2
+ || e2->probability > best2->probability
+ || (e2->probability == best2->probability
+ && traces[bbd[di].start_of_trace].length
+ > best2_len))))
+ {
+ best = e;
+ best2 = e2;
+ if (e2->dest != EXIT_BLOCK_PTR)
+ best2_len = traces[bbd[di].start_of_trace].length;
+ else
+ best2_len = INT_MAX;
+ next_bb = e2->dest;
+ try_copy = true;
+ }
+ }
+ }
+
+ /* Copy tiny blocks always; copy larger blocks only when the
+ edge is traversed frequently enough. */
+ if (try_copy
+ && copy_bb_p (best->dest,
+ !optimize_size
+ && EDGE_FREQUENCY (best) >= freq_threshold
+ && best->count >= count_threshold))
+ {
+ basic_block new_bb;
+
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file, "Connection: %d %d ",
+ traces[t].last->index, best->dest->index);
+ if (!next_bb)
+ fputc ('\n', rtl_dump_file);
+ else if (next_bb == EXIT_BLOCK_PTR)
+ fprintf (rtl_dump_file, "exit\n");
+ else
+ fprintf (rtl_dump_file, "%d\n", next_bb->index);
+ }
+
+ new_bb = copy_bb (best->dest, best, traces[t].last, t);
+ traces[t].last = new_bb;
+ if (next_bb && next_bb != EXIT_BLOCK_PTR)
+ {
+ t = bbd[next_bb->index].start_of_trace;
+ RBI (traces[last_trace].last)->next = traces[t].first;
+ connected[t] = true;
+ last_trace = t;
+ }
+ else
+ break; /* Stop finding the successor traces. */
+ }
+ else
+ break; /* Stop finding the successor traces. */
}
}
}
-}
+ if (rtl_dump_file)
+ {
+ basic_block bb;
-/* Reorder basic blocks. */
+ fprintf (rtl_dump_file, "Final order:\n");
+ for (bb = traces[0].first; bb; bb = RBI (bb)->next)
+ fprintf (rtl_dump_file, "%d ", bb->index);
+ fprintf (rtl_dump_file, "\n");
+ fflush (rtl_dump_file);
+ }
-void
-reorder_basic_blocks ()
+ FREE (connected);
+}
+
+/* Return true when BB can and should be copied. CODE_MAY_GROW is true
+ when code size is allowed to grow by duplication. */
+
+static bool
+copy_bb_p (bb, code_may_grow)
+ basic_block bb;
+ int code_may_grow;
{
- int i, j;
- struct loops loops_info;
- int num_loops;
- rtx last_insn;
+ int size = 0;
+ int max_size = uncond_jump_length;
+ rtx insn;
- if (profile_arc_flag)
- return;
+ if (!bb->frequency)
+ return false;
+ if (!bb->pred || !bb->pred->pred_next)
+ return false;
+ if (!cfg_layout_can_duplicate_bb_p (bb))
+ return false;
- if (n_basic_blocks <= 1)
- return;
+ if (code_may_grow && maybe_hot_bb_p (bb))
+ max_size *= 8;
- /* Exception edges are not currently handled. */
- for (i = 0; i < n_basic_blocks; i++)
+ for (insn = bb->head; insn != NEXT_INSN (bb->end);
+ insn = NEXT_INSN (insn))
{
- edge e;
+ if (INSN_P (insn))
+ size += get_attr_length (insn);
+ }
- for (e = BASIC_BLOCK (i)->succ; e && ! (e->flags & EDGE_EH);
- e = e->succ_next)
- continue;
+ if (size <= max_size)
+ return true;
- if (e && (e->flags & EDGE_EH))
- return;
+ if (rtl_dump_file)
+ {
+ fprintf (rtl_dump_file,
+ "Block %d can't be copied because its size = %d.\n",
+ bb->index, size);
}
- reorder_index = 0;
+ return false;
+}
- /* Find natural loops using the CFG. */
- num_loops = flow_loops_find (&loops_info);
+/* Return the length of unconditional jump instruction. */
- /* Dump loop information. */
- flow_loops_dump (&loops_info, rtl_dump_file, 0);
+static int
+get_uncond_jump_length ()
+{
+ rtx label, jump;
+ int length;
- /* Estimate using heuristics if no profiling info is available. */
- if (! flag_branch_probabilities)
- estimate_probability (&loops_info);
+ label = emit_label_before (gen_label_rtx (), get_insns ());
+ jump = emit_jump_insn (gen_jump (label));
- reorder_last_visited = BASIC_BLOCK (0);
+ length = get_attr_length (jump);
- for (i = 0; i < n_basic_blocks; i++)
- BASIC_BLOCK (i)->aux = xcalloc (1, sizeof (struct reorder_block_def));
-
- last_insn
- = NEXT_INSN (skip_insns_between_block (BASIC_BLOCK (n_basic_blocks - 1),
- REORDER_SKIP_AFTER));
+ delete_insn (jump);
+ delete_insn (label);
+ return length;
+}
- make_reorder_chain (BASIC_BLOCK (0));
+/* Reorder basic blocks. The main entry point to this file. */
- fixup_reorder_chain ();
+void
+reorder_basic_blocks ()
+{
+ int n_traces;
+ int i;
+ struct trace *traces;
-#ifdef ENABLE_CHECKING
- {
- rtx insn, last_insn;
- last_insn = get_insns ();
- for (insn = NEXT_INSN (get_insns ());
- insn && PREV_INSN (insn) == last_insn
- && NEXT_INSN (PREV_INSN (insn)) == insn;
- last_insn = insn,
- insn = NEXT_INSN (insn))
- continue;
+ if (n_basic_blocks <= 1)
+ return;
- if (insn)
- {
- if (rtl_dump_file)
- fprintf (rtl_dump_file, "insn chaining error at %d\n",
- INSN_UID (last_insn));
- abort();
- }
- }
-#endif
+ if ((* targetm.cannot_modify_jumps_p) ())
+ return;
- /* Put basic_block_info in new order. */
- for (i = 0; i < n_basic_blocks - 1; i++)
- {
- for (j = i; i != REORDER_BLOCK_INDEX (BASIC_BLOCK (j)); j++)
- continue;
+ cfg_layout_initialize (NULL);
- if (REORDER_BLOCK_INDEX (BASIC_BLOCK (j)) == i
- && i != j)
- {
- basic_block tempbb;
- int temprbi;
- int rbi = REORDER_BLOCK_INDEX (BASIC_BLOCK (j));
-
- temprbi = BASIC_BLOCK (rbi)->index;
- BASIC_BLOCK (rbi)->index = BASIC_BLOCK (j)->index;
- BASIC_BLOCK (j)->index = temprbi;
- tempbb = BASIC_BLOCK (rbi);
- BASIC_BLOCK (rbi) = BASIC_BLOCK (j);
- BASIC_BLOCK (j) = tempbb;
- }
- }
-
+ set_edge_can_fallthru_flag ();
+ mark_dfs_back_edges ();
+
+ /* We are estimating the lenght of uncond jump insn only once since the code
+ for getting the insn lenght always returns the minimal length now. */
+ if (uncond_jump_length == 0)
+ uncond_jump_length = get_uncond_jump_length ();
+
+ /* We need to know some information for each basic block. */
+ array_size = GET_ARRAY_SIZE (last_basic_block);
+ bbd = xmalloc (array_size * sizeof (bbro_basic_block_data));
+ for (i = 0; i < array_size; i++)
{
- rtx xafter = skip_insns_between_block (BASIC_BLOCK (n_basic_blocks - 1),
- REORDER_SKIP_AFTER);
- if (xafter)
- NEXT_INSN (xafter) = last_insn;
- else
- abort();
+ bbd[i].start_of_trace = -1;
+ bbd[i].end_of_trace = -1;
+ bbd[i].heap = NULL;
+ bbd[i].node = NULL;
}
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ traces = xmalloc (n_basic_blocks * sizeof (struct trace));
+ n_traces = 0;
+ find_traces (&n_traces, traces);
+ connect_traces (n_traces, traces);
+ FREE (traces);
+ FREE (bbd);
- for (i = 0; i < n_basic_blocks; i++)
- free (BASIC_BLOCK (i)->aux);
+ if (rtl_dump_file)
+ dump_flow_info (rtl_dump_file);
- /* Free loop information. */
- flow_loops_free (&loops_info);
+ cfg_layout_finalize ();
}
-