OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [arm/] [ldmstm.md] - Blame information for rev 849

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn 
/* ARM ldm/stm instruction patterns.  This file was automatically generated
2 
   using arm-ldmstm.ml.  Please do not edit manually.
3 
 
4 
   Copyright (C) 2010 Free Software Foundation, Inc.
5 
   Contributed by CodeSourcery.
6 
 
7 
   This file is part of GCC.
8 
 
9 
   GCC is free software; you can redistribute it and/or modify it
10 
   under the terms of the GNU General Public License as published
11 
   by the Free Software Foundation; either version 3, or (at your
12 
   option) any later version.
13 
 
14 
   GCC is distributed in the hope that it will be useful, but WITHOUT
15 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17 
   License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License and
20 
   a copy of the GCC Runtime Library Exception along with this program;
21 
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
22 
   .  */
23 
 
24 
(define_insn "*ldm4_ia"
25 
  [(match_parallel 0 "load_multiple_operation"
26 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
27 
          (mem:SI (match_operand:SI 5 "s_register_operand" "rk")))
28 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
29 
          (mem:SI (plus:SI (match_dup 5)
30 
                  (const_int 4))))
31 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
32 
          (mem:SI (plus:SI (match_dup 5)
33 
                  (const_int 8))))
34 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
35 
          (mem:SI (plus:SI (match_dup 5)
36 
                  (const_int 12))))])]
37 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
38 
  "ldm%(ia%)\t%5, {%1, %2, %3, %4}"
39 
  [(set_attr "type" "load4")
40 
   (set_attr "predicable" "yes")])
41 
 
42 
(define_insn "*thumb_ldm4_ia"
43 
  [(match_parallel 0 "load_multiple_operation"
44 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
45 
          (mem:SI (match_operand:SI 5 "s_register_operand" "l")))
46 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
47 
          (mem:SI (plus:SI (match_dup 5)
48 
                  (const_int 4))))
49 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
50 
          (mem:SI (plus:SI (match_dup 5)
51 
                  (const_int 8))))
52 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
53 
          (mem:SI (plus:SI (match_dup 5)
54 
                  (const_int 12))))])]
55 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 4"
56 
  "ldm%(ia%)\t%5, {%1, %2, %3, %4}"
57 
  [(set_attr "type" "load4")])
58 
 
59 
(define_insn "*ldm4_ia_update"
60 
  [(match_parallel 0 "load_multiple_operation"
61 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
62 
          (plus:SI (match_dup 5) (const_int 16)))
63 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
64 
          (mem:SI (match_dup 5)))
65 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
66 
          (mem:SI (plus:SI (match_dup 5)
67 
                  (const_int 4))))
68 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
69 
          (mem:SI (plus:SI (match_dup 5)
70 
                  (const_int 8))))
71 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
72 
          (mem:SI (plus:SI (match_dup 5)
73 
                  (const_int 12))))])]
74 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 5"
75 
  "ldm%(ia%)\t%5!, {%1, %2, %3, %4}"
76 
  [(set_attr "type" "load4")
77 
   (set_attr "predicable" "yes")])
78 
 
79 
(define_insn "*thumb_ldm4_ia_update"
80 
  [(match_parallel 0 "load_multiple_operation"
81 
    [(set (match_operand:SI 5 "s_register_operand" "+&l")
82 
          (plus:SI (match_dup 5) (const_int 16)))
83 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
84 
          (mem:SI (match_dup 5)))
85 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
86 
          (mem:SI (plus:SI (match_dup 5)
87 
                  (const_int 4))))
88 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
89 
          (mem:SI (plus:SI (match_dup 5)
90 
                  (const_int 8))))
91 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
92 
          (mem:SI (plus:SI (match_dup 5)
93 
                  (const_int 12))))])]
94 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 5"
95 
  "ldm%(ia%)\t%5!, {%1, %2, %3, %4}"
96 
  [(set_attr "type" "load4")])
97 
 
98 
(define_insn "*stm4_ia"
99 
  [(match_parallel 0 "store_multiple_operation"
100 
    [(set (mem:SI (match_operand:SI 5 "s_register_operand" "rk"))
101 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
102 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 4)))
103 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
104 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 8)))
105 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
106 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 12)))
107 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
108 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
109 
  "stm%(ia%)\t%5, {%1, %2, %3, %4}"
110 
  [(set_attr "type" "store4")
111 
   (set_attr "predicable" "yes")])
112 
 
113 
(define_insn "*stm4_ia_update"
114 
  [(match_parallel 0 "store_multiple_operation"
115 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
116 
          (plus:SI (match_dup 5) (const_int 16)))
117 
     (set (mem:SI (match_dup 5))
118 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
119 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 4)))
120 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
121 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 8)))
122 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
123 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 12)))
124 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
125 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 5"
126 
  "stm%(ia%)\t%5!, {%1, %2, %3, %4}"
127 
  [(set_attr "type" "store4")
128 
   (set_attr "predicable" "yes")])
129 
 
130 
(define_insn "*thumb_stm4_ia_update"
131 
  [(match_parallel 0 "store_multiple_operation"
132 
    [(set (match_operand:SI 5 "s_register_operand" "+&l")
133 
          (plus:SI (match_dup 5) (const_int 16)))
134 
     (set (mem:SI (match_dup 5))
135 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
136 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 4)))
137 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
138 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 8)))
139 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
140 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 12)))
141 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
142 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 5"
143 
  "stm%(ia%)\t%5!, {%1, %2, %3, %4}"
144 
  [(set_attr "type" "store4")])
145 
 
146 
(define_insn "*ldm4_ib"
147 
  [(match_parallel 0 "load_multiple_operation"
148 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
149 
          (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk")
150 
                  (const_int 4))))
151 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
152 
          (mem:SI (plus:SI (match_dup 5)
153 
                  (const_int 8))))
154 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
155 
          (mem:SI (plus:SI (match_dup 5)
156 
                  (const_int 12))))
157 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
158 
          (mem:SI (plus:SI (match_dup 5)
159 
                  (const_int 16))))])]
160 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
161 
  "ldm%(ib%)\t%5, {%1, %2, %3, %4}"
