comparison gcc/config/riscv/riscv-shorten-memrefs.c @ 19:2b5abeee2509 default tip

update gcc11
author anatofuz
date Mon, 25 May 2020 07:50:57 +0900
parents
children
comparison
equal deleted inserted replaced
18:1830386684a0 19:2b5abeee2509
1 /* Shorten memrefs pass for RISC-V.
2 Copyright (C) 2018-2019 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #define IN_TARGET_CODE 1
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "backend.h"
28 #include "regs.h"
29 #include "target.h"
30 #include "memmodel.h"
31 #include "emit-rtl.h"
32 #include "df.h"
33 #include "predict.h"
34 #include "tree-pass.h"
35
36 /* Try to make more use of compressed load and store instructions by replacing
37 a load/store at address BASE + LARGE_OFFSET with a new load/store at address
38 NEW BASE + SMALL OFFSET. If NEW BASE is stored in a compressed register, the
39 load/store can be compressed. Since creating NEW BASE incurs an overhead,
40 the change is only attempted when BASE is referenced by at least four
41 load/stores in the same basic block. */
42
43 namespace {
44
45 const pass_data pass_data_shorten_memrefs =
46 {
47 RTL_PASS, /* type */
48 "shorten_memrefs", /* name */
49 OPTGROUP_NONE, /* optinfo_flags */
50 TV_NONE, /* tv_id */
51 0, /* properties_required */
52 0, /* properties_provided */
53 0, /* properties_destroyed */
54 0, /* todo_flags_start */
55 0, /* todo_flags_finish */
56 };
57
58 class pass_shorten_memrefs : public rtl_opt_pass
59 {
60 public:
61 pass_shorten_memrefs (gcc::context *ctxt)
62 : rtl_opt_pass (pass_data_shorten_memrefs, ctxt)
63 {}
64
65 /* opt_pass methods: */
66 virtual bool gate (function *)
67 {
68 return TARGET_RVC && riscv_mshorten_memrefs && optimize > 0;
69 }
70 virtual unsigned int execute (function *);
71
72 private:
73 typedef int_hash <HOST_WIDE_INT, 0> regno_hash;
74 typedef hash_map <regno_hash, int> regno_map;
75
76 regno_map * analyze (basic_block bb);
77 void transform (regno_map *m, basic_block bb);
78 bool get_si_mem_base_reg (rtx mem, rtx *addr);
79 }; // class pass_shorten_memrefs
80
81 bool
82 pass_shorten_memrefs::get_si_mem_base_reg (rtx mem, rtx *addr)
83 {
84 if (!MEM_P (mem) || GET_MODE (mem) != SImode)
85 return false;
86 *addr = XEXP (mem, 0);
87 return GET_CODE (*addr) == PLUS && REG_P (XEXP (*addr, 0));
88 }
89
90 /* Count how many times each regno is referenced as base address for a memory
91 access. */
92
93 pass_shorten_memrefs::regno_map *
94 pass_shorten_memrefs::analyze (basic_block bb)
95 {
96 regno_map *m = hash_map<regno_hash, int>::create_ggc (10);
97 rtx_insn *insn;
98
99 regstat_init_n_sets_and_refs ();
100
101 FOR_BB_INSNS (bb, insn)
102 {
103 if (!NONJUMP_INSN_P (insn))
104 continue;
105 rtx pat = PATTERN (insn);
106 if (GET_CODE (pat) != SET)
107 continue;
108 /* Analyze stores first then loads. */
109 for (int i = 0; i < 2; i++)
110 {
111 rtx mem = XEXP (pat, i);
112 rtx addr;
113 if (get_si_mem_base_reg (mem, &addr))
114 {
115 HOST_WIDE_INT regno = REGNO (XEXP (addr, 0));
116 /* Do not count store zero as these cannot be compressed. */
117 if (i == 0)
118 {
119 if (XEXP (pat, 1) == CONST0_RTX (GET_MODE (XEXP (pat, 1))))
120 continue;
121 }
122 if (REG_N_REFS (regno) < 4)
123 continue;
124 m->get_or_insert (regno)++;
125 }
126 }
127 }
128 regstat_free_n_sets_and_refs ();
129
130 return m;
131 }
132
133 /* Convert BASE + LARGE_OFFSET to NEW_BASE + SMALL_OFFSET for each load/store
134 with a base reg referenced at least 4 times. */
135
136 void
137 pass_shorten_memrefs::transform (regno_map *m, basic_block bb)
138 {
139 rtx_insn *insn;
140 FOR_BB_INSNS (bb, insn)
141 {
142 if (!NONJUMP_INSN_P (insn))
143 continue;
144 rtx pat = PATTERN (insn);
145 if (GET_CODE (pat) != SET)
146 continue;
147 start_sequence ();
148 /* Transform stores first then loads. */
149 for (int i = 0; i < 2; i++)
150 {
151 rtx mem = XEXP (pat, i);
152 rtx addr;
153 if (get_si_mem_base_reg (mem, &addr))
154 {
155 HOST_WIDE_INT regno = REGNO (XEXP (addr, 0));
156 /* Do not transform store zero as these cannot be compressed. */
157 if (i == 0)
158 {
159 if (XEXP (pat, 1) == CONST0_RTX (GET_MODE (XEXP (pat, 1))))
160 continue;
161 }
162 if (m->get_or_insert (regno) > 3)
163 {
164 addr
165 = targetm.legitimize_address (addr, addr, GET_MODE (mem));
166 XEXP (pat, i) = replace_equiv_address (mem, addr);
167 df_insn_rescan (insn);
168 }
169 }
170 }
171 rtx_insn *seq = get_insns ();
172 end_sequence ();
173 emit_insn_before (seq, insn);
174 }
175 }
176
177 unsigned int
178 pass_shorten_memrefs::execute (function *fn)
179 {
180 basic_block bb;
181
182 FOR_ALL_BB_FN (bb, fn)
183 {
184 regno_map *m;
185 if (optimize_bb_for_speed_p (bb))
186 continue;
187 m = analyze (bb);
188 transform (m, bb);
189 }
190
191 return 0;
192 }
193
194 } // anon namespace
195
196 rtl_opt_pass *
197 make_pass_shorten_memrefs (gcc::context *ctxt)
198 {
199 return new pass_shorten_memrefs (ctxt);
200 }