annotate gcc/mode-switching.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1 /* CPU mode switching
16
kono
parents: 14
diff changeset
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
3
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
4 This file is part of GCC.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
5
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
6 GCC is free software; you can redistribute it and/or modify it under
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
7 the terms of the GNU General Public License as published by the Free
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
8 Software Foundation; either version 3, or (at your option) any later
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
9 version.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
10
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
14 for more details.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
15
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
16 You should have received a copy of the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
17 along with GCC; see the file COPYING3. If not see
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
18 <http://www.gnu.org/licenses/>. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
19
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
20 #include "config.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
21 #include "system.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
22 #include "coretypes.h"
16
kono
parents: 14
diff changeset
23 #include "backend.h"
11
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 9
diff changeset
24 #include "target.h"
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
25 #include "rtl.h"
16
kono
parents: 14
diff changeset
26 #include "cfghooks.h"
kono
parents: 14
diff changeset
27 #include "df.h"
kono
parents: 14
diff changeset
28 #include "memmodel.h"
kono
parents: 14
diff changeset
29 #include "tm_p.h"
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
30 #include "regs.h"
16
kono
parents: 14
diff changeset
31 #include "emit-rtl.h"
kono
parents: 14
diff changeset
32 #include "cfgrtl.h"
kono
parents: 14
diff changeset
33 #include "cfganal.h"
kono
parents: 14
diff changeset
34 #include "lcm.h"
kono
parents: 14
diff changeset
35 #include "cfgcleanup.h"
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
36 #include "tree-pass.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
37
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
38 /* We want target macros for the mode switching code to be able to refer
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
39 to instruction attribute values. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
40 #include "insn-attr.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
41
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
42 #ifdef OPTIMIZE_MODE_SWITCHING
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
43
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
44 /* The algorithm for setting the modes consists of scanning the insn list
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
45 and finding all the insns which require a specific mode. Each insn gets
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
46 a unique struct seginfo element. These structures are inserted into a list
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
47 for each basic block. For each entity, there is an array of bb_info over
16
kono
parents: 14
diff changeset
48 the flow graph basic blocks (local var 'bb_info'), which contains a list
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
49 of all insns within that basic block, in the order they are encountered.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
50
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
51 For each entity, any basic block WITHOUT any insns requiring a specific
16
kono
parents: 14
diff changeset
52 mode are given a single entry without a mode (each basic block in the
kono
parents: 14
diff changeset
53 flow graph must have at least one entry in the segment table).
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
54
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
55 The LCM algorithm is then run over the flow graph to determine where to
16
kono
parents: 14
diff changeset
56 place the sets to the highest-priority mode with respect to the first
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
57 insn in any one block. Any adjustments required to the transparency
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
58 vectors are made, then the next iteration starts for the next-lower
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
59 priority mode, till for each entity all modes are exhausted.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
60
16
kono
parents: 14
diff changeset
61 More details can be found in the code of optimize_mode_switching. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
62
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
63 /* This structure contains the information for each insn which requires
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
64 either single or double mode to be set.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
65 MODE is the mode this insn must be executed in.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
66 INSN_PTR is the insn to be executed (may be the note that marks the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
67 beginning of a basic block).
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
68 BBNUM is the flow graph basic block this insn occurs in.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
69 NEXT is the next insn in the same basic block. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
70 struct seginfo
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
71 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
72 int mode;
16
kono
parents: 14
diff changeset
73 rtx_insn *insn_ptr;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
74 int bbnum;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
75 struct seginfo *next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
76 HARD_REG_SET regs_live;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
77 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
78
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
79 struct bb_info
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
80 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
81 struct seginfo *seginfo;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
82 int computing;
16
kono
parents: 14
diff changeset
83 int mode_out;
kono
parents: 14
diff changeset
84 int mode_in;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
85 };
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
86
16
kono
parents: 14
diff changeset
87 static struct seginfo * new_seginfo (int, rtx_insn *, int, HARD_REG_SET);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
88 static void add_seginfo (struct bb_info *, struct seginfo *);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
89 static void reg_dies (rtx, HARD_REG_SET *);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
90 static void reg_becomes_live (rtx, const_rtx, void *);
16
kono
parents: 14
diff changeset
91
kono
parents: 14
diff changeset
92 /* Clear ode I from entity J in bitmap B. */
kono
parents: 14
diff changeset
93 #define clear_mode_bit(b, j, i) \
kono
parents: 14
diff changeset
94 bitmap_clear_bit (b, (j * max_num_modes) + i)
kono
parents: 14
diff changeset
95
kono
parents: 14
diff changeset
96 /* Test mode I from entity J in bitmap B. */
kono
parents: 14
diff changeset
97 #define mode_bit_p(b, j, i) \
kono
parents: 14
diff changeset
98 bitmap_bit_p (b, (j * max_num_modes) + i)
kono
parents: 14
diff changeset
99
kono
parents: 14
diff changeset
100 /* Set mode I from entity J in bitmal B. */
kono
parents: 14
diff changeset
101 #define set_mode_bit(b, j, i) \
kono
parents: 14
diff changeset
102 bitmap_set_bit (b, (j * max_num_modes) + i)
kono
parents: 14
diff changeset
103
kono
parents: 14
diff changeset
104 /* Emit modes segments from EDGE_LIST associated with entity E.
kono
parents: 14
diff changeset
105 INFO gives mode availability for each mode. */
kono
parents: 14
diff changeset
106
kono
parents: 14
diff changeset
107 static bool
kono
parents: 14
diff changeset
108 commit_mode_sets (struct edge_list *edge_list, int e, struct bb_info *info)
kono
parents: 14
diff changeset
109 {
kono
parents: 14
diff changeset
110 bool need_commit = false;
kono
parents: 14
diff changeset
111
kono
parents: 14
diff changeset
112 for (int ed = NUM_EDGES (edge_list) - 1; ed >= 0; ed--)
kono
parents: 14
diff changeset
113 {
kono
parents: 14
diff changeset
114 edge eg = INDEX_EDGE (edge_list, ed);
kono
parents: 14
diff changeset
115 int mode;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
116
16
kono
parents: 14
diff changeset
117 if ((mode = (int)(intptr_t)(eg->aux)) != -1)
kono
parents: 14
diff changeset
118 {
kono
parents: 14
diff changeset
119 HARD_REG_SET live_at_edge;
kono
parents: 14
diff changeset
120 basic_block src_bb = eg->src;
kono
parents: 14
diff changeset
121 int cur_mode = info[src_bb->index].mode_out;
kono
parents: 14
diff changeset
122 rtx_insn *mode_set;
kono
parents: 14
diff changeset
123
kono
parents: 14
diff changeset
124 REG_SET_TO_HARD_REG_SET (live_at_edge, df_get_live_out (src_bb));
kono
parents: 14
diff changeset
125
kono
parents: 14
diff changeset
126 rtl_profile_for_edge (eg);
kono
parents: 14
diff changeset
127 start_sequence ();
kono
parents: 14
diff changeset
128
kono
parents: 14
diff changeset
129 targetm.mode_switching.emit (e, mode, cur_mode, live_at_edge);
kono
parents: 14
diff changeset
130
kono
parents: 14
diff changeset
131 mode_set = get_insns ();
kono
parents: 14
diff changeset
132 end_sequence ();
kono
parents: 14
diff changeset
133 default_rtl_profile ();
kono
parents: 14
diff changeset
134
kono
parents: 14
diff changeset
135 /* Do not bother to insert empty sequence. */
kono
parents: 14
diff changeset
136 if (mode_set == NULL)
kono
parents: 14
diff changeset
137 continue;
kono
parents: 14
diff changeset
138
kono
parents: 14
diff changeset
139 /* We should not get an abnormal edge here. */
kono
parents: 14
diff changeset
140 gcc_assert (! (eg->flags & EDGE_ABNORMAL));
kono
parents: 14
diff changeset
141
kono
parents: 14
diff changeset
142 need_commit = true;
kono
parents: 14
diff changeset
143 insert_insn_on_edge (mode_set, eg);
kono
parents: 14
diff changeset
144 }
kono
parents: 14
diff changeset
145 }
kono
parents: 14
diff changeset
146
kono
parents: 14
diff changeset
147 return need_commit;
kono
parents: 14
diff changeset
148 }
kono
parents: 14
diff changeset
149
kono
parents: 14
diff changeset
150 /* Allocate a new BBINFO structure, initialized with the MODE, INSN,
kono
parents: 14
diff changeset
151 and basic block BB parameters.
kono
parents: 14
diff changeset
152 INSN may not be a NOTE_INSN_BASIC_BLOCK, unless it is an empty
kono
parents: 14
diff changeset
153 basic block; that allows us later to insert instructions in a FIFO-like
kono
parents: 14
diff changeset
154 manner. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
155
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
156 static struct seginfo *
16
kono
parents: 14
diff changeset
157 new_seginfo (int mode, rtx_insn *insn, int bb, HARD_REG_SET regs_live)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
158 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
159 struct seginfo *ptr;
16
kono
parents: 14
diff changeset
160
kono
parents: 14
diff changeset
161 gcc_assert (!NOTE_INSN_BASIC_BLOCK_P (insn)
kono
parents: 14
diff changeset
162 || insn == BB_END (NOTE_BASIC_BLOCK (insn)));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
163 ptr = XNEW (struct seginfo);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
164 ptr->mode = mode;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
165 ptr->insn_ptr = insn;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
166 ptr->bbnum = bb;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
167 ptr->next = NULL;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
168 COPY_HARD_REG_SET (ptr->regs_live, regs_live);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
169 return ptr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
170 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
171
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
172 /* Add a seginfo element to the end of a list.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
173 HEAD is a pointer to the list beginning.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
174 INFO is the structure to be linked in. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
175
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
176 static void
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
177 add_seginfo (struct bb_info *head, struct seginfo *info)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
178 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
179 struct seginfo *ptr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
180
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
181 if (head->seginfo == NULL)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
182 head->seginfo = info;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
183 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
184 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
185 ptr = head->seginfo;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
186 while (ptr->next != NULL)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
187 ptr = ptr->next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
188 ptr->next = info;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
189 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
190 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
191
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
192 /* Record in LIVE that register REG died. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
193
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
194 static void
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
195 reg_dies (rtx reg, HARD_REG_SET *live)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
196 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
197 int regno;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
198
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
199 if (!REG_P (reg))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
200 return;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
201
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
202 regno = REGNO (reg);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
203 if (regno < FIRST_PSEUDO_REGISTER)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
204 remove_from_hard_reg_set (live, GET_MODE (reg), regno);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
205 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
206
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
207 /* Record in LIVE that register REG became live.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
208 This is called via note_stores. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
209
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
210 static void
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
211 reg_becomes_live (rtx reg, const_rtx setter ATTRIBUTE_UNUSED, void *live)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
212 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
213 int regno;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
214
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
215 if (GET_CODE (reg) == SUBREG)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
216 reg = SUBREG_REG (reg);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
217
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
218 if (!REG_P (reg))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
219 return;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
220
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
221 regno = REGNO (reg);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
222 if (regno < FIRST_PSEUDO_REGISTER)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
223 add_to_hard_reg_set ((HARD_REG_SET *) live, GET_MODE (reg), regno);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
224 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
225
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
226 /* Split the fallthrough edge to the exit block, so that we can note
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
227 that there NORMAL_MODE is required. Return the new block if it's
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
228 inserted before the exit block. Otherwise return null. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
229
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
230 static basic_block
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
231 create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
232 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
233 edge eg;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
234 edge_iterator ei;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
235 basic_block pre_exit;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
236
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
237 /* The only non-call predecessor at this stage is a block with a
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
238 fallthrough edge; there can be at most one, but there could be
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
239 none at all, e.g. when exit is called. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
240 pre_exit = 0;
16
kono
parents: 14
diff changeset
241 FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
242 if (eg->flags & EDGE_FALLTHRU)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
243 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
244 basic_block src_bb = eg->src;
16
kono
parents: 14
diff changeset
245 rtx_insn *last_insn;
kono
parents: 14
diff changeset
246 rtx ret_reg;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
247
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
248 gcc_assert (!pre_exit);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
249 /* If this function returns a value at the end, we have to
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
250 insert the final mode switch before the return value copy
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
251 to its hard register. */
16
kono
parents: 14
diff changeset
252 if (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 1
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
253 && NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
254 && GET_CODE (PATTERN (last_insn)) == USE
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
255 && GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
256 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
257 int ret_start = REGNO (ret_reg);
16
kono
parents: 14
diff changeset
258 int nregs = REG_NREGS (ret_reg);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
259 int ret_end = ret_start + nregs;
16
kono
parents: 14
diff changeset
260 bool short_block = false;
kono
parents: 14
diff changeset
261 bool multi_reg_return = false;
kono
parents: 14
diff changeset
262 bool forced_late_switch = false;
kono
parents: 14
diff changeset
263 rtx_insn *before_return_copy;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
264
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
265 do
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
266 {
16
kono
parents: 14
diff changeset
267 rtx_insn *return_copy = PREV_INSN (last_insn);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
268 rtx return_copy_pat, copy_reg;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
269 int copy_start, copy_num;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
270 int j;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
271
16
kono
parents: 14
diff changeset
272 if (NONDEBUG_INSN_P (return_copy))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
273 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
274 /* When using SJLJ exceptions, the call to the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
275 unregister function is inserted between the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
276 clobber of the return value and the copy.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
277 We do not want to split the block before this
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
278 or any other call; if we have not found the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
279 copy yet, the copy must have been deleted. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
280 if (CALL_P (return_copy))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
281 {
16
kono
parents: 14
diff changeset
282 short_block = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
283 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
284 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
285 return_copy_pat = PATTERN (return_copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
286 switch (GET_CODE (return_copy_pat))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
287 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
288 case USE:
16
kono
parents: 14
diff changeset
289 /* Skip USEs of multiple return registers.
kono
parents: 14
diff changeset
290 __builtin_apply pattern is also handled here. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
291 if (GET_CODE (XEXP (return_copy_pat, 0)) == REG
11
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 9
diff changeset
292 && (targetm.calls.function_value_regno_p
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
293 (REGNO (XEXP (return_copy_pat, 0)))))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
294 {
16
kono
parents: 14
diff changeset
295 multi_reg_return = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
296 last_insn = return_copy;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
297 continue;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
298 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
299 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
300
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
301 case ASM_OPERANDS:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
302 /* Skip barrier insns. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
303 if (!MEM_VOLATILE_P (return_copy_pat))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
304 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
305
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
306 /* Fall through. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
307
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
308 case ASM_INPUT:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
309 case UNSPEC_VOLATILE:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
310 last_insn = return_copy;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
311 continue;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
312
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
313 default:
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
314 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
315 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
316
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
317 /* If the return register is not (in its entirety)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
318 likely spilled, the return copy might be
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
319 partially or completely optimized away. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
320 return_copy_pat = single_set (return_copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
321 if (!return_copy_pat)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
322 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
323 return_copy_pat = PATTERN (return_copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
324 if (GET_CODE (return_copy_pat) != CLOBBER)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
325 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
326 else if (!optimize)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
327 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
328 /* This might be (clobber (reg [<result>]))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
329 when not optimizing. Then check if
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
330 the previous insn is the clobber for
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
331 the return register. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
332 copy_reg = SET_DEST (return_copy_pat);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
333 if (GET_CODE (copy_reg) == REG
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
334 && !HARD_REGISTER_NUM_P (REGNO (copy_reg)))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
335 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
336 if (INSN_P (PREV_INSN (return_copy)))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
337 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
338 return_copy = PREV_INSN (return_copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
339 return_copy_pat = PATTERN (return_copy);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
340 if (GET_CODE (return_copy_pat) != CLOBBER)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
341 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
342 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
343 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
344 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
345 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
346 copy_reg = SET_DEST (return_copy_pat);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
347 if (GET_CODE (copy_reg) == REG)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
348 copy_start = REGNO (copy_reg);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
349 else if (GET_CODE (copy_reg) == SUBREG
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
350 && GET_CODE (SUBREG_REG (copy_reg)) == REG)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
351 copy_start = REGNO (SUBREG_REG (copy_reg));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
352 else
16
kono
parents: 14
diff changeset
353 {
kono
parents: 14
diff changeset
354 /* When control reaches end of non-void function,
kono
parents: 14
diff changeset
355 there are no return copy insns at all. This
kono
parents: 14
diff changeset
356 avoids an ice on that invalid function. */
kono
parents: 14
diff changeset
357 if (ret_start + nregs == ret_end)
kono
parents: 14
diff changeset
358 short_block = true;
kono
parents: 14
diff changeset
359 break;
kono
parents: 14
diff changeset
360 }
kono
parents: 14
diff changeset
361 if (!targetm.calls.function_value_regno_p (copy_start))
kono
parents: 14
diff changeset
362 copy_num = 0;
kono
parents: 14
diff changeset
363 else
kono
parents: 14
diff changeset
364 copy_num = hard_regno_nregs (copy_start,
kono
parents: 14
diff changeset
365 GET_MODE (copy_reg));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
366
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
367 /* If the return register is not likely spilled, - as is
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
368 the case for floating point on SH4 - then it might
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
369 be set by an arithmetic operation that needs a
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
370 different mode than the exit block. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
371 for (j = n_entities - 1; j >= 0; j--)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
372 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
373 int e = entity_map[j];
16
kono
parents: 14
diff changeset
374 int mode =
kono
parents: 14
diff changeset
375 targetm.mode_switching.needed (e, return_copy);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
376
16
kono
parents: 14
diff changeset
377 if (mode != num_modes[e]
kono
parents: 14
diff changeset
378 && mode != targetm.mode_switching.exit (e))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
379 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
380 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
381 if (j >= 0)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
382 {
16
kono
parents: 14
diff changeset
383 /* __builtin_return emits a sequence of loads to all
kono
parents: 14
diff changeset
384 return registers. One of them might require
kono
parents: 14
diff changeset
385 another mode than MODE_EXIT, even if it is
kono
parents: 14
diff changeset
386 unrelated to the return value, so we want to put
kono
parents: 14
diff changeset
387 the final mode switch after it. */
kono
parents: 14
diff changeset
388 if (multi_reg_return
kono
parents: 14
diff changeset
389 && targetm.calls.function_value_regno_p
kono
parents: 14
diff changeset
390 (copy_start))
kono
parents: 14
diff changeset
391 forced_late_switch = true;
kono
parents: 14
diff changeset
392
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
393 /* For the SH4, floating point loads depend on fpscr,
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
394 thus we might need to put the final mode switch
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
395 after the return value copy. That is still OK,
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
396 because a floating point return value does not
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
397 conflict with address reloads. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
398 if (copy_start >= ret_start
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
399 && copy_start + copy_num <= ret_end
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
400 && OBJECT_P (SET_SRC (return_copy_pat)))
16
kono
parents: 14
diff changeset
401 forced_late_switch = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
402 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
403 }
16
kono
parents: 14
diff changeset
404 if (copy_num == 0)
kono
parents: 14
diff changeset
405 {
kono
parents: 14
diff changeset
406 last_insn = return_copy;
kono
parents: 14
diff changeset
407 continue;
kono
parents: 14
diff changeset
408 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
409
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
410 if (copy_start >= ret_start
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
411 && copy_start + copy_num <= ret_end)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
412 nregs -= copy_num;
16
kono
parents: 14
diff changeset
413 else if (!multi_reg_return
11
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 9
diff changeset
414 || !targetm.calls.function_value_regno_p
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 9
diff changeset
415 (copy_start))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
416 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
417 last_insn = return_copy;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
418 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
419 /* ??? Exception handling can lead to the return value
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
420 copy being already separated from the return value use,
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
421 as in unwind-dw2.c .
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
422 Similarly, conditionally returning without a value,
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
423 and conditionally using builtin_return can lead to an
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
424 isolated use. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
425 if (return_copy == BB_HEAD (src_bb))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
426 {
16
kono
parents: 14
diff changeset
427 short_block = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
428 break;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
429 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
430 last_insn = return_copy;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
431 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
432 while (nregs);
9
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
433
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
434 /* If we didn't see a full return value copy, verify that there
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
435 is a plausible reason for this. If some, but not all of the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
436 return register is likely spilled, we can expect that there
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
437 is a copy for the likely spilled part. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
438 gcc_assert (!nregs
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
439 || forced_late_switch
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
440 || short_block
14
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 11
diff changeset
441 || !(targetm.class_likely_spilled_p
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
442 (REGNO_REG_CLASS (ret_start)))
16
kono
parents: 14
diff changeset
443 || nregs != REG_NREGS (ret_reg)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
444 /* For multi-hard-register floating point
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
445 values, sometimes the likely-spilled part
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
446 is ordinarily copied first, then the other
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
447 part is set with an arithmetic operation.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
448 This doesn't actually cause reload
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
449 failures, so let it pass. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
450 || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
451 && nregs != 1));
9
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
452
16
kono
parents: 14
diff changeset
453 if (!NOTE_INSN_BASIC_BLOCK_P (last_insn))
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
454 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
455 before_return_copy
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
456 = emit_note_before (NOTE_INSN_DELETED, last_insn);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
457 /* Instructions preceding LAST_INSN in the same block might
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
458 require a different mode than MODE_EXIT, so if we might
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
459 have such instructions, keep them in a separate block
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
460 from pre_exit. */
16
kono
parents: 14
diff changeset
461 src_bb = split_block (src_bb,
kono
parents: 14
diff changeset
462 PREV_INSN (before_return_copy))->dest;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
463 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
464 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
465 before_return_copy = last_insn;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
466 pre_exit = split_block (src_bb, before_return_copy)->src;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
467 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
468 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
469 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
470 pre_exit = split_edge (eg);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
471 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
472 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
473
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
474 return pre_exit;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
475 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
476
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
477 /* Find all insns that need a particular mode setting, and insert the
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
478 necessary mode switches. Return true if we did work. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
479
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
480 static int
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
481 optimize_mode_switching (void)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
482 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
483 int e;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
484 basic_block bb;
16
kono
parents: 14
diff changeset
485 bool need_commit = false;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
486 static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
487 #define N_ENTITIES ARRAY_SIZE (num_modes)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
488 int entity_map[N_ENTITIES];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
489 struct bb_info *bb_info[N_ENTITIES];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
490 int i, j;
16
kono
parents: 14
diff changeset
491 int n_entities = 0;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
492 int max_num_modes = 0;
16
kono
parents: 14
diff changeset
493 bool emitted ATTRIBUTE_UNUSED = false;
kono
parents: 14
diff changeset
494 basic_block post_entry = 0;
kono
parents: 14
diff changeset
495 basic_block pre_exit = 0;
kono
parents: 14
diff changeset
496 struct edge_list *edge_list = 0;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
497
16
kono
parents: 14
diff changeset
498 /* These bitmaps are used for the LCM algorithm. */
kono
parents: 14
diff changeset
499 sbitmap *kill, *del, *insert, *antic, *transp, *comp;
kono
parents: 14
diff changeset
500 sbitmap *avin, *avout;
kono
parents: 14
diff changeset
501
kono
parents: 14
diff changeset
502 for (e = N_ENTITIES - 1; e >= 0; e--)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
503 if (OPTIMIZE_MODE_SWITCHING (e))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
504 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
505 int entry_exit_extra = 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
506
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
507 /* Create the list of segments within each basic block.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
508 If NORMAL_MODE is defined, allow for two extra
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
509 blocks split from the entry and exit block. */
16
kono
parents: 14
diff changeset
510 if (targetm.mode_switching.entry && targetm.mode_switching.exit)
kono
parents: 14
diff changeset
511 entry_exit_extra = 3;
kono
parents: 14
diff changeset
512
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
513 bb_info[n_entities]
16
kono
parents: 14
diff changeset
514 = XCNEWVEC (struct bb_info,
kono
parents: 14
diff changeset
515 last_basic_block_for_fn (cfun) + entry_exit_extra);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
516 entity_map[n_entities++] = e;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
517 if (num_modes[e] > max_num_modes)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
518 max_num_modes = num_modes[e];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
519 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
520
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
521 if (! n_entities)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
522 return 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
523
16
kono
parents: 14
diff changeset
524 /* Make sure if MODE_ENTRY is defined MODE_EXIT is defined. */
kono
parents: 14
diff changeset
525 gcc_assert ((targetm.mode_switching.entry && targetm.mode_switching.exit)
kono
parents: 14
diff changeset
526 || (!targetm.mode_switching.entry
kono
parents: 14
diff changeset
527 && !targetm.mode_switching.exit));
kono
parents: 14
diff changeset
528
kono
parents: 14
diff changeset
529 if (targetm.mode_switching.entry && targetm.mode_switching.exit)
kono
parents: 14
diff changeset
530 {
kono
parents: 14
diff changeset
531 /* Split the edge from the entry block, so that we can note that
kono
parents: 14
diff changeset
532 there NORMAL_MODE is supplied. */
kono
parents: 14
diff changeset
533 post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
kono
parents: 14
diff changeset
534 pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
kono
parents: 14
diff changeset
535 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
536
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
537 df_analyze ();
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
538
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
539 /* Create the bitmap vectors. */
16
kono
parents: 14
diff changeset
540 antic = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
541 n_entities * max_num_modes);
kono
parents: 14
diff changeset
542 transp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
543 n_entities * max_num_modes);
kono
parents: 14
diff changeset
544 comp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
545 n_entities * max_num_modes);
kono
parents: 14
diff changeset
546 avin = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
547 n_entities * max_num_modes);
kono
parents: 14
diff changeset
548 avout = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
549 n_entities * max_num_modes);
kono
parents: 14
diff changeset
550 kill = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
kono
parents: 14
diff changeset
551 n_entities * max_num_modes);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
552
16
kono
parents: 14
diff changeset
553 bitmap_vector_ones (transp, last_basic_block_for_fn (cfun));
kono
parents: 14
diff changeset
554 bitmap_vector_clear (antic, last_basic_block_for_fn (cfun));
kono
parents: 14
diff changeset
555 bitmap_vector_clear (comp, last_basic_block_for_fn (cfun));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
556
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
557 for (j = n_entities - 1; j >= 0; j--)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
558 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
559 int e = entity_map[j];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
560 int no_mode = num_modes[e];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
561 struct bb_info *info = bb_info[j];
16
kono
parents: 14
diff changeset
562 rtx_insn *insn;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
563
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
564 /* Determine what the first use (if any) need for a mode of entity E is.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
565 This will be the mode that is anticipatable for this block.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
566 Also compute the initial transparency settings. */
16
kono
parents: 14
diff changeset
567 FOR_EACH_BB_FN (bb, cfun)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
568 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
569 struct seginfo *ptr;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
570 int last_mode = no_mode;
16
kono
parents: 14
diff changeset
571 bool any_set_required = false;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
572 HARD_REG_SET live_now;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
573
16
kono
parents: 14
diff changeset
574 info[bb->index].mode_out = info[bb->index].mode_in = no_mode;
kono
parents: 14
diff changeset
575
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
576 REG_SET_TO_HARD_REG_SET (live_now, df_get_live_in (bb));
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
577
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
578 /* Pretend the mode is clobbered across abnormal edges. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
579 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
580 edge_iterator ei;
16
kono
parents: 14
diff changeset
581 edge eg;
kono
parents: 14
diff changeset
582 FOR_EACH_EDGE (eg, ei, bb->preds)
kono
parents: 14
diff changeset
583 if (eg->flags & EDGE_COMPLEX)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
584 break;
16
kono
parents: 14
diff changeset
585 if (eg)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
586 {
16
kono
parents: 14
diff changeset
587 rtx_insn *ins_pos = BB_HEAD (bb);
kono
parents: 14
diff changeset
588 if (LABEL_P (ins_pos))
kono
parents: 14
diff changeset
589 ins_pos = NEXT_INSN (ins_pos);
kono
parents: 14
diff changeset
590 gcc_assert (NOTE_INSN_BASIC_BLOCK_P (ins_pos));
kono
parents: 14
diff changeset
591 if (ins_pos != BB_END (bb))
kono
parents: 14
diff changeset
592 ins_pos = NEXT_INSN (ins_pos);
kono
parents: 14
diff changeset
593 ptr = new_seginfo (no_mode, ins_pos, bb->index, live_now);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
594 add_seginfo (info + bb->index, ptr);
16
kono
parents: 14
diff changeset
595 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
596 clear_mode_bit (transp[bb->index], j, i);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
597 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
598 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
599
14
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 11
diff changeset
600 FOR_BB_INSNS (bb, insn)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
601 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
602 if (INSN_P (insn))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
603 {
16
kono
parents: 14
diff changeset
604 int mode = targetm.mode_switching.needed (e, insn);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
605 rtx link;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
606
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
607 if (mode != no_mode && mode != last_mode)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
608 {
16
kono
parents: 14
diff changeset
609 any_set_required = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
610 last_mode = mode;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
611 ptr = new_seginfo (mode, insn, bb->index, live_now);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
612 add_seginfo (info + bb->index, ptr);
16
kono
parents: 14
diff changeset
613 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
614 clear_mode_bit (transp[bb->index], j, i);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
615 }
16
kono
parents: 14
diff changeset
616
kono
parents: 14
diff changeset
617 if (targetm.mode_switching.after)
kono
parents: 14
diff changeset
618 last_mode = targetm.mode_switching.after (e, last_mode,
kono
parents: 14
diff changeset
619 insn);
kono
parents: 14
diff changeset
620
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
621 /* Update LIVE_NOW. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
622 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
623 if (REG_NOTE_KIND (link) == REG_DEAD)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
624 reg_dies (XEXP (link, 0), &live_now);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
625
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
626 note_stores (PATTERN (insn), reg_becomes_live, &live_now);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
627 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
628 if (REG_NOTE_KIND (link) == REG_UNUSED)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
629 reg_dies (XEXP (link, 0), &live_now);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
630 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
631 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
632
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
633 info[bb->index].computing = last_mode;
16
kono
parents: 14
diff changeset
634 /* Check for blocks without ANY mode requirements.
kono
parents: 14
diff changeset
635 N.B. because of MODE_AFTER, last_mode might still
kono
parents: 14
diff changeset
636 be different from no_mode, in which case we need to
kono
parents: 14
diff changeset
637 mark the block as nontransparent. */
kono
parents: 14
diff changeset
638 if (!any_set_required)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
639 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
640 ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
641 add_seginfo (info + bb->index, ptr);
16
kono
parents: 14
diff changeset
642 if (last_mode != no_mode)
kono
parents: 14
diff changeset
643 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
644 clear_mode_bit (transp[bb->index], j, i);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
645 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
646 }
16
kono
parents: 14
diff changeset
647 if (targetm.mode_switching.entry && targetm.mode_switching.exit)
kono
parents: 14
diff changeset
648 {
kono
parents: 14
diff changeset
649 int mode = targetm.mode_switching.entry (e);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
650
16
kono
parents: 14
diff changeset
651 info[post_entry->index].mode_out =
kono
parents: 14
diff changeset
652 info[post_entry->index].mode_in = no_mode;
kono
parents: 14
diff changeset
653 if (pre_exit)
kono
parents: 14
diff changeset
654 {
kono
parents: 14
diff changeset
655 info[pre_exit->index].mode_out =
kono
parents: 14
diff changeset
656 info[pre_exit->index].mode_in = no_mode;
kono
parents: 14
diff changeset
657 }
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
658
16
kono
parents: 14
diff changeset
659 if (mode != no_mode)
kono
parents: 14
diff changeset
660 {
kono
parents: 14
diff changeset
661 bb = post_entry;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
662
16
kono
parents: 14
diff changeset
663 /* By always making this nontransparent, we save
kono
parents: 14
diff changeset
664 an extra check in make_preds_opaque. We also
kono
parents: 14
diff changeset
665 need this to avoid confusing pre_edge_lcm when
kono
parents: 14
diff changeset
666 antic is cleared but transp and comp are set. */
kono
parents: 14
diff changeset
667 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
668 clear_mode_bit (transp[bb->index], j, i);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
669
16
kono
parents: 14
diff changeset
670 /* Insert a fake computing definition of MODE into entry
kono
parents: 14
diff changeset
671 blocks which compute no mode. This represents the mode on
kono
parents: 14
diff changeset
672 entry. */
kono
parents: 14
diff changeset
673 info[bb->index].computing = mode;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
674
16
kono
parents: 14
diff changeset
675 if (pre_exit)
kono
parents: 14
diff changeset
676 info[pre_exit->index].seginfo->mode =
kono
parents: 14
diff changeset
677 targetm.mode_switching.exit (e);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
678 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
679 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
680
16
kono
parents: 14
diff changeset
681 /* Set the anticipatable and computing arrays. */
kono
parents: 14
diff changeset
682 for (i = 0; i < no_mode; i++)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
683 {
16
kono
parents: 14
diff changeset
684 int m = targetm.mode_switching.priority (entity_map[j], i);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
685
16
kono
parents: 14
diff changeset
686 FOR_EACH_BB_FN (bb, cfun)
kono
parents: 14
diff changeset
687 {
kono
parents: 14
diff changeset
688 if (info[bb->index].seginfo->mode == m)
kono
parents: 14
diff changeset
689 set_mode_bit (antic[bb->index], j, m);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
690
16
kono
parents: 14
diff changeset
691 if (info[bb->index].computing == m)
kono
parents: 14
diff changeset
692 set_mode_bit (comp[bb->index], j, m);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
693 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
694 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
695 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
696
16
kono
parents: 14
diff changeset
697 /* Calculate the optimal locations for the
kono
parents: 14
diff changeset
698 placement mode switches to modes with priority I. */
kono
parents: 14
diff changeset
699
kono
parents: 14
diff changeset
700 FOR_EACH_BB_FN (bb, cfun)
kono
parents: 14
diff changeset
701 bitmap_not (kill[bb->index], transp[bb->index]);
kono
parents: 14
diff changeset
702
kono
parents: 14
diff changeset
703 edge_list = pre_edge_lcm_avs (n_entities * max_num_modes, transp, comp, antic,
kono
parents: 14
diff changeset
704 kill, avin, avout, &insert, &del);
kono
parents: 14
diff changeset
705
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
706 for (j = n_entities - 1; j >= 0; j--)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
707 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
708 int no_mode = num_modes[entity_map[j]];
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
709
16
kono
parents: 14
diff changeset
710 /* Insert all mode sets that have been inserted by lcm. */
kono
parents: 14
diff changeset
711
kono
parents: 14
diff changeset
712 for (int ed = NUM_EDGES (edge_list) - 1; ed >= 0; ed--)
kono
parents: 14
diff changeset
713 {
kono
parents: 14
diff changeset
714 edge eg = INDEX_EDGE (edge_list, ed);
kono
parents: 14
diff changeset
715
kono
parents: 14
diff changeset
716 eg->aux = (void *)(intptr_t)-1;
kono
parents: 14
diff changeset
717
kono
parents: 14
diff changeset
718 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
719 {
kono
parents: 14
diff changeset
720 int m = targetm.mode_switching.priority (entity_map[j], i);
kono
parents: 14
diff changeset
721 if (mode_bit_p (insert[ed], j, m))
kono
parents: 14
diff changeset
722 {
kono
parents: 14
diff changeset
723 eg->aux = (void *)(intptr_t)m;
kono
parents: 14
diff changeset
724 break;
kono
parents: 14
diff changeset
725 }
kono
parents: 14
diff changeset
726 }
kono
parents: 14
diff changeset
727 }
kono
parents: 14
diff changeset
728
kono
parents: 14
diff changeset
729 FOR_EACH_BB_FN (bb, cfun)
kono
parents: 14
diff changeset
730 {
kono
parents: 14
diff changeset
731 struct bb_info *info = bb_info[j];
kono
parents: 14
diff changeset
732 int last_mode = no_mode;
kono
parents: 14
diff changeset
733
kono
parents: 14
diff changeset
734 /* intialize mode in availability for bb. */
kono
parents: 14
diff changeset
735 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
736 if (mode_bit_p (avout[bb->index], j, i))
kono
parents: 14
diff changeset
737 {
kono
parents: 14
diff changeset
738 if (last_mode == no_mode)
kono
parents: 14
diff changeset
739 last_mode = i;
kono
parents: 14
diff changeset
740 if (last_mode != i)
kono
parents: 14
diff changeset
741 {
kono
parents: 14
diff changeset
742 last_mode = no_mode;
kono
parents: 14
diff changeset
743 break;
kono
parents: 14
diff changeset
744 }
kono
parents: 14
diff changeset
745 }
kono
parents: 14
diff changeset
746 info[bb->index].mode_out = last_mode;
kono
parents: 14
diff changeset
747
kono
parents: 14
diff changeset
748 /* intialize mode out availability for bb. */
kono
parents: 14
diff changeset
749 last_mode = no_mode;
kono
parents: 14
diff changeset
750 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
751 if (mode_bit_p (avin[bb->index], j, i))
kono
parents: 14
diff changeset
752 {
kono
parents: 14
diff changeset
753 if (last_mode == no_mode)
kono
parents: 14
diff changeset
754 last_mode = i;
kono
parents: 14
diff changeset
755 if (last_mode != i)
kono
parents: 14
diff changeset
756 {
kono
parents: 14
diff changeset
757 last_mode = no_mode;
kono
parents: 14
diff changeset
758 break;
kono
parents: 14
diff changeset
759 }
kono
parents: 14
diff changeset
760 }
kono
parents: 14
diff changeset
761 info[bb->index].mode_in = last_mode;
kono
parents: 14
diff changeset
762
kono
parents: 14
diff changeset
763 for (i = 0; i < no_mode; i++)
kono
parents: 14
diff changeset
764 if (mode_bit_p (del[bb->index], j, i))
kono
parents: 14
diff changeset
765 info[bb->index].seginfo->mode = no_mode;
kono
parents: 14
diff changeset
766 }
kono
parents: 14
diff changeset
767
kono
parents: 14
diff changeset
768 /* Now output the remaining mode sets in all the segments. */
kono
parents: 14
diff changeset
769
kono
parents: 14
diff changeset
770 /* In case there was no mode inserted. the mode information on the edge
kono
parents: 14
diff changeset
771 might not be complete.
kono
parents: 14
diff changeset
772 Update mode info on edges and commit pending mode sets. */
kono
parents: 14
diff changeset
773 need_commit |= commit_mode_sets (edge_list, entity_map[j], bb_info[j]);
kono
parents: 14
diff changeset
774
kono
parents: 14
diff changeset
775 /* Reset modes for next entity. */
kono
parents: 14
diff changeset
776 clear_aux_for_edges ();
kono
parents: 14
diff changeset
777
kono
parents: 14
diff changeset
778 FOR_EACH_BB_FN (bb, cfun)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
779 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
780 struct seginfo *ptr, *next;
16
kono
parents: 14
diff changeset
781 int cur_mode = bb_info[j][bb->index].mode_in;
kono
parents: 14
diff changeset
782
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
783 for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
784 {
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
785 next = ptr->next;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
786 if (ptr->mode != no_mode)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
787 {
16
kono
parents: 14
diff changeset
788 rtx_insn *mode_set;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
789
16
kono
parents: 14
diff changeset
790 rtl_profile_for_bb (bb);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
791 start_sequence ();
16
kono
parents: 14
diff changeset
792
kono
parents: 14
diff changeset
793 targetm.mode_switching.emit (entity_map[j], ptr->mode,
kono
parents: 14
diff changeset
794 cur_mode, ptr->regs_live);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
795 mode_set = get_insns ();
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
796 end_sequence ();
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
797
16
kono
parents: 14
diff changeset
798 /* modes kill each other inside a basic block. */
kono
parents: 14
diff changeset
799 cur_mode = ptr->mode;
kono
parents: 14
diff changeset
800
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
801 /* Insert MODE_SET only if it is nonempty. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
802 if (mode_set != NULL_RTX)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
803 {
16
kono
parents: 14
diff changeset
804 emitted = true;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
805 if (NOTE_INSN_BASIC_BLOCK_P (ptr->insn_ptr))
16
kono
parents: 14
diff changeset
806 /* We need to emit the insns in a FIFO-like manner,
kono
parents: 14
diff changeset
807 i.e. the first to be emitted at our insertion
kono
parents: 14
diff changeset
808 point ends up first in the instruction steam.
kono
parents: 14
diff changeset
809 Because we made sure that NOTE_INSN_BASIC_BLOCK is
kono
parents: 14
diff changeset
810 only used for initially empty basic blocks, we
kono
parents: 14
diff changeset
811 can achieve this by appending at the end of
kono
parents: 14
diff changeset
812 the block. */
kono
parents: 14
diff changeset
813 emit_insn_after
kono
parents: 14
diff changeset
814 (mode_set, BB_END (NOTE_BASIC_BLOCK (ptr->insn_ptr)));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
815 else
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
816 emit_insn_before (mode_set, ptr->insn_ptr);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
817 }
16
kono
parents: 14
diff changeset
818
kono
parents: 14
diff changeset
819 default_rtl_profile ();
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
820 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
821
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
822 free (ptr);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
823 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
824 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
825
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
826 free (bb_info[j]);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
827 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
828
16
kono
parents: 14
diff changeset
829 free_edge_list (edge_list);
kono
parents: 14
diff changeset
830
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
831 /* Finished. Free up all the things we've allocated. */
16
kono
parents: 14
diff changeset
832 sbitmap_vector_free (del);
kono
parents: 14
diff changeset
833 sbitmap_vector_free (insert);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
834 sbitmap_vector_free (kill);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
835 sbitmap_vector_free (antic);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
836 sbitmap_vector_free (transp);
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
837 sbitmap_vector_free (comp);
16
kono
parents: 14
diff changeset
838 sbitmap_vector_free (avin);
kono
parents: 14
diff changeset
839 sbitmap_vector_free (avout);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
840
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
841 if (need_commit)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
842 commit_edge_insertions ();
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
843
16
kono
parents: 14
diff changeset
844 if (targetm.mode_switching.entry && targetm.mode_switching.exit)
kono
parents: 14
diff changeset
845 cleanup_cfg (CLEANUP_NO_INSN_DEL);
kono
parents: 14
diff changeset
846 else if (!need_commit && !emitted)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
847 return 0;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
848
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
849 return 1;
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
850 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
851
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
852 #endif /* OPTIMIZE_MODE_SWITCHING */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
853
16
kono
parents: 14
diff changeset
854 namespace {
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
855
16
kono
parents: 14
diff changeset
856 const pass_data pass_data_mode_switching =
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
857 {
16
kono
parents: 14
diff changeset
858 RTL_PASS, /* type */
kono
parents: 14
diff changeset
859 "mode_sw", /* name */
kono
parents: 14
diff changeset
860 OPTGROUP_NONE, /* optinfo_flags */
kono
parents: 14
diff changeset
861 TV_MODE_SWITCH, /* tv_id */
kono
parents: 14
diff changeset
862 0, /* properties_required */
kono
parents: 14
diff changeset
863 0, /* properties_provided */
kono
parents: 14
diff changeset
864 0, /* properties_destroyed */
kono
parents: 14
diff changeset
865 0, /* todo_flags_start */
kono
parents: 14
diff changeset
866 TODO_df_finish, /* todo_flags_finish */
kono
parents: 14
diff changeset
867 };
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
868
16
kono
parents: 14
diff changeset
869 class pass_mode_switching : public rtl_opt_pass
kono
parents: 14
diff changeset
870 {
kono
parents: 14
diff changeset
871 public:
kono
parents: 14
diff changeset
872 pass_mode_switching (gcc::context *ctxt)
kono
parents: 14
diff changeset
873 : rtl_opt_pass (pass_data_mode_switching, ctxt)
kono
parents: 14
diff changeset
874 {}
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
875
16
kono
parents: 14
diff changeset
876 /* opt_pass methods: */
kono
parents: 14
diff changeset
877 /* The epiphany backend creates a second instance of this pass, so we need
kono
parents: 14
diff changeset
878 a clone method. */
kono
parents: 14
diff changeset
879 opt_pass * clone () { return new pass_mode_switching (m_ctxt); }
kono
parents: 14
diff changeset
880 virtual bool gate (function *)
kono
parents: 14
diff changeset
881 {
kono
parents: 14
diff changeset
882 #ifdef OPTIMIZE_MODE_SWITCHING
kono
parents: 14
diff changeset
883 return true;
kono
parents: 14
diff changeset
884 #else
kono
parents: 14
diff changeset
885 return false;
kono
parents: 14
diff changeset
886 #endif
kono
parents: 14
diff changeset
887 }
kono
parents: 14
diff changeset
888
kono
parents: 14
diff changeset
889 virtual unsigned int execute (function *)
kono
parents: 14
diff changeset
890 {
kono
parents: 14
diff changeset
891 #ifdef OPTIMIZE_MODE_SWITCHING
kono
parents: 14
diff changeset
892 optimize_mode_switching ();
kono
parents: 14
diff changeset
893 #endif /* OPTIMIZE_MODE_SWITCHING */
kono
parents: 14
diff changeset
894 return 0;
kono
parents: 14
diff changeset
895 }
kono
parents: 14
diff changeset
896
kono
parents: 14
diff changeset
897 }; // class pass_mode_switching
kono
parents: 14
diff changeset
898
kono
parents: 14
diff changeset
899 } // anon namespace
kono
parents: 14
diff changeset
900
kono
parents: 14
diff changeset
901 rtl_opt_pass *
kono
parents: 14
diff changeset
902 make_pass_mode_switching (gcc::context *ctxt)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
903 {
16
kono
parents: 14
diff changeset
904 return new pass_mode_switching (ctxt);
kono
parents: 14
diff changeset
905 }