162 
  [(set_attr "type" "load4")
163 
   (set_attr "predicable" "yes")])
164 
 
165 
(define_insn "*ldm4_ib_update"
166 
  [(match_parallel 0 "load_multiple_operation"
167 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
168 
          (plus:SI (match_dup 5) (const_int 16)))
169 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
170 
          (mem:SI (plus:SI (match_dup 5)
171 
                  (const_int 4))))
172 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
173 
          (mem:SI (plus:SI (match_dup 5)
174 
                  (const_int 8))))
175 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
176 
          (mem:SI (plus:SI (match_dup 5)
177 
                  (const_int 12))))
178 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
179 
          (mem:SI (plus:SI (match_dup 5)
180 
                  (const_int 16))))])]
181 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 5"
182 
  "ldm%(ib%)\t%5!, {%1, %2, %3, %4}"
183 
  [(set_attr "type" "load4")
184 
   (set_attr "predicable" "yes")])
185 
 
186 
(define_insn "*stm4_ib"
187 
  [(match_parallel 0 "store_multiple_operation"
188 
    [(set (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk") (const_int 4)))
189 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
190 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 8)))
191 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
192 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 12)))
193 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
194 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 16)))
195 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
196 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
197 
  "stm%(ib%)\t%5, {%1, %2, %3, %4}"
198 
  [(set_attr "type" "store4")
199 
   (set_attr "predicable" "yes")])
200 
 
201 
(define_insn "*stm4_ib_update"
202 
  [(match_parallel 0 "store_multiple_operation"
203 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
204 
          (plus:SI (match_dup 5) (const_int 16)))
205 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 4)))
206 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
207 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 8)))
208 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
209 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 12)))
210 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
211 
     (set (mem:SI (plus:SI (match_dup 5) (const_int 16)))
212 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
213 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 5"
214 
  "stm%(ib%)\t%5!, {%1, %2, %3, %4}"
215 
  [(set_attr "type" "store4")
216 
   (set_attr "predicable" "yes")])
217 
 
218 
(define_insn "*ldm4_da"
219 
  [(match_parallel 0 "load_multiple_operation"
220 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
221 
          (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk")
222 
                  (const_int -12))))
223 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
224 
          (mem:SI (plus:SI (match_dup 5)
225 
                  (const_int -8))))
226 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
227 
          (mem:SI (plus:SI (match_dup 5)
228 
                  (const_int -4))))
229 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
230 
          (mem:SI (match_dup 5)))])]
231 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
232 
  "ldm%(da%)\t%5, {%1, %2, %3, %4}"
233 
  [(set_attr "type" "load4")
234 
   (set_attr "predicable" "yes")])
235 
 
236 
(define_insn "*ldm4_da_update"
237 
  [(match_parallel 0 "load_multiple_operation"
238 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
239 
          (plus:SI (match_dup 5) (const_int -16)))
240 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
241 
          (mem:SI (plus:SI (match_dup 5)
242 
                  (const_int -12))))
243 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
244 
          (mem:SI (plus:SI (match_dup 5)
245 
                  (const_int -8))))
246 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
247 
          (mem:SI (plus:SI (match_dup 5)
248 
                  (const_int -4))))
249 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
250 
          (mem:SI (match_dup 5)))])]
251 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 5"
252 
  "ldm%(da%)\t%5!, {%1, %2, %3, %4}"
253 
  [(set_attr "type" "load4")
254 
   (set_attr "predicable" "yes")])
255 
 
256 
(define_insn "*stm4_da"
257 
  [(match_parallel 0 "store_multiple_operation"
258 
    [(set (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk") (const_int -12)))
259 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
260 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -8)))
261 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
262 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -4)))
263 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
264 
     (set (mem:SI (match_dup 5))
265 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
266 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
267 
  "stm%(da%)\t%5, {%1, %2, %3, %4}"
268 
  [(set_attr "type" "store4")
269 
   (set_attr "predicable" "yes")])
270 
 
271 
(define_insn "*stm4_da_update"
272 
  [(match_parallel 0 "store_multiple_operation"
273 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
274 
          (plus:SI (match_dup 5) (const_int -16)))
275 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -12)))
276 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
277 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -8)))
278 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
279 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -4)))
280 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
281 
     (set (mem:SI (match_dup 5))
282 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
283 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 5"
284 
  "stm%(da%)\t%5!, {%1, %2, %3, %4}"
285 
  [(set_attr "type" "store4")
286 
   (set_attr "predicable" "yes")])
287 
 
288 
(define_insn "*ldm4_db"
289 
  [(match_parallel 0 "load_multiple_operation"
290 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
291 
          (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk")
292 
                  (const_int -16))))
293 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
294 
          (mem:SI (plus:SI (match_dup 5)
295 
                  (const_int -12))))
296 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
297 
          (mem:SI (plus:SI (match_dup 5)
298 
                  (const_int -8))))
299 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
300 
          (mem:SI (plus:SI (match_dup 5)
301 
                  (const_int -4))))])]
302 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
303 
  "ldm%(db%)\t%5, {%1, %2, %3, %4}"
304 
  [(set_attr "type" "load4")
305 
   (set_attr "predicable" "yes")])
306 
 
307 
(define_insn "*ldm4_db_update"
308 
  [(match_parallel 0 "load_multiple_operation"
309 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
310 
          (plus:SI (match_dup 5) (const_int -16)))
311 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
312 
          (mem:SI (plus:SI (match_dup 5)
313 
                  (const_int -16))))
314 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
315 
          (mem:SI (plus:SI (match_dup 5)
316 
                  (const_int -12))))
317 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
318 
          (mem:SI (plus:SI (match_dup 5)
319 
                  (const_int -8))))
320 
     (set (match_operand:SI 4 "arm_hard_register_operand" "")
321 
          (mem:SI (plus:SI (match_dup 5)
322 
                  (const_int -4))))])]
323 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 5"
324 
  "ldm%(db%)\t%5!, {%1, %2, %3, %4}"
325 
  [(set_attr "type" "load4")
326 
   (set_attr "predicable" "yes")])
327 
 
328 
(define_insn "*stm4_db"
329 
  [(match_parallel 0 "store_multiple_operation"
330 
    [(set (mem:SI (plus:SI (match_operand:SI 5 "s_register_operand" "rk") (const_int -16)))
331 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
332 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -12)))
333 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
334 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -8)))
335 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
336 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -4)))
337 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
338 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
339 
  "stm%(db%)\t%5, {%1, %2, %3, %4}"
340 
  [(set_attr "type" "store4")
341 
   (set_attr "predicable" "yes")])
342 
 
343 
(define_insn "*stm4_db_update"
344 
  [(match_parallel 0 "store_multiple_operation"
345 
    [(set (match_operand:SI 5 "s_register_operand" "+&rk")
346 
          (plus:SI (match_dup 5) (const_int -16)))
347 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -16)))
348 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
349 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -12)))
350 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
351 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -8)))
352 
          (match_operand:SI 3 "arm_hard_register_operand" ""))
353 
     (set (mem:SI (plus:SI (match_dup 5) (const_int -4)))
354 
          (match_operand:SI 4 "arm_hard_register_operand" ""))])]
355 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 5"
356 
  "stm%(db%)\t%5!, {%1, %2, %3, %4}"
357 
  [(set_attr "type" "store4")
358 
   (set_attr "predicable" "yes")])
359 
 
360 
(define_peephole2
361 
  [(set (match_operand:SI 0 "s_register_operand" "")
362 
        (match_operand:SI 4 "memory_operand" ""))
363 
   (set (match_operand:SI 1 "s_register_operand" "")
364 
        (match_operand:SI 5 "memory_operand" ""))
365 
   (set (match_operand:SI 2 "s_register_operand" "")
366 
        (match_operand:SI 6 "memory_operand" ""))
367 
   (set (match_operand:SI 3 "s_register_operand" "")
368 
        (match_operand:SI 7 "memory_operand" ""))]
369 
  ""
370 
  [(const_int 0)]
371 
{
372 
  if (gen_ldm_seq (operands, 4, false))
373 
    DONE;
374 
  else
375 
    FAIL;
376 
})
377 
 
378 
(define_peephole2
379 
  [(set (match_operand:SI 0 "s_register_operand" "")
380 
        (match_operand:SI 4 "memory_operand" ""))
381 
   (parallel
382 
    [(set (match_operand:SI 1 "s_register_operand" "")
383 
          (match_operand:SI 5 "memory_operand" ""))
384 
     (set (match_operand:SI 2 "s_register_operand" "")
385 
          (match_operand:SI 6 "memory_operand" ""))
386 
     (set (match_operand:SI 3 "s_register_operand" "")
387 
          (match_operand:SI 7 "memory_operand" ""))])]
388 
  ""
389 
  [(const_int 0)]
390 
{
391 
  if (gen_ldm_seq (operands, 4, false))
392 
    DONE;
393 
  else
394 
    FAIL;
395 
})
396 
 
397 
(define_peephole2
398 
  [(set (match_operand:SI 0 "s_register_operand" "")
399 
        (match_operand:SI 8 "const_int_operand" ""))
400 
   (set (match_operand:SI 4 "memory_operand" "")
401 
        (match_dup 0))
402 
   (set (match_operand:SI 1 "s_register_operand" "")
403 
        (match_operand:SI 9 "const_int_operand" ""))
404 
   (set (match_operand:SI 5 "memory_operand" "")
405 
        (match_dup 1))
406 
   (set (match_operand:SI 2 "s_register_operand" "")
407 
        (match_operand:SI 10 "const_int_operand" ""))
408 
   (set (match_operand:SI 6 "memory_operand" "")
409 
        (match_dup 2))
410 
   (set (match_operand:SI 3 "s_register_operand" "")
411 
        (match_operand:SI 11 "const_int_operand" ""))
412 
   (set (match_operand:SI 7 "memory_operand" "")
413 
        (match_dup 3))]
414 
  ""
415 
  [(const_int 0)]
416 
{
417 
  if (gen_const_stm_seq (operands, 4))
418 
    DONE;
419 
  else
420 
    FAIL;
421 
})
422 
 
423 
(define_peephole2
424 
  [(set (match_operand:SI 0 "s_register_operand" "")
425 
        (match_operand:SI 8 "const_int_operand" ""))
426 
   (set (match_operand:SI 1 "s_register_operand" "")
427 
        (match_operand:SI 9 "const_int_operand" ""))
428 
   (set (match_operand:SI 2 "s_register_operand" "")
429 
        (match_operand:SI 10 "const_int_operand" ""))
430 
   (set (match_operand:SI 3 "s_register_operand" "")
431 
        (match_operand:SI 11 "const_int_operand" ""))
432 
   (set (match_operand:SI 4 "memory_operand" "")
433 
        (match_dup 0))
434 
   (set (match_operand:SI 5 "memory_operand" "")
435 
        (match_dup 1))
436 
   (set (match_operand:SI 6 "memory_operand" "")
437 
        (match_dup 2))
438 
   (set (match_operand:SI 7 "memory_operand" "")
439 
        (match_dup 3))]
440 
  ""
441 
  [(const_int 0)]
442 
{
443 
  if (gen_const_stm_seq (operands, 4))
444 
    DONE;
445 
  else
446 
    FAIL;
447 
})
448 
 
449 
(define_peephole2
450 
  [(set (match_operand:SI 4 "memory_operand" "")
451 
        (match_operand:SI 0 "s_register_operand" ""))
452 
   (set (match_operand:SI 5 "memory_operand" "")
453 
        (match_operand:SI 1 "s_register_operand" ""))
454 
   (set (match_operand:SI 6 "memory_operand" "")
455 
        (match_operand:SI 2 "s_register_operand" ""))
456 
   (set (match_operand:SI 7 "memory_operand" "")
457 
        (match_operand:SI 3 "s_register_operand" ""))]
458 
  ""
459 
  [(const_int 0)]
460 
{
461 
  if (gen_stm_seq (operands, 4))
462 
    DONE;
463 
  else
464 
    FAIL;
465 
})
466 
 
467 
(define_insn "*ldm3_ia"
468 
  [(match_parallel 0 "load_multiple_operation"
469 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
470 
          (mem:SI (match_operand:SI 4 "s_register_operand" "rk")))
471 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
472 
          (mem:SI (plus:SI (match_dup 4)
473 
                  (const_int 4))))
474 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
475 
          (mem:SI (plus:SI (match_dup 4)
476 
                  (const_int 8))))])]
477 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
478 
  "ldm%(ia%)\t%4, {%1, %2, %3}"
479 
  [(set_attr "type" "load3")
480 
   (set_attr "predicable" "yes")])
481 
 
482 
(define_insn "*thumb_ldm3_ia"
483 
  [(match_parallel 0 "load_multiple_operation"
484 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
485 
          (mem:SI (match_operand:SI 4 "s_register_operand" "l")))
486 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
487 
          (mem:SI (plus:SI (match_dup 4)
488 
                  (const_int 4))))
489 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
490 
          (mem:SI (plus:SI (match_dup 4)
491 
                  (const_int 8))))])]
492 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 3"
493 
  "ldm%(ia%)\t%4, {%1, %2, %3}"
494 
  [(set_attr "type" "load3")])
495 
 
496 
(define_insn "*ldm3_ia_update"
497 
  [(match_parallel 0 "load_multiple_operation"
498 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
499 
          (plus:SI (match_dup 4) (const_int 12)))
500 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
501 
          (mem:SI (match_dup 4)))
502 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
503 
          (mem:SI (plus:SI (match_dup 4)
504 
                  (const_int 4))))
505 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
506 
          (mem:SI (plus:SI (match_dup 4)
507 
                  (const_int 8))))])]
508 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
509 
  "ldm%(ia%)\t%4!, {%1, %2, %3}"
510 
  [(set_attr "type" "load3")
511 
   (set_attr "predicable" "yes")])
512 
 
513 
(define_insn "*thumb_ldm3_ia_update"
514 
  [(match_parallel 0 "load_multiple_operation"
515 
    [(set (match_operand:SI 4 "s_register_operand" "+&l")
516 
          (plus:SI (match_dup 4) (const_int 12)))
517 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
518 
          (mem:SI (match_dup 4)))
519 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
520 
          (mem:SI (plus:SI (match_dup 4)
521 
                  (const_int 4))))
522 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
523 
          (mem:SI (plus:SI (match_dup 4)
524 
                  (const_int 8))))])]
525 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 4"
526 
  "ldm%(ia%)\t%4!, {%1, %2, %3}"
527 
  [(set_attr "type" "load3")])
528 
 
529 
(define_insn "*stm3_ia"
530 
  [(match_parallel 0 "store_multiple_operation"
531 
    [(set (mem:SI (match_operand:SI 4 "s_register_operand" "rk"))
532 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
533 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 4)))
534 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
535 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 8)))
536 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
537 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
538 
  "stm%(ia%)\t%4, {%1, %2, %3}"
539 
  [(set_attr "type" "store3")
540 
   (set_attr "predicable" "yes")])
541 
 
542 
(define_insn "*stm3_ia_update"
543 
  [(match_parallel 0 "store_multiple_operation"
544 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
545 
          (plus:SI (match_dup 4) (const_int 12)))
546 
     (set (mem:SI (match_dup 4))
547 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
548 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 4)))
549 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
550 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 8)))
551 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
552 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
553 
  "stm%(ia%)\t%4!, {%1, %2, %3}"
554 
  [(set_attr "type" "store3")
555 
   (set_attr "predicable" "yes")])
556 
 
557 
(define_insn "*thumb_stm3_ia_update"
558 
  [(match_parallel 0 "store_multiple_operation"
559 
    [(set (match_operand:SI 4 "s_register_operand" "+&l")
560 
          (plus:SI (match_dup 4) (const_int 12)))
561 
     (set (mem:SI (match_dup 4))
562 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
563 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 4)))
564 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
565 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 8)))
566 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
567 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 4"
568 
  "stm%(ia%)\t%4!, {%1, %2, %3}"
569 
  [(set_attr "type" "store3")])
570 
 
571 
(define_insn "*ldm3_ib"
572 
  [(match_parallel 0 "load_multiple_operation"
573 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
574 
          (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk")
575 
                  (const_int 4))))
576 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
577 
          (mem:SI (plus:SI (match_dup 4)
578 
                  (const_int 8))))
579 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
580 
          (mem:SI (plus:SI (match_dup 4)
581 
                  (const_int 12))))])]
582 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
583 
  "ldm%(ib%)\t%4, {%1, %2, %3}"
584 
  [(set_attr "type" "load3")
585 
   (set_attr "predicable" "yes")])
586 
 
587 
(define_insn "*ldm3_ib_update"
588 
  [(match_parallel 0 "load_multiple_operation"
589 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
590 
          (plus:SI (match_dup 4) (const_int 12)))
591 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
592 
          (mem:SI (plus:SI (match_dup 4)
593 
                  (const_int 4))))
594 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
595 
          (mem:SI (plus:SI (match_dup 4)
596 
                  (const_int 8))))
597 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
598 
          (mem:SI (plus:SI (match_dup 4)
599 
                  (const_int 12))))])]
600 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
601 
  "ldm%(ib%)\t%4!, {%1, %2, %3}"
602 
  [(set_attr "type" "load3")
603 
   (set_attr "predicable" "yes")])
604 
 
605 
(define_insn "*stm3_ib"
606 
  [(match_parallel 0 "store_multiple_operation"
607 
    [(set (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk") (const_int 4)))
608 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
609 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 8)))
610 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
611 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 12)))
612 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
613 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
614 
  "stm%(ib%)\t%4, {%1, %2, %3}"
615 
  [(set_attr "type" "store3")
616 
   (set_attr "predicable" "yes")])
617 
 
618 
(define_insn "*stm3_ib_update"
619 
  [(match_parallel 0 "store_multiple_operation"
620 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
621 
          (plus:SI (match_dup 4) (const_int 12)))
622 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 4)))
623 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
624 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 8)))
625 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
626 
     (set (mem:SI (plus:SI (match_dup 4) (const_int 12)))
627 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
628 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
629 
  "stm%(ib%)\t%4!, {%1, %2, %3}"
630 
  [(set_attr "type" "store3")
631 
   (set_attr "predicable" "yes")])
632 
 
633 
(define_insn "*ldm3_da"
634 
  [(match_parallel 0 "load_multiple_operation"
635 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
636 
          (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk")
637 
                  (const_int -8))))
638 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
639 
          (mem:SI (plus:SI (match_dup 4)
640 
                  (const_int -4))))
641 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
642 
          (mem:SI (match_dup 4)))])]
643 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
644 
  "ldm%(da%)\t%4, {%1, %2, %3}"
645 
  [(set_attr "type" "load3")
646 
   (set_attr "predicable" "yes")])
647 
 
648 
(define_insn "*ldm3_da_update"
649 
  [(match_parallel 0 "load_multiple_operation"
650 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
651 
          (plus:SI (match_dup 4) (const_int -12)))
652 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
653 
          (mem:SI (plus:SI (match_dup 4)
654 
                  (const_int -8))))
655 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
656 
          (mem:SI (plus:SI (match_dup 4)
657 
                  (const_int -4))))
658 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
659 
          (mem:SI (match_dup 4)))])]
660 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
661 
  "ldm%(da%)\t%4!, {%1, %2, %3}"
662 
  [(set_attr "type" "load3")
663 
   (set_attr "predicable" "yes")])
664 
 
665 
(define_insn "*stm3_da"
666 
  [(match_parallel 0 "store_multiple_operation"
667 
    [(set (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk") (const_int -8)))
668 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
669 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -4)))
670 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
671 
     (set (mem:SI (match_dup 4))
672 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
673 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
674 
  "stm%(da%)\t%4, {%1, %2, %3}"
675 
  [(set_attr "type" "store3")
676 
   (set_attr "predicable" "yes")])
677 
 
678 
(define_insn "*stm3_da_update"
679 
  [(match_parallel 0 "store_multiple_operation"
680 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
681 
          (plus:SI (match_dup 4) (const_int -12)))
682 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -8)))
683 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
684 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -4)))
685 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
686 
     (set (mem:SI (match_dup 4))
687 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
688 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 4"
689 
  "stm%(da%)\t%4!, {%1, %2, %3}"
690 
  [(set_attr "type" "store3")
691 
   (set_attr "predicable" "yes")])
692 
 
693 
(define_insn "*ldm3_db"
694 
  [(match_parallel 0 "load_multiple_operation"
695 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
696 
          (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk")
697 
                  (const_int -12))))
698 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
699 
          (mem:SI (plus:SI (match_dup 4)
700 
                  (const_int -8))))
701 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
702 
          (mem:SI (plus:SI (match_dup 4)
703 
                  (const_int -4))))])]
704 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
705 
  "ldm%(db%)\t%4, {%1, %2, %3}"
706 
  [(set_attr "type" "load3")
707 
   (set_attr "predicable" "yes")])
708 
 
709 
(define_insn "*ldm3_db_update"
710 
  [(match_parallel 0 "load_multiple_operation"
711 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
712 
          (plus:SI (match_dup 4) (const_int -12)))
713 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
714 
          (mem:SI (plus:SI (match_dup 4)
715 
                  (const_int -12))))
716 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
717 
          (mem:SI (plus:SI (match_dup 4)
718 
                  (const_int -8))))
719 
     (set (match_operand:SI 3 "arm_hard_register_operand" "")
720 
          (mem:SI (plus:SI (match_dup 4)
721 
                  (const_int -4))))])]
722 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
723 
  "ldm%(db%)\t%4!, {%1, %2, %3}"
724 
  [(set_attr "type" "load3")
725 
   (set_attr "predicable" "yes")])
726 
 
727 
(define_insn "*stm3_db"
728 
  [(match_parallel 0 "store_multiple_operation"
729 
    [(set (mem:SI (plus:SI (match_operand:SI 4 "s_register_operand" "rk") (const_int -12)))
730 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
731 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -8)))
732 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
733 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -4)))
734 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
735 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
736 
  "stm%(db%)\t%4, {%1, %2, %3}"
737 
  [(set_attr "type" "store3")
738 
   (set_attr "predicable" "yes")])
739 
 
740 
(define_insn "*stm3_db_update"
741 
  [(match_parallel 0 "store_multiple_operation"
742 
    [(set (match_operand:SI 4 "s_register_operand" "+&rk")
743 
          (plus:SI (match_dup 4) (const_int -12)))
744 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -12)))
745 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
746 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -8)))
747 
          (match_operand:SI 2 "arm_hard_register_operand" ""))
748 
     (set (mem:SI (plus:SI (match_dup 4) (const_int -4)))
749 
          (match_operand:SI 3 "arm_hard_register_operand" ""))])]
750 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 4"
751 
  "stm%(db%)\t%4!, {%1, %2, %3}"
752 
  [(set_attr "type" "store3")
753 
   (set_attr "predicable" "yes")])
754 
 
755 
(define_peephole2
756 
  [(set (match_operand:SI 0 "s_register_operand" "")
757 
        (match_operand:SI 3 "memory_operand" ""))
758 
   (set (match_operand:SI 1 "s_register_operand" "")
759 
        (match_operand:SI 4 "memory_operand" ""))
760 
   (set (match_operand:SI 2 "s_register_operand" "")
761 
        (match_operand:SI 5 "memory_operand" ""))]
762 
  ""
763 
  [(const_int 0)]
764 
{
765 
  if (gen_ldm_seq (operands, 3, false))
766 
    DONE;
767 
  else
768 
    FAIL;
769 
})
770 
 
771 
(define_peephole2
772 
  [(set (match_operand:SI 0 "s_register_operand" "")
773 
        (match_operand:SI 3 "memory_operand" ""))
774 
   (parallel
775 
    [(set (match_operand:SI 1 "s_register_operand" "")
776 
          (match_operand:SI 4 "memory_operand" ""))
777 
     (set (match_operand:SI 2 "s_register_operand" "")
778 
          (match_operand:SI 5 "memory_operand" ""))])]
779 
  ""
780 
  [(const_int 0)]
781 
{
782 
  if (gen_ldm_seq (operands, 3, false))
783 
    DONE;
784 
  else
785 
    FAIL;
786 
})
787 
 
788 
(define_peephole2
789 
  [(set (match_operand:SI 0 "s_register_operand" "")
790 
        (match_operand:SI 6 "const_int_operand" ""))
791 
   (set (match_operand:SI 3 "memory_operand" "")
792 
        (match_dup 0))
793 
   (set (match_operand:SI 1 "s_register_operand" "")
794 
        (match_operand:SI 7 "const_int_operand" ""))
795 
   (set (match_operand:SI 4 "memory_operand" "")
796 
        (match_dup 1))
797 
   (set (match_operand:SI 2 "s_register_operand" "")
798 
        (match_operand:SI 8 "const_int_operand" ""))
799 
   (set (match_operand:SI 5 "memory_operand" "")
800 
        (match_dup 2))]
801 
  ""
802 
  [(const_int 0)]
803 
{
804 
  if (gen_const_stm_seq (operands, 3))
805 
    DONE;
806 
  else
807 
    FAIL;
808 
})
809 
 
810 
(define_peephole2
811 
  [(set (match_operand:SI 0 "s_register_operand" "")
812 
        (match_operand:SI 6 "const_int_operand" ""))
813 
   (set (match_operand:SI 1 "s_register_operand" "")
814 
        (match_operand:SI 7 "const_int_operand" ""))
815 
   (set (match_operand:SI 2 "s_register_operand" "")
816 
        (match_operand:SI 8 "const_int_operand" ""))
817 
   (set (match_operand:SI 3 "memory_operand" "")
818 
        (match_dup 0))
819 
   (set (match_operand:SI 4 "memory_operand" "")
820 
        (match_dup 1))
821 
   (set (match_operand:SI 5 "memory_operand" "")
822 
        (match_dup 2))]
823 
  ""
824 
  [(const_int 0)]
825 
{
826 
  if (gen_const_stm_seq (operands, 3))
827 
    DONE;
828 
  else
829 
    FAIL;
830 
})
831 
 
832 
(define_peephole2
833 
  [(set (match_operand:SI 3 "memory_operand" "")
834 
        (match_operand:SI 0 "s_register_operand" ""))
835 
   (set (match_operand:SI 4 "memory_operand" "")
836 
        (match_operand:SI 1 "s_register_operand" ""))
837 
   (set (match_operand:SI 5 "memory_operand" "")
838 
        (match_operand:SI 2 "s_register_operand" ""))]
839 
  ""
840 
  [(const_int 0)]
841 
{
842 
  if (gen_stm_seq (operands, 3))
843 
    DONE;
844 
  else
845 
    FAIL;
846 
})
847 
 
848 
(define_insn "*ldm2_ia"
849 
  [(match_parallel 0 "load_multiple_operation"
850 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
851 
          (mem:SI (match_operand:SI 3 "s_register_operand" "rk")))
852 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
853 
          (mem:SI (plus:SI (match_dup 3)
854 
                  (const_int 4))))])]
855 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 2"
856 
  "ldm%(ia%)\t%3, {%1, %2}"
857 
  [(set_attr "type" "load2")
858 
   (set_attr "predicable" "yes")])
859 
 
860 
(define_insn "*thumb_ldm2_ia"
861 
  [(match_parallel 0 "load_multiple_operation"
862 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
863 
          (mem:SI (match_operand:SI 3 "s_register_operand" "l")))
864 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
865 
          (mem:SI (plus:SI (match_dup 3)
866 
                  (const_int 4))))])]
867 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 2"
868 
  "ldm%(ia%)\t%3, {%1, %2}"
869 
  [(set_attr "type" "load2")])
870 
 
871 
(define_insn "*ldm2_ia_update"
872 
  [(match_parallel 0 "load_multiple_operation"
873 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
874 
          (plus:SI (match_dup 3) (const_int 8)))
875 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
876 
          (mem:SI (match_dup 3)))
877 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
878 
          (mem:SI (plus:SI (match_dup 3)
879 
                  (const_int 4))))])]
880 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
881 
  "ldm%(ia%)\t%3!, {%1, %2}"
882 
  [(set_attr "type" "load2")
883 
   (set_attr "predicable" "yes")])
884 
 
885 
(define_insn "*thumb_ldm2_ia_update"
886 
  [(match_parallel 0 "load_multiple_operation"
887 
    [(set (match_operand:SI 3 "s_register_operand" "+&l")
888 
          (plus:SI (match_dup 3) (const_int 8)))
889 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
890 
          (mem:SI (match_dup 3)))
891 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
892 
          (mem:SI (plus:SI (match_dup 3)
893 
                  (const_int 4))))])]
894 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 3"
895 
  "ldm%(ia%)\t%3!, {%1, %2}"
896 
  [(set_attr "type" "load2")])
897 
 
898 
(define_insn "*stm2_ia"
899 
  [(match_parallel 0 "store_multiple_operation"
900 
    [(set (mem:SI (match_operand:SI 3 "s_register_operand" "rk"))
901 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
902 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 4)))
903 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
904 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 2"
905 
  "stm%(ia%)\t%3, {%1, %2}"
906 
  [(set_attr "type" "store2")
907 
   (set_attr "predicable" "yes")])
908 
 
909 
(define_insn "*stm2_ia_update"
910 
  [(match_parallel 0 "store_multiple_operation"
911 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
912 
          (plus:SI (match_dup 3) (const_int 8)))
913 
     (set (mem:SI (match_dup 3))
914 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
915 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 4)))
916 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
917 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
918 
  "stm%(ia%)\t%3!, {%1, %2}"
919 
  [(set_attr "type" "store2")
920 
   (set_attr "predicable" "yes")])
921 
 
922 
(define_insn "*thumb_stm2_ia_update"
923 
  [(match_parallel 0 "store_multiple_operation"
924 
    [(set (match_operand:SI 3 "s_register_operand" "+&l")
925 
          (plus:SI (match_dup 3) (const_int 8)))
926 
     (set (mem:SI (match_dup 3))
927 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
928 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 4)))
929 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
930 
  "TARGET_THUMB1 && XVECLEN (operands[0], 0) == 3"
931 
  "stm%(ia%)\t%3!, {%1, %2}"
932 
  [(set_attr "type" "store2")])
933 
 
934 
(define_insn "*ldm2_ib"
935 
  [(match_parallel 0 "load_multiple_operation"
936 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
937 
          (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk")
938 
                  (const_int 4))))
939 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
940 
          (mem:SI (plus:SI (match_dup 3)
941 
                  (const_int 8))))])]
942 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 2"
943 
  "ldm%(ib%)\t%3, {%1, %2}"
944 
  [(set_attr "type" "load2")
945 
   (set_attr "predicable" "yes")])
946 
 
947 
(define_insn "*ldm2_ib_update"
948 
  [(match_parallel 0 "load_multiple_operation"
949 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
950 
          (plus:SI (match_dup 3) (const_int 8)))
951 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
952 
          (mem:SI (plus:SI (match_dup 3)
953 
                  (const_int 4))))
954 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
955 
          (mem:SI (plus:SI (match_dup 3)
956 
                  (const_int 8))))])]
957 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
958 
  "ldm%(ib%)\t%3!, {%1, %2}"
959 
  [(set_attr "type" "load2")
960 
   (set_attr "predicable" "yes")])
961 
 
962 
(define_insn "*stm2_ib"
963 
  [(match_parallel 0 "store_multiple_operation"
964 
    [(set (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk") (const_int 4)))
965 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
966 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 8)))
967 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
968 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 2"
969 
  "stm%(ib%)\t%3, {%1, %2}"
970 
  [(set_attr "type" "store2")
971 
   (set_attr "predicable" "yes")])
972 
 
973 
(define_insn "*stm2_ib_update"
974 
  [(match_parallel 0 "store_multiple_operation"
975 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
976 
          (plus:SI (match_dup 3) (const_int 8)))
977 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 4)))
978 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
979 
     (set (mem:SI (plus:SI (match_dup 3) (const_int 8)))
980 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
981 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
982 
  "stm%(ib%)\t%3!, {%1, %2}"
983 
  [(set_attr "type" "store2")
984 
   (set_attr "predicable" "yes")])
985 
 
986 
(define_insn "*ldm2_da"
987 
  [(match_parallel 0 "load_multiple_operation"
988 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
989 
          (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk")
990 
                  (const_int -4))))
991 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
992 
          (mem:SI (match_dup 3)))])]
993 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 2"
994 
  "ldm%(da%)\t%3, {%1, %2}"
995 
  [(set_attr "type" "load2")
996 
   (set_attr "predicable" "yes")])
997 
 
998 
(define_insn "*ldm2_da_update"
999 
  [(match_parallel 0 "load_multiple_operation"
1000 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
1001 
          (plus:SI (match_dup 3) (const_int -8)))
1002 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
1003 
          (mem:SI (plus:SI (match_dup 3)
1004 
                  (const_int -4))))
1005 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
1006 
          (mem:SI (match_dup 3)))])]
1007 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
1008 
  "ldm%(da%)\t%3!, {%1, %2}"
1009 
  [(set_attr "type" "load2")
1010 
   (set_attr "predicable" "yes")])
1011 
 
1012 
(define_insn "*stm2_da"
1013 
  [(match_parallel 0 "store_multiple_operation"
1014 
    [(set (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk") (const_int -4)))
1015 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
1016 
     (set (mem:SI (match_dup 3))
1017 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
1018 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 2"
1019 
  "stm%(da%)\t%3, {%1, %2}"
1020 
  [(set_attr "type" "store2")
1021 
   (set_attr "predicable" "yes")])
1022 
 
1023 
(define_insn "*stm2_da_update"
1024 
  [(match_parallel 0 "store_multiple_operation"
1025 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
1026 
          (plus:SI (match_dup 3) (const_int -8)))
1027 
     (set (mem:SI (plus:SI (match_dup 3) (const_int -4)))
1028 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
1029 
     (set (mem:SI (match_dup 3))
1030 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
1031 
  "TARGET_ARM && XVECLEN (operands[0], 0) == 3"
1032 
  "stm%(da%)\t%3!, {%1, %2}"
1033 
  [(set_attr "type" "store2")
1034 
   (set_attr "predicable" "yes")])
1035 
 
1036 
(define_insn "*ldm2_db"
1037 
  [(match_parallel 0 "load_multiple_operation"
1038 
    [(set (match_operand:SI 1 "arm_hard_register_operand" "")
1039 
          (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk")
1040 
                  (const_int -8))))
1041 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
1042 
          (mem:SI (plus:SI (match_dup 3)
1043 
                  (const_int -4))))])]
1044 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 2"
1045 
  "ldm%(db%)\t%3, {%1, %2}"
1046 
  [(set_attr "type" "load2")
1047 
   (set_attr "predicable" "yes")])
1048 
 
1049 
(define_insn "*ldm2_db_update"
1050 
  [(match_parallel 0 "load_multiple_operation"
1051 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
1052 
          (plus:SI (match_dup 3) (const_int -8)))
1053 
     (set (match_operand:SI 1 "arm_hard_register_operand" "")
1054 
          (mem:SI (plus:SI (match_dup 3)
1055 
                  (const_int -8))))
1056 
     (set (match_operand:SI 2 "arm_hard_register_operand" "")
1057 
          (mem:SI (plus:SI (match_dup 3)
1058 
                  (const_int -4))))])]
1059 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
1060 
  "ldm%(db%)\t%3!, {%1, %2}"
1061 
  [(set_attr "type" "load2")
1062 
   (set_attr "predicable" "yes")])
1063 
 
1064 
(define_insn "*stm2_db"
1065 
  [(match_parallel 0 "store_multiple_operation"
1066 
    [(set (mem:SI (plus:SI (match_operand:SI 3 "s_register_operand" "rk") (const_int -8)))
1067 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
1068 
     (set (mem:SI (plus:SI (match_dup 3) (const_int -4)))
1069 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
1070 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 2"
1071 
  "stm%(db%)\t%3, {%1, %2}"
1072 
  [(set_attr "type" "store2")
1073 
   (set_attr "predicable" "yes")])
1074 
 
1075 
(define_insn "*stm2_db_update"
1076 
  [(match_parallel 0 "store_multiple_operation"
1077 
    [(set (match_operand:SI 3 "s_register_operand" "+&rk")
1078 
          (plus:SI (match_dup 3) (const_int -8)))
1079 
     (set (mem:SI (plus:SI (match_dup 3) (const_int -8)))
1080 
          (match_operand:SI 1 "arm_hard_register_operand" ""))
1081 
     (set (mem:SI (plus:SI (match_dup 3) (const_int -4)))
1082 
          (match_operand:SI 2 "arm_hard_register_operand" ""))])]
1083 
  "TARGET_32BIT && XVECLEN (operands[0], 0) == 3"
1084 
  "stm%(db%)\t%3!, {%1, %2}"
1085 
  [(set_attr "type" "store2")
1086 
   (set_attr "predicable" "yes")])
1087 
 
1088 
(define_peephole2
1089 
  [(set (match_operand:SI 0 "s_register_operand" "")
1090 
        (match_operand:SI 2 "memory_operand" ""))
1091 
   (set (match_operand:SI 1 "s_register_operand" "")
1092 
        (match_operand:SI 3 "memory_operand" ""))]
1093 
  ""
1094 
  [(const_int 0)]
1095 
{
1096 
  if (gen_ldm_seq (operands, 2, false))
1097 
    DONE;
1098 
  else
1099 
    FAIL;
1100 
})
1101 
 
1102 
(define_peephole2
1103 
  [(set (match_operand:SI 0 "s_register_operand" "")
1104 
        (match_operand:SI 4 "const_int_operand" ""))
1105 
   (set (match_operand:SI 2 "memory_operand" "")
1106 
        (match_dup 0))
1107 
   (set (match_operand:SI 1 "s_register_operand" "")
1108 
        (match_operand:SI 5 "const_int_operand" ""))
1109 
   (set (match_operand:SI 3 "memory_operand" "")
1110 
        (match_dup 1))]
1111 
  ""
1112 
  [(const_int 0)]
1113 
{
1114 
  if (gen_const_stm_seq (operands, 2))
1115 
    DONE;
1116 
  else
1117 
    FAIL;
1118 
})
1119 
 
1120 
(define_peephole2
1121 
  [(set (match_operand:SI 0 "s_register_operand" "")
1122 
        (match_operand:SI 4 "const_int_operand" ""))
1123 
   (set (match_operand:SI 1 "s_register_operand" "")
1124 
        (match_operand:SI 5 "const_int_operand" ""))
1125 
   (set (match_operand:SI 2 "memory_operand" "")
1126 
        (match_dup 0))
1127 
   (set (match_operand:SI 3 "memory_operand" "")
1128 
        (match_dup 1))]
1129 
  ""
1130 
  [(const_int 0)]
1131 
{
1132 
  if (gen_const_stm_seq (operands, 2))
1133 
    DONE;
1134 
  else
1135 
    FAIL;
1136 
})
1137 
 
1138 
(define_peephole2
1139 
  [(set (match_operand:SI 2 "memory_operand" "")
1140 
        (match_operand:SI 0 "s_register_operand" ""))
1141 
   (set (match_operand:SI 3 "memory_operand" "")
1142 
        (match_operand:SI 1 "s_register_operand" ""))]
1143 
  ""
1144 
  [(const_int 0)]
1145 
{
1146 
  if (gen_stm_seq (operands, 2))
1147 
    DONE;
1148 
  else
1149 
    FAIL;
1150 
})
1151 
 
1152 
(define_peephole2
1153 
  [(set (match_operand:SI 0 "s_register_operand" "")
1154 
        (match_operand:SI 2 "memory_operand" ""))
1155 
   (set (match_operand:SI 1 "s_register_operand" "")
1156 
        (match_operand:SI 3 "memory_operand" ""))
1157 
   (parallel
1158 
     [(set (match_operand:SI 4 "s_register_operand" "")
1159 
           (match_operator:SI 5 "commutative_binary_operator"
1160 
            [(match_operand:SI 6 "s_register_operand" "")
1161 
             (match_operand:SI 7 "s_register_operand" "")]))
1162 
      (clobber (reg:CC CC_REGNUM))])]
1163 
  "(((operands[6] == operands[0] && operands[7] == operands[1])
1164 
     || (operands[7] == operands[0] && operands[6] == operands[1]))
1165 
    && peep2_reg_dead_p (3, operands[0]) && peep2_reg_dead_p (3, operands[1]))"
1166 
  [(parallel
1167 
    [(set (match_dup 4) (match_op_dup 5 [(match_dup 6) (match_dup 7)]))
1168 
     (clobber (reg:CC CC_REGNUM))])]
1169 
{
1170 
  if (!gen_ldm_seq (operands, 2, true))
1171 
    FAIL;
1172 
})
1173 
 
1174 
(define_peephole2
1175 
  [(set (match_operand:SI 0 "s_register_operand" "")
1176 
        (match_operand:SI 2 "memory_operand" ""))
1177 
   (set (match_operand:SI 1 "s_register_operand" "")
1178 
        (match_operand:SI 3 "memory_operand" ""))
1179 
   (set (match_operand:SI 4 "s_register_operand" "")
1180 
        (match_operator:SI 5 "commutative_binary_operator"
1181 
         [(match_operand:SI 6 "s_register_operand" "")
1182 
          (match_operand:SI 7 "s_register_operand" "")]))]
1183 
  "(((operands[6] == operands[0] && operands[7] == operands[1])
1184 
     || (operands[7] == operands[0] && operands[6] == operands[1]))
1185 
    && peep2_reg_dead_p (3, operands[0]) && peep2_reg_dead_p (3, operands[1]))"
1186 
  [(set (match_dup 4) (match_op_dup 5 [(match_dup 6) (match_dup 7)]))]
1187 
{
1188 
  if (!gen_ldm_seq (operands, 2, true))
1189 
    FAIL;
1190 
})
1191 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.