OSDN Git Service

* decl2.c (is_late_template_attribute): Don't defer attribute
[pf3gnuchains/gcc-fork.git] / gcc / config / c4x / c4x.md
1 ;; Machine description for the TMS320C[34]x for GCC
2 ;; Copyright (C) 1994, 1995, 1996, 1997, 1998,
3 ;; 1999, 2000, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
4
5 ;; Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz)
6 ;;            and Herman Ten Brugge (Haj.Ten.Brugge@net.HCC.nl)
7
8 ;; This file is part of GCC.
9
10 ;; GCC is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 3, or (at your option)
13 ;; any later version.
14
15 ;; GCC is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 ;; GNU General Public License for more details.
19
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GCC; see the file COPYING3.  If not see
22 ;; <http://www.gnu.org/licenses/>.
23
24 ;
25 ; TODO :
26 ;        Try using PQImode again for addresses since C30 only uses
27 ;        24-bit addresses.   Ideally GCC would emit different insns
28 ;        for QImode and Pmode, whether Pmode was QImode or PQImode.
29 ;        For addresses we wouldn't have to have a clobber of the CC
30 ;        associated with each insn and we could use MPYI in address
31 ;        calculations without having to synthesize a proper 32-bit multiply.
32
33 ; Additional C30/C40 instructions not coded:
34 ; CALLcond, IACK, IDLE, LDE, LDFI, LDII, LDM, NORM, RETIcond
35 ; ROLC, RORC, SIGI, STFI, STII, SUBC, SWI
36
37 ; Additional C40 instructions not coded:
38 ; LDEP, LDPE, LWRct, LAJcond, RETIcondD
39
40 ;
41 ; C4x MODES
42 ;
43 ; QImode                char, short, int, long (32-bits)
44 ; HImode                long long              (64-bits)
45 ; QFmode                float, double          (32-bits)
46 ; HFmode                long double            (40-bits)
47 ; CCmode                
48 ; CC_NOOVmode           
49
50 ;
51 ; C4x PREDICATES:
52 ;
53 ; comparison_operator   LT, GT, LE, GE, LTU, GTU, LEU, GEU, EQ, NE
54 ; memory_operand        memory                                     [m]
55 ; immediate_operand     immediate constant                         [IKN]
56 ; register_operand      register                                   [rf]
57 ; general_operand       register, memory, constant                 [rfmI]
58
59 ; addr_reg_operand      AR0-AR7, pseudo reg                        [a]
60 ; sp_reg_operand        SP                                         [b]
61 ; std_reg_operand       AR0-AR7, IR0-IR1, RC, RS, RE, SP, pseudo   [c]
62 ; ext_reg_operand       R0-R11, pseudo reg                         [f]
63 ; ext_low_reg_operand   R0-R7, pseudo reg                          [q]
64 ; index_reg_operand     IR0-IR1, pseudo reg                        [x]
65 ; st_reg_operand        ST                                         [y]
66 ; dp_reg_operand        DP                                         [z]
67 ; stik_const_operand    5-bit const                                [K]
68 ; src_operand           general operand                            [rfHmI]
69 ; par_ind_operand       indirect S mode (ARx + 0, 1, IRx)          [S<>]
70 ; parallel_operand      par_ind_operand or ext_low_reg_operand
71 ; symbolic_address_operand
72 ; call_address_operand
73
74 ; ADDI src2, src1, dst  three operand op
75 ; ADDI src, dst         two operand op
76
77 ;  Note that the predicates are only used when selecting a pattern
78 ;  to determine if an operand is valid.
79
80 ;  The constraints then select which of the possible valid operands
81 ;  is present (and guide register selection). The actual assembly
82 ;  instruction is then selected on the basis of the constraints.
83
84 ;  The extra constraint (valid_operands) is used to determine if
85 ;  the combination of operands is legitimate for the pattern.
86
87 ;
88 ; C4x CONSTRAINTS:
89 ;
90 ; a   address reg          AR0-AR7
91 ; b   stack pointer        SP
92 ; c   other int reg        AR0-AR7, IR0-IR1, RC, RS, RE
93 ; d   fp reg               R0-R11 (sets CC when dst) 
94 ; e
95 ; f   fp reg               R0-R11 (sets CC when dst)
96 ; g   general reg, memory, constant
97 ; h   fp reg (HFmode)      R0-R11 (sets CC when dst) 
98 ; i   immediate int constant
99 ; j
100 ; k   block count          BK
101 ; l
102 ; m   memory
103 ; n   immediate int constant with known numeric value
104 ; o   offsettable memory
105 ; p   memory address
106 ; q   low fp reg           R0-R7  (sets CC when dst)
107 ; r   general reg          R0-R11, AR0-AR7, IR0-IR1, RC, RS, RE
108 ; s   immediate int constant (value not explicit)
109 ; t                        R0-R1
110 ; u                        R2-R3
111 ; v   repeat count reg     RC
112 ; w
113 ; x   index reg            IR0-IR1
114 ; y   status (CC) reg      ST
115 ; z   data pointer         DP
116
117 ; G   fp zero
118 ; H   fp 16-bit constant
119 ; I   signed 16-bit
120 ; J   signed 8-bit    (C4x only)
121 ; K   signed 5-bit    (C4x only)
122 ; L   unsigned 16-bit
123 ; M   unsigned 8-bit  (C4x only)
124 ; N   ones complement of unsigned 16-bit
125 ; O   16-bit high constant
126 ; Q   ARx + 9-bit signed disp
127 ; R   ARx + 5-bit unsigned disp  (C4x only)
128 ; S   ARx + 0, 1, IRx disp
129 ; T   direct memory operand
130 ; V   non offsettable memory
131 ; X   any operand
132 ; <   memory operand with autodecrement addressing
133 ; >   memory operand with autoincrement addressing
134 ; {   memory operand with pre-modify addressing
135 ; }   memory operand with post-modify addressing
136
137 ;  Note that the 'd', 'f', and 'h' constraints are equivalent.
138 ;  The m constraint is equivalent to 'QT<>{}'
139
140 ;  Note we cannot use the 'g' constraint with Pmode (i.e, QImode)
141 ;  operations since LEGITIMATE_CONSTANT_P accepts SYMBOL_REF.
142 ;  So instead we use 'rIm' for signed operands or 'rLm' for unsigned operands.
143
144 ;  Note that the constraints are used to select the operands
145 ;  for a chosen pattern.  The constraint that requires the fewest
146 ;  instructions to load an operand is chosen.
147
148 ;  Note that the 'r' constraint is mostly only used for src integer register 
149 ;  operands,  while 'c' and 'd' constraints are generally only used for dst
150 ;  integer register operands (the 'r' constraint is the union of the 'c' and
151 ;  'd' constraints).  When a register satisfying the 'd' constraint
152 ;  is used as a dst operand, the CC gets clobbered (except for LDIcond)---but 
153 ;  not for 'c'.
154
155 ;  The 'f' constraint is only for float register operands---when 
156 ;  a register satisfying the 'f' constraint is used as a dst operand,
157 ;  the CC gets clobbered (except for LDFcond).
158
159 ;  The ! in front of the 'b' constraint says to GCC to disparage the
160 ;  use of this constraint.  The 'b' constraint applies only to the SP.
161
162 ;  Note that we deal with the condition code CC like some of the RISC
163 ;  architectures (arm, sh, sparc) where it is stored in a general register,
164 ;  in this case the hard register ST (21).  Unlike these other architectures
165 ;  that do not set the CC with many instructions, the C[34]x architectures
166 ;  sets the CC for many instructions when the destination register is
167 ;  an extended precision register.  While it would have been easier
168 ;  to use the generic cc0 register to store the CC, as with most of
169 ;  the other ported architectures, this constrains the setting and testing
170 ;  of the CC to be consecutive insns.  Thus we would reduce the benefit
171 ;  of scheduling instructions to avoid pipeline conflicts and filling of
172 ;  delayed branch slots.
173
174 ;  Since the C[34]x has many instructions that set the CC, we pay the
175 ;  price of having to explicitly define which insns clobber the CC
176 ;  (rather than using the macro NOTICE_UPDATE_CC). 
177
178 ;  Note that many patterns say that the CC is clobbered when in fact
179 ;  that it may not be (depending on the destination register).
180 ;  We have to cover ourselves if an extended precision register
181 ;  is allocated to the destination register.
182 ;  Unfortunately, it is not easy to tell GCC that the clobbering of CC
183 ;  is register dependent.  If we could tolerate the ST register being
184 ;  copied about, then we could store the CC in a pseudo register and
185 ;  use constructs such as (clobber (match_scratch:CC N "&y,X")) to
186 ;  indicate that the 'y' class (ST register) is clobbered for the
187 ;  first combination of operands but not with the second.
188 ;  I tried this approach for a while but reload got unhappy since I
189 ;  didn't allow it to move the CC around.
190
191 ;  Note that fundamental operations, such as moves, must not clobber the
192 ;  CC.  Thus movqi chooses a move instruction that doesn't clobber the CC.
193 ;  If GCC wants to combine a move with a compare, it is smart enough to
194 ;  chose the move instruction that sets the CC.
195
196 ;  Unfortunately, the C[34]x instruction set does not have arithmetic or
197 ;  logical operations that never touch the CC.  We thus have to assume
198 ;  that the CC may be clobbered at all times.  If we define patterns
199 ;  such as addqi without the clobber of CC, then GCC will be forced
200 ;  to use registers such as the auxiliary registers which can cause
201 ;  horrible pipeline conflicts.  The tradeoff is that GCC can't now
202 ;  sneak in an add instruction between setting and testing of the CC.
203
204 ;  Most of the C[34]x instructions require operands of the following formats,
205 ;  where imm represents an immediate constant, dir a direct memory reference,
206 ;  ind an indirect memory reference, and reg a register:
207
208 ;        src2 (op2)             src1 (op1)      dst (op0)
209 ; imm  dir  ind  reg  |  imm  dir  ind  reg  |  reg      Notes
210 ;---------------------+----------------------+------
211 ; ILH   T   Q<>   r   |   -    -    -    0   |   r       2 operand
212 ;  -    -   S<>   r   |   -    -   S<>   r   |   r       
213 ;  J    -    R    -   |   -    -    R    r   |   r       C4x
214
215 ;  Arithmetic operations use the I, J constraints for immediate constants,
216 ;  while logical operations use the L, J constraints.  Floating point
217 ;  operations use the H constraint for immediate constants.
218
219 ;  With most instructions the src2 and src1 operands are commutative
220 ;  (except for SUB, SUBR, ANDN).  The assembler considers
221 ;  ADDI 10, R0, R1 and ADDI R0, 10, R1 to be equivalent.
222 ;  We thus match src2 and src1 with the src_operand predicate and
223 ;  use valid_operands as the extra constraint to reject invalid
224 ;  operand combinations.  For example, ADDI @foo, @bar, R0.
225
226 ;  Note that we use the ? modifier so that reload doesn't preferentially
227 ;  try the alternative where three registers are acceptable as
228 ;  operands (whenever an operand requires reloading).  Instead it will try
229 ;  the 2 operand form which will produce better code since it won't require
230 ;  a new spill register.
231
232 ;  Note that the floating point representation of 0.0 on the C4x
233 ;  is 0x80000000 (-2147483648).  This value produces a warning
234 ;  message on 32-bit machines about the decimal constant being so large
235 ;  that it is unsigned.
236
237 ;  With two operand instructions patterns having two sets,
238 ;  the compare set must come first to keep the combiner happy.
239 ;  While the combiner seems to cope most of the time with the
240 ;  compare set coming second, it's best to have it first.
241
242 ;
243 ; C4x CONSTANT attributes
244 ;
245 (define_attr "cpu" "c4x,c3x"
246  (const
247   (cond [(symbol_ref "TARGET_C3X") (const_string "c3x")]
248          (const_string "c4x"))))
249
250 ;
251 ; C4x INSN ATTRIBUTES:
252 ;
253 ; lda           load address, non-clobber CC
254 ; store         memory store, non-clobber CC
255 ; load_load     parallel memory loads, non-clobber CC
256 ; load_store    parallel memory load and store, non-clobber CC
257 ; store_load    parallel memory store and load, non-clobber CC
258 ; store_store   parallel memory stores, non-clobber CC
259 ; unary         two operand arithmetic, non-clobber CC
260 ; unarycc       two operand arithmetic, clobber CC
261 ; binary        three operand arithmetic, non-clobber CC
262 ; binarycc      three operand arithmetic, clobber CC
263 ; compare       compare, clobber CC
264 ; call          function call
265 ; rets          return from subroutine
266 ; jump          unconditional branch
267 ; jmpc          conditional branch
268 ; db            decrement and branch (unconditional)
269 ; dbc           decrement and branch (conditional)
270 ; ldp           load DP
271 ; push          stack push
272 ; pop           stack pop
273 ; repeat        block repeat
274 ; repeat_top    block repeat top
275 ; laj           link and jump
276 ; multi         multiple instruction
277 ; misc          nop             (default)
278
279 ;  The only real instructions that affect things are the ones that modify
280 ;  address registers and ones that call or jump.  Note that the number
281 ;  of operands refers to the RTL insn pattern, not the number of explicit
282 ;  operands in the machine instruction.
283 ;
284 (define_attr "type" "lda,store,unary,unarycc,binary,binarycc,compare,call,rets,jump,jmpc,db,dbc,misc,ldp,repeat,repeat_top,laj,load_load,load_store,store_load,store_store,push,pop,multi"
285              (const_string "misc"))
286
287
288 ; Some instructions operate on unsigned data constants, some on signed data
289 ; constants, or the ones complement of unsigned constants.
290 ; This differentiates them.  Default to signed.  This attribute
291 ; is used by the macro SMALL_CONST () (defined in c4x.h) to determine
292 ; whether an immediate integer constant will fit within the instruction,
293 ; or will have to be loaded using direct addressing from memory.
294 ; Note that logical operations assume unsigned integers whereas
295 ; arithmetic operations assume signed integers.  Note that the C4x
296 ; small immediate constant (J) used as src2 in three operand instructions
297 ; is always signed.  not_uint16 refers to a number that fits into 16-bits
298 ; when one's complemented.
299 ;
300 (define_attr "data" "int16,uint16,high_16,not_uint16" (const_string "int16"))
301
302 (define_asm_attributes
303   [(set_attr "type" "multi")])
304
305 ;
306 ; C4x DELAY SLOTS
307 ;
308 ; Define delay slot scheduling for branch and call instructions.
309 ; The C[34]x has three delay slots. Note that none of the three instructions
310 ; that follow a delayed branch can be a Bcond, BcondD, BR, BRD, DBcond,
311 ; DBcondD, CALL, CALLcond, TRAPcond, RETIcond, RETScond, RPTB, RPTS, or IDLE.
312 ;
313 ; Annulled branches are a bit difficult because the next instructions
314 ; are preprocessed.
315 ; The table below shows what phase of the c4x is executed.
316 ;        BccA[TF] label
317 ;        op1             fetch, decode and read executed
318 ;        op2             fetch and decode executed
319 ;        op3             fetch executed
320 ; This means that we can allow any instruction in the last delay slot
321 ; and only instructions which modify registers in the first two. 
322 ; lda cannot be executed in the first delay slot 
323 ; and ldpk cannot be executed in the first two delay slots.
324
325 (define_attr "onlyreg" "false,true"
326        (cond [(eq_attr "type" "unary,unarycc")
327                        (if_then_else (and (match_operand 0 "reg_imm_operand" "")
328                                           (match_operand 1 "reg_imm_operand" ""))
329                                      (const_string "true") (const_string "false"))
330               (eq_attr "type" "binary,binarycc")
331                        (if_then_else (and (match_operand 0 "reg_imm_operand" "")
332                                           (and (match_operand 1 "reg_imm_operand" "")
333                                                (match_operand 2 "reg_imm_operand" "")))
334                                      (const_string "true") (const_string "false"))]
335              (const_string "false")))
336
337 (define_attr "onlyreg_nomod" "false,true"
338        (cond [(eq_attr "type" "unary,unarycc,compare,lda,store")
339                        (if_then_else (and (match_operand 0 "not_modify_reg" "")
340                                           (match_operand 1 "not_modify_reg" ""))
341                                      (const_string "true") (const_string "false"))
342               (eq_attr "type" "binary,binarycc")
343                        (if_then_else (and (match_operand 0 "not_modify_reg" "")
344                                           (and (match_operand 1 "not_modify_reg" "")
345                                                (match_operand 2 "not_modify_reg" "")))
346                                      (const_string "true") (const_string "false"))]
347              (const_string "false")))
348
349 (define_attr "not_repeat_reg" "false,true"
350        (cond [(eq_attr "type" "unary,unarycc,compare,lda,ldp,store")
351                        (if_then_else (and (match_operand 0 "not_rc_reg" "")
352                                           (match_operand 1 "not_rc_reg" ""))
353                                      (const_string "true") (const_string "false"))
354               (eq_attr "type" "binary,binarycc")
355                        (if_then_else (and (match_operand 0 "not_rc_reg" "")
356                                           (and (match_operand 1 "not_rc_reg" "")
357                                                (match_operand 2 "not_rc_reg" "")))
358                                      (const_string "true") (const_string "false"))]
359              (const_string "false")))
360
361 /* Disable compare because the c4x contains a bug. The cmpi insn sets the CC
362    in the read phase of the pipeline instead of the execution phase when
363    two registers are compared.  */
364 (define_attr "in_annul_slot_1" "false,true"
365   (if_then_else (and (and (eq_attr "cpu" "c4x")
366                           (eq_attr "type" "!jump,call,rets,jmpc,compare,db,dbc,repeat,repeat_top,laj,push,pop,lda,ldp,multi"))
367                      (eq_attr "onlyreg" "true"))
368                 (const_string "true")
369                 (const_string "false")))
370
371 (define_attr "in_annul_slot_2" "false,true"
372   (if_then_else (and (and (eq_attr "cpu" "c4x")
373                           (eq_attr "type" "!jump,call,rets,jmpc,db,dbc,repeat,repeat_top,laj,push,pop,ldp,multi"))
374                      (eq_attr "onlyreg_nomod" "true"))
375                 (const_string "true")
376                 (const_string "false")))
377
378 /* Disable ldp because the c4x contains a bug. The ldp insn modifies
379    the dp register when the insn is anulled or not.
380    Also disable autoincrement insns because of a silicon bug.  */
381 (define_attr "in_annul_slot_3" "false,true"
382   (if_then_else (and (and (eq_attr "cpu" "c4x")
383                           (eq_attr "type" "!jump,call,rets,jmpc,db,dbc,repeat,repeat_top,laj,push,pop,ldp,multi"))
384                      (eq_attr "onlyreg_nomod" "true"))
385                 (const_string "true")
386                 (const_string "false")))
387
388 (define_attr "in_delay_slot" "false,true"
389   (if_then_else (eq_attr "type" "!jump,call,rets,jmpc,db,dbc,repeat,repeat_top,laj,multi")
390                 (const_string "true")
391                 (const_string "false")))
392
393 (define_attr "in_repeat_slot" "false,true"
394   (if_then_else (and (eq_attr "cpu" "c4x")
395                      (and (eq_attr "type" "!jump,call,rets,jmpc,db,dbc,repeat,repeat_top,laj,multi")
396                           (eq_attr "not_repeat_reg" "true")))
397                 (const_string "true")
398                 (const_string "false")))
399
400 (define_attr "in_dbc_slot" "false,true"
401   (if_then_else (eq_attr "type" "!jump,call,rets,jmpc,unarycc,binarycc,compare,db,dbc,repeat,repeat_top,laj,multi")
402                 (const_string "true")
403                 (const_string "false")))
404
405 (define_delay (eq_attr "type" "jmpc")
406               [(eq_attr "in_delay_slot" "true")
407                (eq_attr "in_annul_slot_1" "true")
408                (eq_attr "in_annul_slot_1" "true")
409
410                (eq_attr "in_delay_slot" "true")
411                (eq_attr "in_annul_slot_2" "true")
412                (eq_attr "in_annul_slot_2" "true")
413
414                (eq_attr "in_delay_slot" "true")
415                (eq_attr "in_annul_slot_3" "true")
416                (eq_attr "in_annul_slot_3" "true") ])
417
418
419 (define_delay (eq_attr "type" "repeat_top")
420               [(eq_attr "in_repeat_slot" "true") (nil) (nil)
421                (eq_attr "in_repeat_slot" "true") (nil) (nil)
422                (eq_attr "in_repeat_slot" "true") (nil) (nil)])
423
424 (define_delay (eq_attr "type" "jump,db")
425               [(eq_attr "in_delay_slot" "true") (nil) (nil)
426                (eq_attr "in_delay_slot" "true") (nil) (nil)
427                (eq_attr "in_delay_slot" "true") (nil) (nil)])
428
429
430 ; Decrement and branch conditional instructions cannot modify the
431 ; condition codes for the cycles in the delay slots.
432 ;
433 (define_delay (eq_attr "type" "dbc")
434               [(eq_attr "in_dbc_slot" "true") (nil) (nil)
435                (eq_attr "in_dbc_slot" "true") (nil) (nil)
436                (eq_attr "in_dbc_slot" "true") (nil) (nil)])
437
438 ; The LAJ instruction has three delay slots but the last slot is
439 ; used for pushing the return address.  Thus we can only use two slots.
440 ;
441 (define_delay (eq_attr "type" "laj")
442               [(eq_attr "in_delay_slot" "true") (nil) (nil)
443                (eq_attr "in_delay_slot" "true") (nil) (nil)])
444
445 ;
446 ; C4x UNSPEC NUMBERS
447 ;
448 (define_constants
449   [
450    (UNSPEC_BU                   1)
451    (UNSPEC_RPTS                 2)
452    (UNSPEC_LSH                  3)
453    (UNSPEC_CMPHI                4)
454    (UNSPEC_RCPF                 5)
455    (UNSPEC_RND                  6)
456    (UNSPEC_RPTB_FILL            7)
457    (UNSPEC_LOADHF_INT           8)
458    (UNSPEC_STOREHF_INT          9)
459    (UNSPEC_RSQRF                10)
460    (UNSPEC_LOADQF_INT           11)
461    (UNSPEC_STOREQF_INT          12)
462    (UNSPEC_LDIV                 13)
463    (UNSPEC_PUSH_ST              14)
464    (UNSPEC_POP_ST               15)
465    (UNSPEC_PUSH_DP              16)
466    (UNSPEC_POP_DP               17)
467    (UNSPEC_POPQI                18)
468    (UNSPEC_POPQF                19)
469    (UNSPEC_ANDN_ST              20)
470    (UNSPEC_RPTB_INIT            22)
471    (UNSPEC_TOIEEE               23)
472    (UNSPEC_FRIEEE               24)
473   ])
474
475 ;
476 ; C4x PIPELINE MODEL
477 ;
478 ; With the C3x, an external memory write (with no wait states) takes
479 ; two cycles and an external memory read (with no wait states) takes
480 ; one cycle.  However, an external read following an external write
481 ; takes two cycles.  With internal memory, reads and writes take
482 ; half a cycle.
483 ; When a C4x address register is loaded it will not be available for
484 ; an extra machine cycle.  Calculating with a C4x address register
485 ; makes it unavailable for 2 machine cycles.
486 ;
487 ; Just some dummy definitions. The real work is done in c4x_adjust_cost.
488 ; These are needed so the min/max READY_DELAY is known.
489
490 (define_insn_reservation "any_insn" 1 (const_int 1) "nothing")
491 (define_insn_reservation "slowest_insn" 3 (const_int 0) "nothing")
492
493 ; The attribute setar0 is set to 1 for insns where ar0 is a dst operand.
494 ; Note that the attributes unarycc and binarycc do not apply
495 ; if ar0 is a dst operand (only loading an ext. prec. reg. sets CC)
496 (define_attr "setar0" ""
497        (cond [(eq_attr "type" "unary,binary")
498                        (if_then_else (match_operand 0 "ar0_reg_operand" "")
499                                      (const_int 1) (const_int 0))]
500              (const_int 0)))
501
502 (define_attr "setlda_ar0" ""
503        (cond [(eq_attr "type" "lda")
504                        (if_then_else (match_operand 0 "ar0_reg_operand" "")
505                                      (const_int 1) (const_int 0))]
506              (const_int 0)))
507
508 ; The attribute usear0 is set to 1 for insns where ar0 is used
509 ; for addressing, as a src operand, or as a dst operand.
510 (define_attr "usear0" ""
511        (cond [(eq_attr "type" "compare,store")
512                        (if_then_else (match_operand 0 "ar0_mem_operand" "")
513                                      (const_int 1) (const_int 0))
514               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
515                        (if_then_else (match_operand 1 "ar0_mem_operand" "")
516                                      (const_int 1) (const_int 0))
517               (eq_attr "type" "binary,binarycc")
518                        (if_then_else (match_operand 2 "ar0_mem_operand" "")
519                                      (const_int 1) (const_int 0))
520               (eq_attr "type" "db,dbc")
521                        (if_then_else (match_operand 0 "ar0_reg_operand" "")
522                                      (const_int 1) (const_int 0))]
523              (const_int 0)))
524
525 ; The attribute readar0 is set to 1 for insns where ar0 is a src operand.
526 (define_attr "readar0" ""
527        (cond [(eq_attr "type" "compare")
528                        (if_then_else (match_operand 0 "ar0_reg_operand" "")
529                                      (const_int 1) (const_int 0))
530               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
531                        (if_then_else (match_operand 1 "ar0_reg_operand" "")
532                                      (const_int 1) (const_int 0))
533               (eq_attr "type" "binary,binarycc")
534                        (if_then_else (match_operand 2 "ar0_reg_operand" "")
535                                      (const_int 1) (const_int 0))]
536              (const_int 0)))
537
538 (define_attr "setar1" ""
539        (cond [(eq_attr "type" "unary,binary")
540                        (if_then_else (match_operand 0 "ar1_reg_operand" "")
541                                      (const_int 1) (const_int 0))]
542              (const_int 0)))
543
544 (define_attr "setlda_ar1" ""
545        (cond [(eq_attr "type" "lda")
546                        (if_then_else (match_operand 0 "ar1_reg_operand" "")
547                                      (const_int 1) (const_int 0))]
548              (const_int 0)))
549
550 (define_attr "usear1" ""
551        (cond [(eq_attr "type" "compare,store")
552                        (if_then_else (match_operand 0 "ar1_mem_operand" "")
553                                      (const_int 1) (const_int 0))
554               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
555                        (if_then_else (match_operand 1 "ar1_mem_operand" "")
556                                      (const_int 1) (const_int 0))
557               (eq_attr "type" "binary,binarycc")
558                        (if_then_else (match_operand 2 "ar1_mem_operand" "")
559                                      (const_int 1) (const_int 0))
560               (eq_attr "type" "db,dbc")
561                        (if_then_else (match_operand 0 "ar1_reg_operand" "")
562                                      (const_int 1) (const_int 0))]
563              (const_int 0)))
564
565 (define_attr "readar1" ""
566        (cond [(eq_attr "type" "compare")
567                        (if_then_else (match_operand 0 "ar1_reg_operand" "")
568                                      (const_int 1) (const_int 0))
569               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
570                        (if_then_else (match_operand 1 "ar1_reg_operand" "")
571                                      (const_int 1) (const_int 0))
572               (eq_attr "type" "binary,binarycc")
573                        (if_then_else (match_operand 2 "ar1_reg_operand" "")
574                                      (const_int 1) (const_int 0))]
575              (const_int 0)))
576
577 (define_attr "setar2" ""
578        (cond [(eq_attr "type" "unary,binary")
579                        (if_then_else (match_operand 0 "ar2_reg_operand" "")
580                                      (const_int 1) (const_int 0))]
581              (const_int 0)))
582
583 (define_attr "setlda_ar2" ""
584        (cond [(eq_attr "type" "lda")
585                        (if_then_else (match_operand 0 "ar2_reg_operand" "")
586                                      (const_int 1) (const_int 0))]
587              (const_int 0)))
588
589 (define_attr "usear2" ""
590        (cond [(eq_attr "type" "compare,store")
591                        (if_then_else (match_operand 0 "ar2_mem_operand" "")
592                                      (const_int 1) (const_int 0))
593               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
594                        (if_then_else (match_operand 1 "ar2_mem_operand" "")
595                                      (const_int 1) (const_int 0))
596               (eq_attr "type" "binary,binarycc")
597                        (if_then_else (match_operand 2 "ar2_mem_operand" "")
598                                      (const_int 1) (const_int 0))
599               (eq_attr "type" "db,dbc")
600                        (if_then_else (match_operand 0 "ar2_reg_operand" "")
601                                      (const_int 1) (const_int 0))]
602              (const_int 0)))
603
604 (define_attr "readar2" ""
605        (cond [(eq_attr "type" "compare")
606                        (if_then_else (match_operand 0 "ar2_reg_operand" "")
607                                      (const_int 1) (const_int 0))
608               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
609                        (if_then_else (match_operand 1 "ar2_reg_operand" "")
610                                      (const_int 1) (const_int 0))
611               (eq_attr "type" "binary,binarycc")
612                        (if_then_else (match_operand 2 "ar2_reg_operand" "")
613                                      (const_int 1) (const_int 0))]
614              (const_int 0)))
615
616 (define_attr "setar3" ""
617        (cond [(eq_attr "type" "unary,binary")
618                        (if_then_else (match_operand 0 "ar3_reg_operand" "")
619                                      (const_int 1) (const_int 0))]
620              (const_int 0)))
621
622 (define_attr "setlda_ar3" ""
623        (cond [(eq_attr "type" "lda")
624                        (if_then_else (match_operand 0 "ar3_reg_operand" "")
625                                      (const_int 1) (const_int 0))]
626              (const_int 0)))
627
628 (define_attr "usear3" ""
629        (cond [(eq_attr "type" "compare,store")
630                        (if_then_else (match_operand 0 "ar3_mem_operand" "")
631                                      (const_int 1) (const_int 0))
632               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
633                        (if_then_else (match_operand 1 "ar3_mem_operand" "")
634                                      (const_int 1) (const_int 0))
635               (eq_attr "type" "binary,binarycc")
636                        (if_then_else (match_operand 2 "ar3_mem_operand" "")
637                                      (const_int 1) (const_int 0))
638               (eq_attr "type" "db,dbc")
639                        (if_then_else (match_operand 0 "ar3_reg_operand" "")
640                                      (const_int 1) (const_int 0))]
641              (const_int 0)))
642
643 (define_attr "readar3" ""
644        (cond [(eq_attr "type" "compare")
645                        (if_then_else (match_operand 0 "ar3_reg_operand" "")
646                                      (const_int 1) (const_int 0))
647               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
648                        (if_then_else (match_operand 1 "ar3_reg_operand" "")
649                                      (const_int 1) (const_int 0))
650               (eq_attr "type" "binary,binarycc")
651                        (if_then_else (match_operand 2 "ar3_reg_operand" "")
652                                      (const_int 1) (const_int 0))]
653              (const_int 0)))
654
655 (define_attr "setar4" ""
656        (cond [(eq_attr "type" "unary,binary")
657                        (if_then_else (match_operand 0 "ar4_reg_operand" "")
658                                      (const_int 1) (const_int 0))]
659              (const_int 0)))
660
661 (define_attr "setlda_ar4" ""
662        (cond [(eq_attr "type" "lda")
663                        (if_then_else (match_operand 0 "ar4_reg_operand" "")
664                                      (const_int 1) (const_int 0))]
665              (const_int 0)))
666
667 (define_attr "usear4" ""
668        (cond [(eq_attr "type" "compare,store")
669                        (if_then_else (match_operand 0 "ar4_mem_operand" "")
670                                      (const_int 1) (const_int 0))
671               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
672                        (if_then_else (match_operand 1 "ar4_mem_operand" "")
673                                      (const_int 1) (const_int 0))
674               (eq_attr "type" "binary,binarycc")
675                        (if_then_else (match_operand 2 "ar4_mem_operand" "")
676                                      (const_int 1) (const_int 0))
677               (eq_attr "type" "db,dbc")
678                        (if_then_else (match_operand 0 "ar4_reg_operand" "")
679                                      (const_int 1) (const_int 0))]
680              (const_int 0)))
681
682 (define_attr "readar4" ""
683        (cond [(eq_attr "type" "compare")
684                        (if_then_else (match_operand 0 "ar4_reg_operand" "")
685                                      (const_int 1) (const_int 0))
686               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
687                        (if_then_else (match_operand 1 "ar4_reg_operand" "")
688                                      (const_int 1) (const_int 0))
689               (eq_attr "type" "binary,binarycc")
690                        (if_then_else (match_operand 2 "ar4_reg_operand" "")
691                                      (const_int 1) (const_int 0))]
692              (const_int 0)))
693
694 (define_attr "setar5" ""
695        (cond [(eq_attr "type" "unary,binary")
696                        (if_then_else (match_operand 0 "ar5_reg_operand" "")
697                                      (const_int 1) (const_int 0))]
698              (const_int 0)))
699
700 (define_attr "setlda_ar5" ""
701        (cond [(eq_attr "type" "lda")
702                        (if_then_else (match_operand 0 "ar5_reg_operand" "")
703                                      (const_int 1) (const_int 0))]
704              (const_int 0)))
705
706 (define_attr "usear5" ""
707        (cond [(eq_attr "type" "compare,store")
708                        (if_then_else (match_operand 0 "ar5_mem_operand" "")
709                                      (const_int 1) (const_int 0))
710               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
711                        (if_then_else (match_operand 1 "ar5_mem_operand" "")
712                                      (const_int 1) (const_int 0))
713               (eq_attr "type" "binary,binarycc")
714                        (if_then_else (match_operand 2 "ar5_mem_operand" "")
715                                      (const_int 1) (const_int 0))
716               (eq_attr "type" "db,dbc")
717                        (if_then_else (match_operand 0 "ar5_reg_operand" "")
718                                      (const_int 1) (const_int 0))]
719              (const_int 0)))
720
721 (define_attr "readar5" ""
722        (cond [(eq_attr "type" "compare")
723                        (if_then_else (match_operand 0 "ar5_reg_operand" "")
724                                      (const_int 1) (const_int 0))
725               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
726                        (if_then_else (match_operand 1 "ar5_reg_operand" "")
727                                      (const_int 1) (const_int 0))
728               (eq_attr "type" "binary,binarycc")
729                        (if_then_else (match_operand 2 "ar5_reg_operand" "")
730                                      (const_int 1) (const_int 0))]
731              (const_int 0)))
732
733 (define_attr "setar6" ""
734        (cond [(eq_attr "type" "unary,binary")
735                        (if_then_else (match_operand 0 "ar6_reg_operand" "")
736                                      (const_int 1) (const_int 0))]
737              (const_int 0)))
738
739 (define_attr "setlda_ar6" ""
740        (cond [(eq_attr "type" "lda")
741                        (if_then_else (match_operand 0 "ar6_reg_operand" "")
742                                      (const_int 1) (const_int 0))]
743              (const_int 0)))
744
745 (define_attr "usear6" ""
746        (cond [(eq_attr "type" "compare,store")
747                        (if_then_else (match_operand 0 "ar6_mem_operand" "")
748                                      (const_int 1) (const_int 0))
749               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
750                        (if_then_else (match_operand 1 "ar6_mem_operand" "")
751                                      (const_int 1) (const_int 0))
752               (eq_attr "type" "binary,binarycc")
753                        (if_then_else (match_operand 2 "ar6_mem_operand" "")
754                                      (const_int 1) (const_int 0))
755               (eq_attr "type" "db,dbc")
756                        (if_then_else (match_operand 0 "ar6_reg_operand" "")
757                                      (const_int 1) (const_int 0))]
758              (const_int 0)))
759
760 (define_attr "readar6" ""
761        (cond [(eq_attr "type" "compare")
762                        (if_then_else (match_operand 0 "ar6_reg_operand" "")
763                                      (const_int 1) (const_int 0))
764               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
765                        (if_then_else (match_operand 1 "ar6_reg_operand" "")
766                                      (const_int 1) (const_int 0))
767               (eq_attr "type" "binary,binarycc")
768                        (if_then_else (match_operand 2 "ar6_reg_operand" "")
769                                      (const_int 1) (const_int 0))]
770              (const_int 0)))
771
772 (define_attr "setar7" ""
773        (cond [(eq_attr "type" "unary,binary")
774                        (if_then_else (match_operand 0 "ar7_reg_operand" "")
775                                      (const_int 1) (const_int 0))]
776              (const_int 0)))
777
778 (define_attr "setlda_ar7" ""
779        (cond [(eq_attr "type" "lda")
780                        (if_then_else (match_operand 0 "ar7_reg_operand" "")
781                                      (const_int 1) (const_int 0))]
782              (const_int 0)))
783
784 (define_attr "usear7" ""
785        (cond [(eq_attr "type" "compare,store")
786                        (if_then_else (match_operand 0 "ar7_mem_operand" "")
787                                      (const_int 1) (const_int 0))
788               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
789                        (if_then_else (match_operand 1 "ar7_mem_operand" "")
790                                      (const_int 1) (const_int 0))
791               (eq_attr "type" "binary,binarycc")
792                        (if_then_else (match_operand 2 "ar7_mem_operand" "")
793                                      (const_int 1) (const_int 0))
794               (eq_attr "type" "db,dbc")
795                        (if_then_else (match_operand 0 "ar7_reg_operand" "")
796                                      (const_int 1) (const_int 0))]
797              (const_int 0)))
798
799 (define_attr "readar7" ""
800        (cond [(eq_attr "type" "compare")
801                        (if_then_else (match_operand 0 "ar7_reg_operand" "")
802                                      (const_int 1) (const_int 0))
803               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
804                        (if_then_else (match_operand 1 "ar7_reg_operand" "")
805                                      (const_int 1) (const_int 0))
806               (eq_attr "type" "binary,binarycc")
807                        (if_then_else (match_operand 2 "ar7_reg_operand" "")
808                                      (const_int 1) (const_int 0))]
809              (const_int 0)))
810
811 (define_attr "setir0" ""
812        (cond [(eq_attr "type" "unary,binary")
813                        (if_then_else (match_operand 0 "ir0_reg_operand" "")
814                                      (const_int 1) (const_int 0))]
815              (const_int 0)))
816
817 (define_attr "setlda_ir0" ""
818        (cond [(eq_attr "type" "lda")
819                        (if_then_else (match_operand 0 "ir0_reg_operand" "")
820                                      (const_int 1) (const_int 0))]
821              (const_int 0)))
822
823 (define_attr "useir0" ""
824        (cond [(eq_attr "type" "compare,store")
825                        (if_then_else (match_operand 0 "ir0_mem_operand" "")
826                                      (const_int 1) (const_int 0))
827               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
828                        (if_then_else (match_operand 1 "ir0_mem_operand" "")
829                                      (const_int 1) (const_int 0))
830               (eq_attr "type" "binary,binarycc")
831                        (if_then_else (match_operand 2 "ir0_mem_operand" "")
832                                      (const_int 1) (const_int 0))]
833              (const_int 0)))
834
835 (define_attr "setir1" ""
836        (cond [(eq_attr "type" "unary,binary")
837                        (if_then_else (match_operand 0 "ir1_reg_operand" "")
838                                      (const_int 1) (const_int 0))]
839              (const_int 0)))
840
841 (define_attr "setlda_ir1" ""
842        (cond [(eq_attr "type" "lda")
843                        (if_then_else (match_operand 0 "ir1_reg_operand" "")
844                                      (const_int 1) (const_int 0))]
845              (const_int 0)))
846
847 (define_attr "useir1" ""
848        (cond [(eq_attr "type" "compare,store")
849                        (if_then_else (match_operand 0 "ir1_mem_operand" "")
850                                      (const_int 1) (const_int 0))
851               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc")
852                        (if_then_else (match_operand 1 "ir1_mem_operand" "")
853                                      (const_int 1) (const_int 0))
854               (eq_attr "type" "binary,binarycc")
855                        (if_then_else (match_operand 2 "ir1_mem_operand" "")
856                                      (const_int 1) (const_int 0))]
857              (const_int 0)))
858
859 ; With the C3x, things are simpler but slower, i.e. more pipeline conflicts :(
860 ; There are three functional groups:
861 ; (1) AR0-AR7, IR0-IR1, BK
862 ; (2) DP
863 ; (3) SP
864 ;
865 ; When a register in one of these functional groups is loaded,
866 ; the contents of that or any other register in its group
867 ; will not be available to the next instruction for 2 machine cycles.
868 ; Similarly, when a register in one of the functional groups is read
869 ; excepting (IR0-IR1, BK, DP) the contents of that or any other register
870 ; in its group will not be available to the next instruction for
871 ; 1 machine cycle.
872 ;
873 ; Let's ignore functional groups 2 and 3 for now, since they are not
874 ; so important.
875
876 (define_attr "setgroup1" ""
877        (cond [(eq_attr "type" "lda,unary,binary")
878                   (if_then_else (match_operand 0 "group1_reg_operand" "")
879                                 (const_int 1) (const_int 0))]
880              (const_int 0)))
881
882 (define_attr "usegroup1" ""
883        (cond [(eq_attr "type" "compare,store,store_store,store_load")
884               (if_then_else (match_operand 0 "group1_mem_operand" "")
885                             (const_int 1) (const_int 0))
886               (eq_attr "type" "compare,lda,unary,unarycc,binary,binarycc,load_load,load_store")
887               (if_then_else (match_operand 1 "group1_mem_operand" "")
888                             (const_int 1) (const_int 0))
889               (eq_attr "type" "store_store,load_store")
890               (if_then_else (match_operand 2 "group1_mem_operand" "")
891                             (const_int 1) (const_int 0))
892               (eq_attr "type" "load_load,store_load")
893               (if_then_else (match_operand 3 "group1_mem_operand" "")
894                             (const_int 1) (const_int 0))]
895              (const_int 0)))
896
897 (define_attr "readarx" ""
898        (cond [(eq_attr "type" "compare")
899               (if_then_else (match_operand 0 "arx_reg_operand" "")
900                             (const_int 1) (const_int 0))
901               (eq_attr "type" "compare,store,lda,unary,unarycc,binary,binarycc")
902               (if_then_else (match_operand 1 "arx_reg_operand" "")
903                             (const_int 1) (const_int 0))
904               (eq_attr "type" "binary,binarycc")
905               (if_then_else (match_operand 2 "arx_reg_operand" "")
906                             (const_int 1) (const_int 0))]
907              (const_int 0)))
908
909 (include "predicates.md")
910
911 ;
912 ; C4x INSN PATTERNS:
913 ;
914 ; Note that the movMM and addP patterns can be called during reload
915 ; so we need to take special care with theses patterns since
916 ; we cannot blindly clobber CC or generate new pseudo registers.
917
918 ;
919 ; TWO OPERAND INTEGER INSTRUCTIONS
920 ;
921
922 ;
923 ; LDP/LDPK
924 ;
925 (define_insn "set_ldp"
926   [(set (match_operand:QI 0 "dp_reg_operand" "=z")
927         (high:QI (match_operand:QI 1 "" "")))]
928   "! TARGET_SMALL"
929   "* return (TARGET_C3X) ? \"ldp\\t%A1\" : \"ldpk\\t%A1\";"
930   [(set_attr "type" "ldp")])
931
932 (define_insn "set_ldp_prologue"
933   [(set (match_operand:QI 0 "dp_reg_operand" "=z")
934         (high:QI (match_operand:QI 1 "" "")))]
935   "TARGET_SMALL && TARGET_PARANOID"
936   "* return (TARGET_C3X) ? \"ldp\\t@data_sec\" : \"ldpk\\t@data_sec\";"
937   [(set_attr "type" "ldp")])
938
939 (define_insn "set_high"
940   [(set (match_operand:QI 0 "std_reg_operand" "=c")
941         (high:QI (match_operand:QI 1 "symbolic_address_operand" "")))]
942   "! TARGET_C3X && ! TARGET_TI"
943   "ldhi\\t^%H1,%0"
944   [(set_attr "type" "unary")])
945
946 (define_insn "set_lo_sum"
947   [(set (match_operand:QI 0 "std_reg_operand" "+c")
948         (lo_sum:QI (match_dup 0)
949                    (match_operand:QI 1 "symbolic_address_operand" "")))]
950   "! TARGET_TI"
951   "or\\t#%H1,%0"
952   [(set_attr "type" "unary")])
953
954 (define_split
955   [(set (match_operand:QI 0 "std_reg_operand" "")
956         (match_operand:QI 1 "symbolic_address_operand" ""))]
957   "reload_completed && ! TARGET_C3X && ! TARGET_TI"
958   [(set (match_dup 0) (high:QI (match_dup 1)))
959    (set (match_dup 0) (lo_sum:QI (match_dup 0) (match_dup 1)))]
960   "")
961
962 (define_split
963   [(set (match_operand:QI 0 "reg_operand" "")
964         (match_operand:QI 1 "const_int_operand" ""))
965    (clobber (reg:QI 16))]
966   "! TARGET_C3X
967    && ! IS_INT16_CONST (INTVAL (operands[1]))
968    && ! IS_HIGH_CONST (INTVAL (operands[1]))
969    && reload_completed
970    && std_reg_operand (operands[0], QImode)"
971   [(set (match_dup 0) (match_dup 2))
972    (set (match_dup 0) (ior:QI (match_dup 0) (match_dup 3)))]
973   "
974 {
975    operands[2] = GEN_INT (INTVAL (operands[1]) & ~0xffff);
976    operands[3] = GEN_INT (INTVAL (operands[1]) & 0xffff);
977 }")
978
979 (define_split
980   [(set (match_operand:QI 0 "reg_operand" "")
981         (match_operand:QI 1 "const_int_operand" ""))]
982   "! TARGET_C3X
983    && ! IS_INT16_CONST (INTVAL (operands[1]))
984    && ! IS_HIGH_CONST (INTVAL (operands[1]))
985    && reload_completed
986    && std_reg_operand (operands[0], QImode)"
987   [(set (match_dup 0) (match_dup 2))
988    (set (match_dup 0) (ior:QI (match_dup 0) (match_dup 3)))]
989   "
990 {
991    operands[2] = GEN_INT (INTVAL (operands[1]) & ~0xffff);
992    operands[3] = GEN_INT (INTVAL (operands[1]) & 0xffff);
993 }")
994
995 (define_split
996   [(set (match_operand:QI 0 "reg_operand" "")
997         (match_operand:QI 1 "const_int_operand" ""))
998    (clobber (reg:QI 16))]
999   "TARGET_C3X && ! TARGET_SMALL
1000    && ! IS_INT16_CONST (INTVAL (operands[1]))
1001    && reload_completed
1002    && std_reg_operand (operands[0], QImode)
1003    && c4x_shiftable_constant (operands[1]) < 0"
1004   [(set (match_dup 0) (match_dup 2))
1005    (set (match_dup 0) (ashift:QI (match_dup 0) (match_dup 4)))
1006    (set (match_dup 0) (ior:QI (match_dup 0) (match_dup 3)))]
1007   "
1008 {
1009    /* Generate two's complement value of 16 MSBs.  */
1010    operands[2] = GEN_INT ((((INTVAL (operands[1]) >> 16) & 0xffff)
1011                            - 0x8000) ^ ~0x7fff);
1012    operands[3] = GEN_INT (INTVAL (operands[1]) & 0xffff);
1013    operands[4] = GEN_INT (16);
1014 }")
1015
1016 (define_split
1017   [(set (match_operand:QI 0 "reg_operand" "")
1018         (match_operand:QI 1 "const_int_operand" ""))]
1019   "TARGET_C3X && ! TARGET_SMALL
1020    && ! IS_INT16_CONST (INTVAL (operands[1]))
1021    && reload_completed
1022    && std_reg_operand (operands[0], QImode)
1023    && c4x_shiftable_constant (operands[1]) < 0"
1024   [(set (match_dup 0) (match_dup 2))
1025    (set (match_dup 0) (ashift:QI (match_dup 0) (match_dup 4)))
1026    (set (match_dup 0) (ior:QI (match_dup 0) (match_dup 3)))]
1027   "
1028 {
1029    /* Generate two's complement value of 16 MSBs.  */
1030    operands[2] = GEN_INT ((((INTVAL (operands[1]) >> 16) & 0xffff)
1031                            - 0x8000) ^ ~0x7fff);
1032    operands[3] = GEN_INT (INTVAL (operands[1]) & 0xffff);
1033    operands[4] = GEN_INT (16);
1034 }")
1035
1036 (define_split
1037   [(set (match_operand:QI 0 "reg_operand" "")
1038         (match_operand:QI 1 "const_int_operand" ""))
1039    (clobber (reg:QI 16))]
1040   "TARGET_C3X
1041    && ! IS_INT16_CONST (INTVAL (operands[1]))
1042    && reload_completed
1043    && std_reg_operand (operands[0], QImode)
1044    && c4x_shiftable_constant (operands[1]) >= 0"
1045   [(set (match_dup 0) (match_dup 2))
1046    (set (match_dup 0) (ashift:QI (match_dup 0) (match_dup 3)))]
1047   "
1048 {
1049    /* Generate two's complement value of MSBs.  */
1050    int shift = c4x_shiftable_constant (operands[1]);
1051
1052    operands[2] = GEN_INT ((((INTVAL (operands[1]) >> shift) & 0xffff)
1053                            - 0x8000) ^ ~0x7fff);
1054    operands[3] = GEN_INT (shift);
1055 }")
1056
1057 (define_split
1058   [(set (match_operand:QI 0 "reg_operand" "")
1059         (match_operand:QI 1 "const_int_operand" ""))]
1060   "TARGET_C3X
1061    && ! IS_INT16_CONST (INTVAL (operands[1]))
1062    && reload_completed
1063    && std_reg_operand (operands[0], QImode)
1064    && c4x_shiftable_constant (operands[1]) >= 0"
1065   [(set (match_dup 0) (match_dup 2))
1066    (set (match_dup 0) (ashift:QI (match_dup 0) (match_dup 3)))]
1067   "
1068 {
1069    /* Generate two's complement value of MSBs.  */
1070    int shift = c4x_shiftable_constant (operands[1]);
1071
1072    operands[2] = GEN_INT ((((INTVAL (operands[1]) >> shift) & 0xffff)
1073                             - 0x8000) ^ ~0x7fff);
1074    operands[3] = GEN_INT (shift);
1075 }")
1076
1077 (define_split
1078   [(set (match_operand:QI 0 "reg_operand" "")
1079         (match_operand:QI 1 "const_int_operand" ""))
1080    (clobber (reg:QI 16))]
1081   "! TARGET_SMALL
1082    && ! IS_INT16_CONST (INTVAL (operands[1]))
1083    && ! IS_HIGH_CONST (INTVAL (operands[1]))
1084    && reload_completed
1085    && ! std_reg_operand (operands[0], QImode)"
1086   [(set (match_dup 2) (high:QI (match_dup 3)))
1087    (set (match_dup 0) (match_dup 4))
1088    (use (match_dup 1))]
1089   "
1090 {
1091    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1092    operands[2] = dp_reg;
1093    operands[3] = force_const_mem (Pmode, operands[1]);
1094    operands[4] = change_address (operands[3], QImode,
1095                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1096                                                  XEXP (operands[3], 0)));
1097    operands[3] = XEXP (operands[3], 0);
1098 }")
1099
1100 (define_split
1101   [(set (match_operand:QI 0 "reg_operand" "")
1102         (match_operand:QI 1 "const_int_operand" ""))]
1103   "! TARGET_SMALL
1104    && ! IS_INT16_CONST (INTVAL (operands[1]))
1105    && ! IS_HIGH_CONST (INTVAL (operands[1]))
1106    && reload_completed
1107    && ! std_reg_operand (operands[0], QImode)"
1108   [(set (match_dup 2) (high:QI (match_dup 3)))
1109    (set (match_dup 0) (match_dup 4))
1110    (use (match_dup 1))]
1111   "
1112 {
1113    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1114    operands[2] = dp_reg;
1115    operands[3] = force_const_mem (Pmode, operands[1]);
1116    operands[4] = change_address (operands[3], QImode,
1117                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1118                                                  XEXP (operands[3], 0)));
1119    operands[3] = XEXP (operands[3], 0);
1120 }")
1121
1122 (define_split
1123   [(set (match_operand:QI 0 "reg_operand" "")
1124         (match_operand:QI 1 "const_int_operand" ""))
1125    (clobber (reg:QI 16))]
1126   "TARGET_SMALL
1127    && ! IS_INT16_CONST (INTVAL (operands[1]))
1128    && ! IS_HIGH_CONST (INTVAL (operands[1]))
1129    && reload_completed
1130    && ((TARGET_C3X && c4x_shiftable_constant (operands[1]) < 0)
1131        || ! std_reg_operand (operands[0], QImode))"
1132   [(set (match_dup 0) (match_dup 2))
1133    (use (match_dup 1))]
1134   "
1135 {
1136    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1137    operands[2] = force_const_mem (Pmode, operands[1]);
1138    operands[2] = change_address (operands[2], QImode,
1139                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1140                                                  XEXP (operands[2], 0)));
1141 }")
1142
1143 (define_split
1144   [(set (match_operand:QI 0 "reg_operand" "")
1145         (match_operand:QI 1 "const_int_operand" ""))]
1146   "TARGET_SMALL
1147    && ! IS_INT16_CONST (INTVAL (operands[1]))
1148    && ! IS_HIGH_CONST (INTVAL (operands[1]))
1149    && reload_completed
1150    && ((TARGET_C3X && c4x_shiftable_constant (operands[1]) < 0)
1151        || ! std_reg_operand (operands[0], QImode))"
1152   [(set (match_dup 0) (match_dup 2))
1153    (use (match_dup 1))]
1154   "
1155 {
1156    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1157    operands[2] = force_const_mem (Pmode, operands[1]);
1158    operands[2] = change_address (operands[2], QImode,
1159                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1160                                                  XEXP (operands[2], 0)));
1161 }")
1162
1163 (define_split
1164   [(set (match_operand:HI 0 "reg_operand" "")
1165         (match_operand:HI 1 "const_int_operand" ""))
1166    (clobber (reg:QI 16))]
1167   "reload_completed"
1168   [(set (match_dup 2) (match_dup 4))
1169    (set (match_dup 3) (match_dup 5))]
1170   "
1171 {
1172    operands[2] = c4x_operand_subword (operands[0], 0, 1, HImode);
1173    operands[3] = c4x_operand_subword (operands[0], 1, 1, HImode);
1174    operands[4] = c4x_operand_subword (operands[1], 0, 1, HImode);
1175    operands[5] = c4x_operand_subword (operands[1], 1, 1, HImode);
1176 }")
1177
1178
1179 ; We need to clobber the DP reg to be safe in case we
1180 ; need to load this address from memory
1181 (define_insn "load_immed_address"
1182   [(set (match_operand:QI 0 "reg_operand" "=a?x?c*r")
1183         (match_operand:QI 1 "symbolic_address_operand" ""))
1184    (clobber (reg:QI 16))]
1185   "TARGET_LOAD_ADDRESS"
1186   "#"
1187   [(set_attr "type" "multi")])
1188
1189
1190 (define_split
1191   [(set (match_operand:QI 0 "std_reg_operand" "")
1192         (match_operand:QI 1 "symbolic_address_operand" ""))
1193    (clobber (reg:QI 16))]
1194   "reload_completed && ! TARGET_C3X && ! TARGET_TI"
1195   [(set (match_dup 0) (high:QI (match_dup 1)))
1196    (set (match_dup 0) (lo_sum:QI (match_dup 0) (match_dup 1)))]
1197   "")
1198
1199 ; CC has been selected to load a symbolic address.  We force the address
1200 ; into memory and then generate LDP and LDIU insns.
1201 ; This is also required for the C30 if we pretend that we can 
1202 ; easily load symbolic addresses into a register.
1203 (define_split
1204   [(set (match_operand:QI 0 "reg_operand" "")
1205         (match_operand:QI 1 "symbolic_address_operand" ""))
1206    (clobber (reg:QI 16))]
1207   "reload_completed
1208    && ! TARGET_SMALL 
1209    && (TARGET_C3X || TARGET_TI || ! std_reg_operand (operands[0], QImode))"
1210   [(set (match_dup 2) (high:QI (match_dup 3)))
1211    (set (match_dup 0) (match_dup 4))
1212    (use (match_dup 1))]
1213   "
1214 {
1215    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1216    operands[2] = dp_reg;
1217    operands[3] = force_const_mem (Pmode, operands[1]);
1218    operands[4] = change_address (operands[3], QImode,
1219                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1220                                                  XEXP (operands[3], 0)));
1221    operands[3] = XEXP (operands[3], 0);
1222 }")
1223
1224 ; This pattern is similar to the above but does not emit a LDP
1225 ; for the small memory model.
1226 (define_split
1227   [(set (match_operand:QI 0 "reg_operand" "")
1228         (match_operand:QI 1 "symbolic_address_operand" ""))
1229    (clobber (reg:QI 16))]
1230   "reload_completed
1231    && TARGET_SMALL
1232    && (TARGET_C3X || TARGET_TI || ! std_reg_operand (operands[0], QImode))"
1233   [(set (match_dup 0) (match_dup 2))
1234    (use (match_dup 1))]
1235   "
1236 {  
1237    rtx dp_reg = gen_rtx_REG (Pmode, DP_REGNO);
1238    operands[2] = force_const_mem (Pmode, operands[1]);
1239    operands[2] = change_address (operands[2], QImode,
1240                                  gen_rtx_LO_SUM (Pmode, dp_reg,
1241                                                  XEXP (operands[2], 0)));
1242 }")
1243
1244 (define_insn "loadhi_big_constant"
1245   [(set (match_operand:HI 0 "reg_operand" "=c*d")
1246         (match_operand:HI 1 "const_int_operand" ""))
1247    (clobber (reg:QI 16))]
1248   ""
1249   "#"
1250   [(set_attr "type" "multi")])
1251
1252 ;
1253 ; LDIU/LDA/STI/STIK
1254 ;
1255 ; The following moves will not set the condition codes register.
1256 ;
1257
1258 ; This must come before the general case
1259 (define_insn "*movqi_stik"
1260   [(set (match_operand:QI 0 "memory_operand" "=m")
1261         (match_operand:QI 1 "stik_const_operand" "K"))]
1262   "! TARGET_C3X"
1263   "stik\\t%1,%0"
1264   [(set_attr "type" "store")])
1265
1266 (define_insn "loadqi_big_constant"
1267   [(set (match_operand:QI 0 "reg_operand" "=c*d")
1268         (match_operand:QI 1 "const_int_operand" ""))
1269    (clobber (reg:QI 16))]
1270   "! IS_INT16_CONST (INTVAL (operands[1]))
1271    && ! IS_HIGH_CONST (INTVAL (operands[1]))"
1272   "#"
1273   [(set_attr "type" "multi")])
1274
1275 ; We must provide an alternative to store to memory in case we have to
1276 ; spill a register.
1277 (define_insn "movqi_noclobber"
1278   [(set (match_operand:QI 0 "dst_operand" "=d,*c,m,r")
1279         (match_operand:QI 1 "src_hi_operand" "rIm,rIm,r,O"))]
1280   "(REG_P (operands[0]) || REG_P (operands[1])
1281     || GET_CODE (operands[0]) == SUBREG
1282     || GET_CODE (operands[1]) == SUBREG)
1283     && ! symbolic_address_operand (operands[1], QImode)"
1284   "*
1285    if (which_alternative == 2)
1286      return \"sti\\t%1,%0\";
1287
1288    if (! TARGET_C3X && which_alternative == 3)
1289      {
1290        operands[1] = GEN_INT ((INTVAL (operands[1]) >> 16) & 0xffff);
1291        return \"ldhi\\t%1,%0\";
1292      }
1293
1294    /* The lda instruction cannot use the same register as source
1295       and destination.  */
1296    if (! TARGET_C3X && which_alternative == 1
1297        && (   IS_ADDR_REG (operands[0])
1298            || IS_INDEX_REG (operands[0])
1299            || IS_SP_REG (operands[0]))
1300        && (REGNO (operands[0]) != REGNO (operands[1])))
1301       return \"lda\\t%1,%0\";
1302    return \"ldiu\\t%1,%0\";
1303   "
1304   [(set_attr "type" "unary,lda,store,unary")
1305    (set_attr "data" "int16,int16,int16,high_16")])
1306
1307 ;
1308 ; LDI
1309 ;
1310
1311 ; We shouldn't need these peepholes, but the combiner seems to miss them...
1312 (define_peephole
1313   [(set (match_operand:QI 0 "ext_reg_operand" "=d")
1314         (match_operand:QI 1 "src_operand" "rIm"))
1315    (set (reg:CC 21)
1316         (compare:CC (match_dup 0) (const_int 0)))]
1317   ""
1318   "ldi\\t%1,%0"
1319   [(set_attr "type" "unarycc")
1320    (set_attr "data" "int16")])
1321
1322 (define_insn "*movqi_set"
1323   [(set (reg:CC 21)
1324         (compare:CC (match_operand:QI 1 "src_operand" "rIm") 
1325                     (const_int 0)))
1326    (set (match_operand:QI 0 "ext_reg_operand" "=d")
1327         (match_dup 1))]
1328   ""
1329   "ldi\\t%1,%0"
1330   [(set_attr "type" "unarycc")
1331    (set_attr "data" "int16")])
1332
1333 ; This pattern probably gets in the way and requires a scratch register
1334 ; when a simple compare with zero will suffice.
1335 ;(define_insn "*movqi_test"
1336 ; [(set (reg:CC 21)
1337 ;       (compare:CC (match_operand:QI 1 "src_operand" "rIm") 
1338 ;                   (const_int 0)))
1339 ;  (clobber (match_scratch:QI 0 "=d"))]
1340 ; ""
1341 ; "@
1342 ;  ldi\\t%1,%0"
1343 ;  [(set_attr "type" "unarycc")
1344 ;   (set_attr "data" "int16")])
1345
1346 ;  If one of the operands is not a register, then we should
1347 ;  emit two insns, using a scratch register.  This will produce
1348 ;  better code in loops if the source operand is invariant, since
1349 ;  the source reload can be optimized out.  During reload we cannot
1350 ;  use change_address or force_reg which will allocate new pseudo regs.
1351
1352 ;  Unlike most other insns, the move insns can't be split with
1353 ;  different predicates, because register spilling and other parts of
1354 ;  the compiler, have memoized the insn number already.
1355
1356 (define_expand "movqi"
1357   [(set (match_operand:QI 0 "general_operand" "")
1358         (match_operand:QI 1 "general_operand" ""))]
1359   ""
1360   "
1361 {
1362   if (c4x_emit_move_sequence (operands, QImode))
1363     DONE;
1364 }")
1365
1366
1367 ; As far as GCC is concerned, the moves are performed in parallel
1368 ; thus it must be convinced that there is no aliasing.
1369 ; It also assumes that the input operands are simultaneously loaded
1370 ; and then the output operands are simultaneously stored.
1371 ; With the C4x, if there are parallel stores to the same address
1372 ; both stores are executed.
1373 ; If there is a parallel load and store to the same address,
1374 ; the load is performed first.
1375 ; The problem with this pattern is that reload can spoil
1376 ; the show when it eliminates a reference to the frame pointer.
1377 ; This can invalidate the memory addressing mode, i.e., when
1378 ; the displacement is greater than 1.
1379 (define_insn "movqi_parallel"
1380   [(set (match_operand:QI 0 "parallel_operand" "=q,S<>!V,q,S<>!V")
1381         (match_operand:QI 1 "parallel_operand" "S<>!V,q,S<>!V,q"))
1382    (set (match_operand:QI 2 "parallel_operand" "=q,S<>!V,S<>!V,q")
1383         (match_operand:QI 3 "parallel_operand" "S<>!V,q,q,S<>!V"))]
1384   "TARGET_PARALLEL && valid_parallel_load_store (operands, QImode)"
1385   "@
1386    ldi1\\t%1,%0\\n||\\tldi2\\t%3,%2
1387    sti1\\t%1,%0\\n||\\tsti2\\t%3,%2
1388    ldi\\t%1,%0\\n||\\tsti\\t%3,%2
1389    ldi\\t%3,%2\\n||\\tsti\\t%1,%0"
1390   [(set_attr "type" "load_load,store_store,load_store,store_load")])
1391
1392 ;
1393 ; PUSH/POP
1394 ;
1395 (define_insn "pushqi"
1396   [(set (mem:QI (pre_inc:QI (reg:QI 20)))
1397         (match_operand:QI 0 "reg_operand" "r"))]
1398   ""
1399   "push\\t%0"
1400   [(set_attr "type" "push")])
1401
1402 (define_insn "push_st"
1403   [(set (mem:QI (pre_inc:QI (reg:QI 20)))
1404         (unspec:QI [(reg:QI 21)] UNSPEC_PUSH_ST))
1405    (use (reg:QI 21))]
1406   ""
1407   "push\\tst"
1408   [(set_attr "type" "push")])
1409
1410 (define_insn "push_dp"
1411   [(set (mem:QI (pre_inc:QI (reg:QI 20))) 
1412         (unspec:QI [(reg:QI 16)] UNSPEC_PUSH_DP))
1413    (use (reg:QI 16))]
1414   ""
1415   "push\\tdp"
1416   [(set_attr "type" "push")])
1417
1418 (define_insn "popqi"
1419   [(set (match_operand:QI 0 "reg_operand" "=r")
1420         (mem:QI (post_dec:QI (reg:QI 20))))
1421    (clobber (reg:CC 21))]
1422   ""
1423   "pop\\t%0"
1424   [(set_attr "type" "pop")])
1425
1426 (define_insn "pop_st"
1427   [(set (unspec:QI [(reg:QI 21)] UNSPEC_POP_ST) 
1428         (mem:QI (post_dec:QI (reg:QI 20))))
1429    (clobber (reg:CC 21))]
1430   ""
1431   "pop\\tst"
1432   [(set_attr "type" "pop")])
1433
1434 (define_insn "pop_dp"
1435   [(set (unspec:QI [(reg:QI 16)] UNSPEC_POP_DP)
1436         (mem:QI (post_dec:QI (reg:QI 20))))
1437    (clobber (reg:CC 16))]
1438   ""
1439   "pop\\tdp"
1440   [(set_attr "type" "pop")])
1441
1442 (define_insn "popqi_unspec"
1443   [(set (unspec:QI [(match_operand:QI 0 "reg_operand" "=r")] UNSPEC_POPQI)
1444         (mem:QI (post_dec:QI (reg:QI 20))))
1445    (clobber (match_dup 0))
1446    (clobber (reg:CC 21))]
1447   ""
1448   "pop\\t%0"
1449   [(set_attr "type" "pop")])
1450
1451 ;
1452 ; ABSI
1453 ;
1454 (define_expand "absqi2"
1455   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1456                    (abs:QI (match_operand:QI 1 "src_operand" "")))
1457               (clobber (reg:CC_NOOV 21))])]
1458   ""
1459   "")
1460
1461 (define_insn "*absqi2_clobber"
1462   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1463         (abs:QI (match_operand:QI 1 "src_operand" "rIm,rIm")))
1464    (clobber (reg:CC_NOOV 21))]
1465   ""
1466   "absi\\t%1,%0"
1467   [(set_attr "type" "unarycc,unary")
1468    (set_attr "data" "int16,int16")])
1469
1470 (define_insn "*absqi2_noclobber"
1471   [(set (match_operand:QI 0 "std_reg_operand" "=c")
1472         (abs:QI (match_operand:QI 1 "src_operand" "rIm")))]
1473   ""
1474   "absi\\t%1,%0"
1475   [(set_attr "type" "unary")
1476    (set_attr "data" "int16")])
1477
1478 (define_split
1479   [(set (match_operand:QI 0 "std_reg_operand" "")
1480         (abs:QI (match_operand:QI 1 "src_operand" "")))
1481    (clobber (reg:CC_NOOV 21))]
1482   "reload_completed"
1483   [(set (match_dup 0)
1484         (abs:QI (match_dup 1)))]
1485   "")
1486
1487 (define_insn "*absqi2_test"
1488   [(set (reg:CC_NOOV 21)
1489         (compare:CC_NOOV (abs:QI (match_operand:QI 1 "src_operand" "rIm"))
1490                          (const_int 0)))
1491    (clobber (match_scratch:QI 0 "=d"))]
1492   ""
1493   "absi\\t%1,%0"
1494   [(set_attr "type" "unarycc")
1495    (set_attr "data" "int16")])
1496
1497 (define_insn "*absqi2_set"
1498   [(set (reg:CC_NOOV 21)
1499         (compare:CC_NOOV (abs:QI (match_operand:QI 1 "src_operand" "rIm"))
1500                          (const_int 0)))
1501    (set (match_operand:QI 0 "ext_reg_operand" "=d")
1502         (abs:QI (match_dup 1)))]
1503   ""
1504   "absi\\t%1,%0"
1505   [(set_attr "type" "unarycc")
1506    (set_attr "data" "int16")])        
1507
1508 ;
1509 ; NEGI
1510 ;
1511 (define_expand "negqi2"
1512   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1513                    (neg:QI (match_operand:QI 1 "src_operand" "")))
1514               (clobber (reg:CC_NOOV 21))])]
1515 ""
1516 "")
1517
1518 (define_insn "*negqi2_clobber"
1519   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1520         (neg:QI (match_operand:QI 1 "src_operand" "rIm,rIm")))
1521    (clobber (reg:CC_NOOV 21))]
1522   ""
1523   "negi\\t%1,%0"
1524   [(set_attr "type" "unarycc,unary")
1525    (set_attr "data" "int16,int16")])
1526
1527 (define_insn "*negqi2_noclobber"
1528   [(set (match_operand:QI 0 "std_reg_operand" "=c")
1529         (neg:QI (match_operand:QI 1 "src_operand" "rIm")))]
1530   ""
1531   "negi\\t%1,%0"
1532   [(set_attr "type" "unary")
1533    (set_attr "data" "int16")])
1534
1535 (define_split
1536   [(set (match_operand:QI 0 "std_reg_operand" "")
1537         (neg:QI (match_operand:QI 1 "src_operand" "")))
1538    (clobber (reg:CC_NOOV 21))]
1539   "reload_completed"
1540   [(set (match_dup 0)
1541         (neg:QI (match_dup 1)))]
1542   "")
1543
1544 (define_insn "*negqi2_test"
1545   [(set (reg:CC_NOOV 21)
1546         (compare:CC_NOOV (neg:QI (match_operand:QI 1 "src_operand" "rIm"))
1547                          (const_int 0)))
1548    (clobber (match_scratch:QI 0 "=d"))]
1549   ""
1550   "negi\\t%1,%0"
1551   [(set_attr "type" "unarycc")
1552    (set_attr "data" "int16")])
1553
1554 (define_insn "*negqi2_set"
1555   [(set (reg:CC_NOOV 21)
1556         (compare:CC_NOOV (neg:QI (match_operand:QI 1 "src_operand" "rIm"))
1557                          (const_int 0)))
1558    (set (match_operand:QI 0 "ext_reg_operand" "=d")
1559         (neg:QI (match_dup 1)))]
1560   ""
1561   "negi\\t%1,%0"
1562   [(set_attr "type" "unarycc")
1563    (set_attr "data" "int16")])        
1564
1565 (define_insn "*negbqi2_clobber"
1566   [(set (match_operand:QI 0 "ext_reg_operand" "=d")
1567         (neg:QI (match_operand:QI 1 "src_operand" "rIm")))
1568    (use (reg:CC_NOOV 21))
1569    (clobber (reg:CC_NOOV 21))]
1570   ""
1571   "negb\\t%1,%0"
1572   [(set_attr "type" "unarycc")
1573    (set_attr "data" "int16")])        
1574
1575 ;
1576 ; NOT
1577 ;
1578 (define_expand "one_cmplqi2"
1579   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1580                    (not:QI (match_operand:QI 1 "lsrc_operand" "")))
1581               (clobber (reg:CC 21))])]
1582   ""
1583   "")
1584
1585 (define_insn "*one_cmplqi2_clobber"
1586   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1587         (not:QI (match_operand:QI 1 "lsrc_operand" "rLm,rLm")))
1588    (clobber (reg:CC 21))]
1589   ""
1590   "not\\t%1,%0"
1591   [(set_attr "type" "unarycc,unary")
1592    (set_attr "data" "uint16,uint16")])
1593
1594 (define_insn "*one_cmplqi2_noclobber"
1595   [(set (match_operand:QI 0 "std_reg_operand" "=c")
1596         (not:QI (match_operand:QI 1 "lsrc_operand" "rLm")))]
1597   ""
1598   "not\\t%1,%0"
1599   [(set_attr "type" "unary")
1600    (set_attr "data" "uint16")])
1601
1602 (define_split
1603   [(set (match_operand:QI 0 "std_reg_operand" "")
1604         (not:QI (match_operand:QI 1 "lsrc_operand" "")))
1605    (clobber (reg:CC 21))]
1606   "reload_completed"
1607   [(set (match_dup 0)
1608         (not:QI (match_dup 1)))]
1609   "")
1610
1611 (define_insn "*one_cmplqi2_test"
1612   [(set (reg:CC 21)
1613         (compare:CC (not:QI (match_operand:QI 1 "lsrc_operand" "rLm"))
1614                     (const_int 0)))
1615    (clobber (match_scratch:QI 0 "=d"))]
1616   ""
1617   "not\\t%1,%0"
1618   [(set_attr "type" "unarycc")
1619    (set_attr "data" "uint16")])
1620
1621 (define_insn "*one_cmplqi2_set"
1622   [(set (reg:CC 21)
1623         (compare:CC (not:QI (match_operand:QI 1 "lsrc_operand" "rLm"))
1624                     (const_int 0)))
1625    (set (match_operand:QI 0 "ext_reg_operand" "=d")        
1626         (not:QI (match_dup 1)))]
1627   ""
1628   "not\\t%1,%0"
1629   [(set_attr "type" "unarycc")
1630    (set_attr "data" "uint16")])        
1631
1632 (define_insn "*one_cmplqi2_const_clobber"
1633   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1634         (match_operand:QI 1 "not_const_operand" "N,N"))
1635    (clobber (reg:CC 21))]
1636   ""
1637   "@
1638    not\\t%N1,%0
1639    not\\t%N1,%0"
1640    [(set_attr "type" "unarycc,unary")
1641     (set_attr "data" "not_uint16,not_uint16")])
1642
1643 ; movqi can use this for loading an integer that can't normally
1644 ; fit into a 16-bit signed integer.  The drawback is that it cannot
1645 ; go into R0-R11 since that will clobber the CC and movqi shouldn't
1646 ; do that.  This can cause additional reloading but in most cases
1647 ; this will cause only an additional register move.  With the large
1648 ; memory model we require an extra instruction to load DP anyway,
1649 ; if we're loading the constant from memory.  The big advantage of
1650 ; allowing constants that satisfy not_const_operand in movqi, is that
1651 ; it allows andn to be generated more often.
1652 ; However, there is a problem if GCC has decided that it wants
1653 ; to use R0-R11, since we won't have a matching pattern...
1654 ; In interim, we prevent immed_const allowing `N' constants.
1655 (define_insn "*one_cmplqi2_const_noclobber"
1656   [(set (match_operand:QI 0 "std_reg_operand" "=c")
1657         (match_operand:QI 1 "not_const_operand" "N"))]
1658   ""
1659   "not\\t%N1,%0"
1660   [(set_attr "type" "unary")
1661    (set_attr "data" "not_uint16")])
1662
1663 ;
1664 ; ROL
1665 ;
1666 (define_expand "rotlqi3"
1667   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1668                    (rotate:QI (match_operand:QI 1 "reg_operand" "")
1669                               (match_operand:QI 2 "const_int_operand" "")))
1670               (clobber (reg:CC 21))])]
1671   ""
1672   "if (INTVAL (operands[2]) > 4)
1673      FAIL; /* Open code as two shifts and an or */
1674    if (INTVAL (operands[2]) > 1)
1675      {
1676         int i;
1677         rtx tmp;
1678
1679         /* If we have 4 or fewer shifts, then it is probably faster
1680            to emit separate ROL instructions.  A C3x requires
1681            at least 4 instructions (a C4x requires at least 3), to
1682            perform a rotation by shifts.  */
1683
1684         tmp = operands[1];
1685         for (i = 0; i < INTVAL (operands[2]) - 1; i++)
1686           {
1687             tmp = gen_reg_rtx (QImode);
1688             emit_insn (gen_rotl_1_clobber (tmp, operands[1]));
1689             operands[1] = tmp;
1690           }
1691         emit_insn (gen_rotl_1_clobber (operands[0], tmp));
1692         DONE;
1693      }")
1694
1695 (define_insn "rotl_1_clobber"
1696   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1697         (rotate:QI (match_operand:QI 1 "reg_operand" "0,0")
1698                    (const_int 1)))
1699    (clobber (reg:CC 21))]
1700   ""
1701   "rol\\t%0"
1702   [(set_attr "type" "unarycc,unary")])
1703 ; Default to int16 data attr.
1704
1705 ;
1706 ; ROR
1707 ;
1708 (define_expand "rotrqi3"
1709   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1710                    (rotatert:QI (match_operand:QI 1 "reg_operand" "")
1711                                 (match_operand:QI 2 "const_int_operand" "")))
1712               (clobber (reg:CC 21))])]
1713   ""
1714   "if (INTVAL (operands[2]) > 4)
1715      FAIL; /* Open code as two shifts and an or */
1716    if (INTVAL (operands[2]) > 1)
1717      {
1718         int i;
1719         rtx tmp;
1720  
1721         /* If we have 4 or fewer shifts, then it is probably faster
1722            to emit separate ROL instructions.  A C3x requires
1723            at least 4 instructions (a C4x requires at least 3), to
1724            perform a rotation by shifts.  */
1725  
1726         tmp = operands[1];
1727         for (i = 0; i < INTVAL (operands[2]) - 1; i++)
1728           {
1729             tmp = gen_reg_rtx (QImode);
1730             emit_insn (gen_rotr_1_clobber (tmp, operands[1]));
1731             operands[1] = tmp;
1732           }
1733         emit_insn (gen_rotr_1_clobber (operands[0], tmp));
1734         DONE;
1735      }")
1736
1737 (define_insn "rotr_1_clobber"
1738   [(set (match_operand:QI 0 "reg_operand" "=d,c")
1739         (rotatert:QI (match_operand:QI 1 "reg_operand" "0,0")
1740                      (const_int 1)))
1741    (clobber (reg:CC 21))]
1742   ""
1743   "ror\\t%0"
1744   [(set_attr "type" "unarycc,unary")])
1745 ; Default to int16 data attr.
1746
1747
1748 ;
1749 ; THREE OPERAND INTEGER INSTRUCTIONS
1750 ;
1751
1752 ;
1753 ; ADDI
1754 ;
1755 ; This is used by reload when it calls gen_add2_insn for address arithmetic
1756 ; so we must emit the pattern that doesn't clobber CC.
1757 ;
1758 (define_expand "addqi3"
1759   [(parallel [(set (match_operand:QI 0 "std_or_reg_operand" "")
1760                    (plus:QI (match_operand:QI 1 "src_operand" "")
1761                             (match_operand:QI 2 "src_operand" "")))
1762               (clobber (reg:CC_NOOV 21))])]
1763   ""
1764   "legitimize_operands (PLUS, operands, QImode);
1765    if (reload_in_progress
1766        || (! IS_PSEUDO_REG (operands[0]) 
1767            && ! IS_EXT_REG (operands[0])))
1768    {
1769       emit_insn (gen_addqi3_noclobber (operands[0], operands[1], operands[2]));
1770       DONE;
1771    }")
1772
1773 ; This pattern is required primarily for manipulating the stack pointer
1774 ; where GCC doesn't expect CC to be clobbered or for calculating
1775 ; addresses during reload.  Since this is a more specific pattern
1776 ; it needs to go first (otherwise we get into problems trying to decide
1777 ; to add clobbers).
1778 (define_insn "addqi3_noclobber"
1779   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,c")
1780         (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1781                  (match_operand:QI 2 "src_operand" "rIm,JR,rS<>")))]
1782   "valid_operands (PLUS, operands, QImode)"
1783   "@
1784    addi\\t%2,%0
1785    addi3\\t%2,%1,%0
1786    addi3\\t%2,%1,%0"
1787   [(set_attr "type" "binary,binary,binary")])
1788 ; Default to int16 data attr.
1789
1790 (define_insn "*addqi3_clobber"
1791   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
1792         (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
1793                  (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")))
1794    (clobber (reg:CC_NOOV 21))]
1795   "valid_operands (PLUS, operands, QImode)"
1796   "@
1797    addi\\t%2,%0
1798    addi3\\t%2,%1,%0
1799    addi3\\t%2,%1,%0
1800    addi\\t%2,%0
1801    addi3\\t%2,%1,%0
1802    addi3\\t%2,%1,%0"
1803   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
1804 ; Default to int16 data attr.
1805
1806 (define_split
1807   [(set (match_operand:QI 0 "std_reg_operand" "")
1808         (plus:QI (match_operand:QI 1 "src_operand" "")
1809                  (match_operand:QI 2 "src_operand" "")))
1810    (clobber (reg:CC_NOOV 21))]
1811   "reload_completed"
1812   [(set (match_dup 0)
1813         (plus:QI (match_dup 1)
1814                  (match_dup 2)))]
1815   "")
1816
1817 (define_insn "*addqi3_test"
1818   [(set (reg:CC_NOOV 21)
1819         (compare:CC_NOOV (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1820                                   (match_operand:QI 2 "src_operand" "rIm,JR,rS<>"))
1821                          (const_int 0)))
1822    (clobber (match_scratch:QI 0 "=d,d,d"))]
1823   "valid_operands (PLUS, operands, QImode)"
1824   "@
1825    addi\\t%2,%0
1826    addi3\\t%2,%1,%0
1827    addi3\\t%2,%1,%0"
1828   [(set_attr "type" "binarycc,binarycc,binarycc")])
1829 ; Default to int16 data attr.
1830
1831 ; gcc does this in combine.c we just reverse it here
1832 (define_insn "*cmp_neg"
1833   [(set (reg:CC_NOOV 21)
1834         (compare:CC_NOOV (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1835                          (neg: QI (match_operand:QI 2 "src_operand" "g,JR,rS<>"))))
1836    (clobber (match_scratch:QI 0 "=d,d,d"))]
1837   "valid_operands (PLUS, operands, QImode)"
1838   "@
1839    addi\\t%2,%0
1840    addi3\\t%2,%1,%0
1841    addi3\\t%2,%1,%0"
1842   [(set_attr "type" "binarycc,binarycc,binarycc")])
1843   
1844 (define_peephole
1845   [(parallel [(set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
1846                    (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1847                             (match_operand:QI 2 "src_operand" "g,JR,rS<>")))
1848               (clobber (reg:CC_NOOV 21))])
1849    (set (reg:CC_NOOV 21)
1850         (compare:CC_NOOV (match_dup 0) (const_int 0)))]
1851   "valid_operands (PLUS, operands, QImode)"
1852   "@
1853    addi\\t%2,%0
1854    addi3\\t%2,%1,%0
1855    addi3\\t%2,%1,%0"
1856   [(set_attr "type" "binarycc,binarycc,binarycc")])
1857
1858 (define_insn "*addqi3_set"
1859   [(set (reg:CC_NOOV 21)
1860         (compare:CC_NOOV (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1861                                   (match_operand:QI 2 "src_operand" "rIm,JR,rS<>"))
1862                          (const_int 0)))
1863    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
1864         (plus:QI (match_dup 1) (match_dup 2)))]
1865   "valid_operands (PLUS, operands, QImode)"
1866   "@
1867    addi\\t%2,%0
1868    addi3\\t%2,%1,%0
1869    addi3\\t%2,%1,%0"
1870   [(set_attr "type" "binarycc,binarycc,binarycc")])
1871 ; Default to int16 data attr.
1872
1873
1874 ; This pattern is required during reload when eliminate_regs_in_insn
1875 ; effectively converts a move insn into an add insn when the src
1876 ; operand is the frame pointer plus a constant.  Without this
1877 ; pattern, gen_addqi3 can be called with a register for operand0
1878 ; that can clobber CC.
1879 ; For example, we may have (set (mem (reg ar0)) (reg 99))
1880 ; with (set (reg 99) (plus (reg ar3) (const_int 8)))
1881 ; Now since ar3, the frame pointer, is unchanging within the function,
1882 ; (plus (reg ar3) (const_int 8)) is considered a constant.
1883 ; eliminate_regs_in_insn substitutes this constant to give
1884 ; (set (mem (reg ar0)) (plus (reg ar3) (const_int 8))).
1885 ; This is an invalid C4x insn but if we don't provide a pattern
1886 ; for it, it will be considered to be a move insn for reloading.
1887 (define_insn "*addqi3_noclobber_reload"
1888   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,c")
1889         (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
1890                  (match_operand:QI 2 "src_operand" "rIm,JR,rS<>")))]
1891   "reload_in_progress"
1892   "@
1893    addi\\t%2,%0
1894    addi3\\t%2,%1,%0
1895    addi3\\t%2,%1,%0"
1896   [(set_attr "type" "binary,binary,binary")])
1897 ; Default to int16 data attr.
1898
1899
1900 (define_insn "*addqi3_carry_clobber"
1901   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
1902         (plus:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
1903                  (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")))
1904    (use (reg:CC_NOOV 21))
1905    (clobber (reg:CC_NOOV 21))]
1906   "valid_operands (PLUS, operands, QImode)"
1907   "@
1908    addc\\t%2,%0
1909    addc3\\t%2,%1,%0
1910    addc3\\t%2,%1,%0
1911    addc\\t%2,%0
1912    addc3\\t%2,%1,%0
1913    addc3\\t%2,%1,%0"
1914   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
1915 ; Default to int16 data attr.
1916
1917
1918 ;
1919 ; SUBI/SUBRI
1920 ;
1921 (define_expand "subqi3"
1922   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
1923                    (minus:QI (match_operand:QI 1 "src_operand" "")
1924                              (match_operand:QI 2 "src_operand" "")))
1925               (clobber (reg:CC_NOOV 21))])]
1926   ""
1927   "legitimize_operands (MINUS, operands, QImode);")
1928
1929 (define_insn "*subqi3_clobber"
1930   [(set (match_operand:QI 0 "reg_operand" "=d,d,d,?d,c,c,c,?c")
1931         (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>,0,rIm,rR,rS<>")
1932                   (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>,rIm,0,JR,rS<>")))
1933    (clobber (reg:CC_NOOV 21))]
1934   "valid_operands (MINUS, operands, QImode)"
1935   "@
1936    subi\\t%2,%0
1937    subri\\t%1,%0
1938    subi3\\t%2,%1,%0
1939    subi3\\t%2,%1,%0
1940    subi\\t%2,%0
1941    subri\\t%1,%0
1942    subi3\\t%2,%1,%0
1943    subi3\\t%2,%1,%0"
1944   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc,binary,binary,binary,binary")])
1945 ; Default to int16 data attr.
1946
1947 (define_split
1948   [(set (match_operand:QI 0 "std_reg_operand" "")
1949         (minus:QI (match_operand:QI 1 "src_operand" "")
1950                   (match_operand:QI 2 "src_operand" "")))
1951    (clobber (reg:CC_NOOV 21))]
1952   "reload_completed"
1953   [(set (match_dup 0)
1954         (minus:QI (match_dup 1)
1955                  (match_dup 2)))]
1956   "")
1957
1958 (define_insn "*subqi3_test"
1959   [(set (reg:CC_NOOV 21)
1960         (compare:CC_NOOV (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>")
1961                                    (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>"))
1962                          (const_int 0)))
1963    (clobber (match_scratch:QI 0 "=d,d,d,?d"))]
1964   "valid_operands (MINUS, operands, QImode)"
1965   "@
1966    subi\\t%2,%0
1967    subri\\t%1,%0
1968    subi3\\t%2,%1,%0
1969    subi3\\t%2,%1,%0"
1970   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")])
1971 ; Default to int16 data attr.
1972
1973 (define_peephole
1974   [(parallel [(set (match_operand:QI 0 "ext_reg_operand" "=d,d,d,?d")
1975                    (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>")
1976                              (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>")))
1977               (clobber (reg:CC_NOOV 21))])
1978    (set (reg:CC_NOOV 21)
1979         (compare:CC_NOOV (match_dup 0) (const_int 0)))]
1980   "valid_operands (MINUS, operands, QImode)"
1981   "@
1982    subi\\t%2,%0
1983    subri\\t%1,%0
1984    subi3\\t%2,%1,%0
1985    subi3\\t%2,%1,%0"
1986   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")])
1987   
1988 (define_insn "*subqi3_set"
1989   [(set (reg:CC_NOOV 21)
1990         (compare:CC_NOOV (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>")
1991                                    (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>"))
1992                          (const_int 0)))
1993    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d,?d")
1994         (minus:QI (match_dup 1)
1995                   (match_dup 2)))]
1996   "valid_operands (MINUS, operands, QImode)"
1997   "@
1998    subi\\t%2,%0
1999    subri\\t%1,%0
2000    subi3\\t%2,%1,%0
2001    subi3\\t%2,%1,%0"
2002   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")])
2003 ; Default to int16 data attr.
2004
2005 (define_insn "*subqi3_noclobber"
2006   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,c,?c")
2007         (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>")
2008                   (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>")))]
2009   "valid_operands (MINUS, operands, QImode)"
2010   "@
2011    subi\\t%2,%0
2012    subri\\t%1,%0
2013    subi3\\t%2,%1,%0
2014    subi3\\t%2,%1,%0"
2015   [(set_attr "type" "binary,binary,binary,binary")])
2016 ; Default to int16 data attr.
2017
2018 (define_insn "*subqi3_carry_clobber"
2019   [(set (match_operand:QI 0 "reg_operand" "=d,d,d,?d,c,c,c,?c")
2020         (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>,0,rIm,rR,rS<>")
2021                   (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>,rIm,0,JR,rS<>")))
2022    (use (reg:CC_NOOV 21))
2023    (clobber (reg:CC_NOOV 21))]
2024   "valid_operands (MINUS, operands, QImode)"
2025   "@
2026    subb\\t%2,%0
2027    subrb\\t%1,%0
2028    subb3\\t%2,%1,%0
2029    subb3\\t%2,%1,%0
2030    subb\\t%2,%0
2031    subrb\\t%1,%0
2032    subb3\\t%2,%1,%0
2033    subb3\\t%2,%1,%0"
2034   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc,binary,binary,binary,binary")])
2035 ; Default to int16 data attr.
2036
2037 (define_insn "*subqi3_carry_set"
2038   [(set (reg:CC_NOOV 21)
2039         (compare:CC_NOOV (minus:QI (match_operand:QI 1 "src_operand" "0,rIm,rR,rS<>")
2040                                    (match_operand:QI 2 "src_operand" "rIm,0,JR,rS<>"))
2041                          (const_int 0)))
2042    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d,?d")
2043         (minus:QI (match_dup 1)
2044                   (match_dup 2)))
2045    (use (reg:CC_NOOV 21))]
2046   "valid_operands (MINUS, operands, QImode)"
2047   "@
2048    subb\\t%2,%0
2049    subrb\\t%1,%0
2050    subb3\\t%2,%1,%0
2051    subb3\\t%2,%1,%0"
2052   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")])
2053 ; Default to int16 data attr.
2054
2055 ;
2056 ; MPYI
2057 ;
2058 (define_expand "mulqi3"
2059   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2060                    (mult:QI (match_operand:QI 1 "src_operand" "")
2061                             (match_operand:QI 2 "src_operand" "")))
2062               (clobber (reg:CC_NOOV 21))])]
2063   ""
2064   "if (TARGET_MPYI || (GET_CODE (operands[2]) == CONST_INT
2065        && exact_log2 (INTVAL (operands[2])) >= 0))
2066      legitimize_operands (MULT, operands, QImode);
2067    else
2068      {        
2069        if (GET_CODE (operands[2]) == CONST_INT)
2070          {
2071           /* Let GCC try to synthesize the multiplication using shifts
2072              and adds.  In most cases this will be more profitable than
2073              using the C3x MPYI.  */
2074             FAIL;
2075          }
2076        if (operands[1] == operands[2])
2077          {
2078             /* Do the squaring operation in-line.  */
2079             emit_insn (gen_sqrqi2_inline (operands[0], operands[1]));
2080             DONE;
2081          }
2082        if (TARGET_INLINE)
2083          {
2084             emit_insn (gen_mulqi3_inline (operands[0], operands[1],
2085                                           operands[2]));
2086             DONE;
2087          }
2088        c4x_emit_libcall3 (optab_libfunc (smul_optab, QImode),
2089                           MULT, QImode, operands);
2090        DONE;
2091      }
2092   ")
2093
2094 (define_insn "*mulqi3_clobber"
2095   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2096         (mult:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
2097                  (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")))
2098    (clobber (reg:CC_NOOV 21))]
2099   "valid_operands (MULT, operands, QImode)"
2100   "*
2101   if (which_alternative == 0 || which_alternative == 3)
2102     {
2103       if (TARGET_C3X
2104           && GET_CODE (operands[2]) == CONST_INT
2105           && exact_log2 (INTVAL (operands[2])) >= 0)
2106         return \"ash\\t%L2,%0\";
2107       else
2108         return \"mpyi\\t%2,%0\";
2109     }
2110   else
2111       return \"mpyi3\\t%2,%1,%0\";"
2112   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
2113 ; Default to int16 data attr.
2114
2115 (define_insn "*mulqi3_test"
2116   [(set (reg:CC_NOOV 21)
2117         (compare:CC_NOOV (mult:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2118                                   (match_operand:QI 2 "src_operand" "rIm,JR,rS<>"))
2119                          (const_int 0)))
2120    (clobber (match_scratch:QI 0 "=d,d,d"))]
2121   "valid_operands (MULT, operands, QImode)"
2122   "*
2123   if (which_alternative == 0)
2124     {
2125       if (TARGET_C3X 
2126           && GET_CODE (operands[2]) == CONST_INT
2127           && exact_log2 (INTVAL (operands[2])) >= 0)
2128         return \"ash\\t%L2,%0\";
2129       else
2130         return \"mpyi\\t%2,%0\";
2131     } 
2132   else
2133       return \"mpyi3\\t%2,%1,%0\";"
2134   [(set_attr "type" "binarycc,binarycc,binarycc")])
2135 ; Default to int16 data attr.
2136
2137 (define_insn "*mulqi3_set"
2138   [(set (reg:CC_NOOV 21)
2139         (compare:CC_NOOV (mult:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2140                                   (match_operand:QI 2 "src_operand" "rIm,JR,rS<>"))
2141                          (const_int 0)))
2142    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
2143         (mult:QI (match_dup 1)
2144                  (match_dup 2)))]
2145   "valid_operands (MULT, operands, QImode)"
2146   "*
2147   if (which_alternative == 0)
2148     {
2149       if (TARGET_C3X 
2150           && GET_CODE (operands[2]) == CONST_INT
2151           && exact_log2 (INTVAL (operands[2])) >= 0)
2152         return \"ash\\t%L2,%0\";
2153       else
2154         return \"mpyi\\t%2,%0\";
2155     }
2156     else
2157         return \"mpyi3\\t%2,%1,%0\";"
2158   [(set_attr "type" "binarycc,binarycc,binarycc")])
2159 ; Default to int16 data attr.
2160
2161 ; The C3x multiply instruction assumes 24-bit signed integer operands
2162 ; and the 48-bit result is truncated to 32-bits.
2163 (define_insn "mulqi3_24_clobber"
2164   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2165         (mult:QI
2166          (sign_extend:QI
2167           (and:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
2168                   (const_int 16777215)))
2169          (sign_extend:QI
2170           (and:QI (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")
2171                   (const_int 16777215)))))
2172    (clobber (reg:CC_NOOV 21))]
2173   "TARGET_C3X && valid_operands (MULT, operands, QImode)"
2174   "@
2175    mpyi\\t%2,%0
2176    mpyi3\\t%2,%1,%0
2177    mpyi3\\t%2,%1,%0
2178    mpyi\\t%2,%0
2179    mpyi3\\t%2,%1,%0
2180    mpyi3\\t%2,%1,%0"
2181   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
2182 ; Default to int16 data attr.
2183
2184
2185 ; Fast square function for C3x where TARGET_MPYI not asserted
2186 (define_expand "sqrqi2_inline"
2187   [(set (match_dup 7) (match_operand:QI 1 "src_operand" ""))
2188    (parallel [(set (match_dup 3)
2189                    (lshiftrt:QI (match_dup 7) (const_int 16)))
2190               (clobber (reg:CC 21))])
2191    (parallel [(set (match_dup 2)
2192                    (and:QI (match_dup 7) (const_int 65535)))
2193               (clobber (reg:CC 21))])
2194    (parallel [(set (match_dup 4)
2195                    (mult:QI (sign_extend:QI (and:QI (match_dup 2) 
2196                                                     (const_int 16777215)))
2197                             (sign_extend:QI (and:QI (match_dup 2) 
2198                                                     (const_int 16777215)))))
2199               (clobber (reg:CC_NOOV 21))])
2200    (parallel [(set (match_dup 5)
2201                    (mult:QI (sign_extend:QI (and:QI (match_dup 2) 
2202                                                     (const_int 16777215)))
2203                             (sign_extend:QI (and:QI (match_dup 3) 
2204                                                     (const_int 16777215)))))
2205               (clobber (reg:CC_NOOV 21))])
2206    (parallel [(set (match_dup 6)
2207                    (ashift:QI (match_dup 5) (const_int 17)))
2208               (clobber (reg:CC 21))])
2209    (parallel [(set (match_operand:QI 0 "reg_operand" "")
2210                    (plus:QI (match_dup 4) (match_dup 6)))
2211               (clobber (reg:CC_NOOV 21))])]
2212   ""
2213   "
2214   operands[2] = gen_reg_rtx (QImode); /* a = val & 0xffff */
2215   operands[3] = gen_reg_rtx (QImode); /* b = val >> 16 */
2216   operands[4] = gen_reg_rtx (QImode); /* a * a */
2217   operands[5] = gen_reg_rtx (QImode); /* a * b */
2218   operands[6] = gen_reg_rtx (QImode); /* (a * b) << 17 */
2219   operands[7] = gen_reg_rtx (QImode); /* val */
2220   ")
2221
2222 ; Inlined integer multiply for C3x
2223 (define_expand "mulqi3_inline"
2224   [(set (match_dup 12) (const_int -16))
2225    (set (match_dup 13) (match_operand:QI 1 "src_operand" ""))
2226    (set (match_dup 14) (match_operand:QI 2 "src_operand" ""))
2227    (parallel [(set (match_dup 4)
2228                    (lshiftrt:QI (match_dup 13) (neg:QI (match_dup 12))))
2229               (clobber (reg:CC 21))])
2230    (parallel [(set (match_dup 6)
2231                    (lshiftrt:QI (match_dup 14) (neg:QI (match_dup 12))))
2232               (clobber (reg:CC 21))])
2233    (parallel [(set (match_dup 3)
2234                    (and:QI (match_dup 13)
2235                            (const_int 65535)))
2236               (clobber (reg:CC 21))])
2237    (parallel [(set (match_dup 5)
2238                    (and:QI (match_dup 14) 
2239                            (const_int 65535)))
2240               (clobber (reg:CC 21))])
2241    (parallel [(set (match_dup 7)
2242                    (mult:QI (sign_extend:QI (and:QI (match_dup 4) 
2243                                                     (const_int 16777215)))
2244                             (sign_extend:QI (and:QI (match_dup 5) 
2245                                                     (const_int 16777215)))))
2246               (clobber (reg:CC_NOOV 21))])
2247    (parallel [(set (match_dup 8)
2248                    (mult:QI (sign_extend:QI (and:QI (match_dup 3) 
2249                                                     (const_int 16777215)))
2250                             (sign_extend:QI (and:QI (match_dup 5) 
2251                                                     (const_int 16777215)))))
2252               (clobber (reg:CC_NOOV 21))])
2253    (parallel [(set (match_dup 9)
2254                    (mult:QI (sign_extend:QI (and:QI (match_dup 3) 
2255                                                     (const_int 16777215)))
2256                             (sign_extend:QI (and:QI (match_dup 6) 
2257                                                     (const_int 16777215)))))
2258               (clobber (reg:CC_NOOV 21))])
2259    (parallel [(set (match_dup 10)
2260                    (plus:QI (match_dup 7) (match_dup 9)))
2261               (clobber (reg:CC_NOOV 21))])
2262    (parallel [(set (match_dup 11)
2263                    (ashift:QI (match_dup 10) (const_int 16)))
2264               (clobber (reg:CC 21))])
2265    (parallel [(set (match_operand:QI 0 "reg_operand" "")
2266                    (plus:QI (match_dup 8) (match_dup 11)))
2267               (clobber (reg:CC_NOOV 21))])]
2268   "TARGET_C3X"
2269   "
2270   operands[3] = gen_reg_rtx (QImode); /* a = arg1 & 0xffff */
2271   operands[4] = gen_reg_rtx (QImode); /* b = arg1 >> 16 */
2272   operands[5] = gen_reg_rtx (QImode); /* a = arg2 & 0xffff */
2273   operands[6] = gen_reg_rtx (QImode); /* b = arg2 >> 16 */
2274   operands[7] = gen_reg_rtx (QImode); /* b * c */
2275   operands[8] = gen_reg_rtx (QImode); /* a * c */
2276   operands[9] = gen_reg_rtx (QImode); /* a * d */
2277   operands[10] = gen_reg_rtx (QImode); /* b * c + a * d */
2278   operands[11] = gen_reg_rtx (QImode); /* (b *c + a * d) << 16 */
2279   operands[12] = gen_reg_rtx (QImode); /* -16 */
2280   operands[13] = gen_reg_rtx (QImode); /* arg1 */
2281   operands[14] = gen_reg_rtx (QImode); /* arg2 */
2282   ")
2283
2284 ;
2285 ; MPYSHI (C4x only)
2286 ;
2287 (define_expand "smulqi3_highpart"
2288   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2289                    (truncate:QI
2290                     (lshiftrt:HI
2291                      (mult:HI
2292                       (sign_extend:HI (match_operand:QI 1 "src_operand" ""))
2293                       (sign_extend:HI (match_operand:QI 2 "src_operand" "")))
2294                  (const_int 32))))
2295               (clobber (reg:CC_NOOV 21))])]
2296  ""
2297  "legitimize_operands (MULT, operands, QImode);
2298   if (TARGET_C3X)
2299     {
2300        c4x_emit_libcall_mulhi (smulhi3_libfunc, SIGN_EXTEND, QImode, operands);
2301        DONE;
2302     }
2303  ")
2304
2305 (define_insn "*smulqi3_highpart_clobber"
2306   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2307         (truncate:QI 
2308          (lshiftrt:HI
2309           (mult:HI
2310            (sign_extend:HI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>"))
2311            (sign_extend:HI (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")))
2312       (const_int 32))))
2313    (clobber (reg:CC_NOOV 21))]
2314   "! TARGET_C3X && valid_operands (MULT, operands, QImode)"
2315   "@
2316    mpyshi\\t%2,%0
2317    mpyshi3\\t%2,%1,%0
2318    mpyshi3\\t%2,%1,%0
2319    mpyshi\\t%2,%0
2320    mpyshi3\\t%2,%1,%0
2321    mpyshi3\\t%2,%1,%0"
2322   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")
2323    (set_attr "data" "int16,int16,int16,int16,int16,int16")])
2324
2325 (define_insn "*smulqi3_highpart_noclobber"
2326   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
2327         (truncate:QI 
2328          (lshiftrt:HI
2329           (mult:HI
2330            (sign_extend:HI (match_operand:QI 1 "src_operand" "0,rR,rS<>"))
2331            (sign_extend:HI (match_operand:QI 2 "src_operand" "rIm,JR,rS<>")))
2332       (const_int 32))))]
2333   "! TARGET_C3X && valid_operands (MULT, operands, QImode)"
2334   "@
2335    mpyshi\\t%2,%0
2336    mpyshi3\\t%2,%1,%0
2337    mpyshi3\\t%2,%1,%0"
2338   [(set_attr "type" "binary,binary,binary")
2339    (set_attr "data" "int16,int16,int16")])
2340
2341 ;
2342 ; MPYUHI (C4x only)
2343 ;
2344 (define_expand "umulqi3_highpart"
2345   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2346                (truncate:QI
2347                 (lshiftrt:HI
2348                  (mult:HI
2349                   (zero_extend:HI (match_operand:QI 1
2350                                    "nonimmediate_src_operand" ""))
2351                   (zero_extend:HI (match_operand:QI 2
2352                                    "nonimmediate_lsrc_operand" "")))
2353                  (const_int 32))))
2354               (clobber (reg:CC_NOOV 21))])]
2355  ""
2356  "legitimize_operands (MULT, operands, QImode);
2357   if (TARGET_C3X) 
2358     {
2359       c4x_emit_libcall_mulhi (umulhi3_libfunc, ZERO_EXTEND, QImode, operands);
2360       DONE;
2361     }
2362  ")
2363
2364 (define_insn "*umulqi3_highpart_clobber"
2365   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2366         (truncate:QI
2367          (lshiftrt:HI
2368           (mult:HI 
2369            (zero_extend:HI (match_operand:QI 1
2370                             "nonimmediate_src_operand" "%0,rR,rS<>,0,rR,rS<>"))
2371            (zero_extend:HI (match_operand:QI 2
2372                             "nonimmediate_lsrc_operand" "rm,R,rS<>,rm,R,rS<>")))
2373           (const_int 32))))
2374    (clobber (reg:CC_NOOV 21))]
2375   "! TARGET_C3X && valid_operands (MULT, operands, QImode)"
2376   "@
2377    mpyuhi\\t%2,%0
2378    mpyuhi3\\t%2,%1,%0
2379    mpyuhi3\\t%2,%1,%0
2380    mpyuhi\\t%2,%0
2381    mpyuhi3\\t%2,%1,%0
2382    mpyuhi3\\t%2,%1,%0"
2383   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")
2384    (set_attr "data" "uint16,uint16,uint16,uint16,uint16,uint16")])
2385
2386 (define_insn "*umulqi3_highpart_noclobber"
2387   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
2388         (truncate:QI
2389          (lshiftrt:HI
2390           (mult:HI 
2391            (zero_extend:HI (match_operand:QI 1
2392                             "nonimmediate_src_operand" "0,rR,rS<>"))
2393            (zero_extend:HI (match_operand:QI 2
2394                             "nonimmediate_lsrc_operand" "rm,R,rS<>")))
2395           (const_int 32))))]
2396   "! TARGET_C3X && valid_operands (MULT, operands, QImode)"
2397   "@
2398    mpyuhi\\t%2,%0
2399    mpyuhi3\\t%2,%1,%0
2400    mpyuhi3\\t%2,%1,%0"
2401   [(set_attr "type" "binary,binary,binary")
2402    (set_attr "data" "uint16,uint16,uint16")])
2403
2404 ;
2405 ; AND
2406 ;
2407 (define_expand "andqi3"
2408   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2409                    (and:QI (match_operand:QI 1 "src_operand" "")
2410                            (match_operand:QI 2 "tsrc_operand" "")))
2411               (clobber (reg:CC 21))])]
2412  ""
2413  "legitimize_operands (AND, operands, QImode);")
2414
2415
2416 (define_insn "*andqi3_255_clobber"
2417   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2418         (and:QI (match_operand:QI 1 "src_operand" "mr,mr")
2419                 (const_int 255)))
2420    (clobber (reg:CC 21))]
2421  "! TARGET_C3X"
2422  "lbu0\\t%1,%0"
2423   [(set_attr "type" "unarycc,unary")])
2424
2425 (define_insn "*andqi3_255_noclobber"
2426   [(set (match_operand:QI 0 "reg_operand" "=c")
2427         (and:QI (match_operand:QI 1 "src_operand" "mr")
2428                 (const_int 255)))]
2429  "! TARGET_C3X"
2430  "lbu0\\t%1,%0"
2431   [(set_attr "type" "unary")])
2432
2433
2434 (define_insn "*andqi3_65535_clobber"
2435   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2436         (and:QI (match_operand:QI 1 "src_operand" "mr,mr")
2437                 (const_int 65535)))
2438    (clobber (reg:CC 21))]
2439  "! TARGET_C3X"
2440  "lhu0\\t%1,%0"
2441   [(set_attr "type" "unarycc,unary")])
2442
2443 (define_insn "*andqi3_65535_noclobber"
2444   [(set (match_operand:QI 0 "reg_operand" "=c")
2445         (and:QI (match_operand:QI 1 "src_operand" "mr")
2446                 (const_int 65535)))]
2447  "! TARGET_C3X"
2448  "lhu0\\t%1,%0"
2449   [(set_attr "type" "unary")])
2450
2451 (define_insn "*andqi3_clobber"
2452   [(set (match_operand:QI 0 "reg_operand" "=d,d,d,?d,c,c,c,?c")
2453         (and:QI (match_operand:QI 1 "src_operand" "%0,0,rR,rS<>,0,0,rR,rS<>")
2454                 (match_operand:QI 2 "tsrc_operand" "N,rLm,JR,rS<>,N,rLm,JR,rS<>")))
2455    (clobber (reg:CC 21))]
2456   "valid_operands (AND, operands, QImode)"
2457   "@
2458    andn\\t%N2,%0
2459    and\\t%2,%0
2460    and3\\t%2,%1,%0
2461    and3\\t%2,%1,%0
2462    andn\\t%N2,%0
2463    and\\t%2,%0
2464    and3\\t%2,%1,%0
2465    and3\\t%2,%1,%0"
2466   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc,binary,binary,binary,binary")
2467    (set_attr "data" "not_uint16,uint16,int16,uint16,not_uint16,uint16,int16,uint16")])
2468
2469 (define_insn "*andqi3_noclobber"
2470   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,c,?c")
2471         (and:QI (match_operand:QI 1 "src_operand" "%0,0,rR,rS<>")
2472                 (match_operand:QI 2 "tsrc_operand" "N,rLm,JR,rS<>")))]
2473   "valid_operands (AND, operands, QImode)"
2474   "@
2475    andn\\t%N2,%0
2476    and\\t%2,%0
2477    and3\\t%2,%1,%0
2478    and3\\t%2,%1,%0"
2479   [(set_attr "type" "binary,binary,binary,binary")
2480    (set_attr "data" "not_uint16,uint16,int16,uint16")])
2481
2482 (define_insn "andn_st"
2483   [(set (unspec:QI [(reg:QI 21)] 20)
2484         (and:QI (unspec:QI [(reg:QI 21)] UNSPEC_ANDN_ST)
2485                 (match_operand:QI 0 "" "N")))
2486    (use (match_dup 0))
2487    (use (reg:CC 21))
2488    (clobber (reg:CC 21))]
2489   ""
2490   "andn\\t%N0,st"
2491   [(set_attr "type" "misc")
2492    (set_attr "data" "not_uint16")])
2493
2494 (define_split
2495   [(set (match_operand:QI 0 "std_reg_operand" "")
2496         (and:QI (match_operand:QI 1 "src_operand" "")
2497                 (match_operand:QI 2 "tsrc_operand" "")))
2498    (clobber (reg:CC 21))]
2499   "reload_completed"
2500   [(set (match_dup 0)
2501         (and:QI (match_dup 1)
2502                 (match_dup 2)))]
2503   "")
2504
2505 (define_insn "*andqi3_test"
2506   [(set (reg:CC 21)
2507         (compare:CC (and:QI (match_operand:QI 1 "src_operand" "%0,r,rR,rS<>")
2508                             (match_operand:QI 2 "tsrc_operand" "N,rLm,JR,rS<>"))
2509                     (const_int 0)))
2510    (clobber (match_scratch:QI 0 "=d,X,X,?X"))]
2511   "valid_operands (AND, operands, QImode)"
2512   "@
2513    andn\\t%N2,%0
2514    tstb\\t%2,%1
2515    tstb3\\t%2,%1
2516    tstb3\\t%2,%1"
2517   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")
2518    (set_attr "data" "not_uint16,uint16,int16,uint16")])
2519
2520 (define_peephole
2521   [(parallel [(set (match_operand:QI 0 "ext_reg_operand" "=d,d,d,?d")
2522                    (and:QI (match_operand:QI 1 "src_operand" "%0,0,rR,rS<>")
2523                            (match_operand:QI 2 "tsrc_operand" "N,rLm,JR,rS<>")))
2524               (clobber (reg:CC 21))])
2525    (set (reg:CC 21)
2526         (compare:CC (match_dup 0) (const_int 0)))]
2527   "valid_operands (AND, operands, QImode)"
2528   "@
2529    andn\\t%N2,%0
2530    and\\t%2,%0
2531    and3\\t%2,%1,%0
2532    and3\\t%2,%1,%0"
2533   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")
2534    (set_attr "data" "not_uint16,uint16,int16,uint16")])
2535   
2536 (define_insn "*andqi3_set"
2537   [(set (reg:CC 21)
2538         (compare:CC (and:QI (match_operand:QI 1 "src_operand" "%0,0,rR,rS<>")
2539                             (match_operand:QI 2 "tsrc_operand" "N,rLm,JR,rS<>"))
2540                     (const_int 0)))
2541    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d,?d")
2542         (and:QI (match_dup 1)
2543                 (match_dup 2)))]
2544   "valid_operands (AND, operands, QImode)"
2545   "@
2546    andn\\t%N2,%0
2547    and\\t%2,%0
2548    and3\\t%2,%1,%0
2549    and3\\t%2,%1,%0"
2550   [(set_attr "type" "binarycc,binarycc,binarycc,binarycc")
2551    (set_attr "data" "not_uint16,uint16,int16,uint16")])
2552
2553 ;
2554 ; ANDN
2555 ;
2556 ; NB, this insn doesn't have commutative operands, but valid_operands
2557 ; assumes that the code AND does.  We might have to kludge this if
2558 ; we make valid_operands stricter.
2559 (define_insn "*andnqi3_clobber"
2560   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2561         (and:QI (not:QI (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>,rLm,JR,rS<>"))
2562                 (match_operand:QI 1 "src_operand" "0,rR,rS<>,0,rR,rS<>")))
2563    (clobber (reg:CC 21))]
2564   "valid_operands (AND, operands, QImode)"
2565   "@
2566    andn\\t%2,%0
2567    andn3\\t%2,%1,%0
2568    andn3\\t%2,%1,%0
2569    andn\\t%2,%0
2570    andn3\\t%2,%1,%0
2571    andn3\\t%2,%1,%0"
2572   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")
2573    (set_attr "data" "uint16,int16,uint16,uint16,int16,uint16")])
2574
2575 (define_insn "*andnqi3_noclobber"
2576   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
2577         (and:QI (not:QI (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2578                 (match_operand:QI 1 "src_operand" "0,rR,rS<>")))]
2579   "valid_operands (AND, operands, QImode)"
2580   "@
2581    andn\\t%2,%0
2582    andn3\\t%2,%1,%0
2583    andn3\\t%2,%1,%0"
2584   [(set_attr "type" "binary,binary,binary")
2585    (set_attr "data" "uint16,int16,uint16")])
2586
2587 (define_split
2588   [(set (match_operand:QI 0 "std_reg_operand" "")
2589         (and:QI (not:QI (match_operand:QI 2 "lsrc_operand" ""))
2590                 (match_operand:QI 1 "src_operand" "")))
2591    (clobber (reg:CC 21))]
2592   "reload_completed"
2593   [(set (match_dup 0)
2594         (and:QI (not:QI (match_dup 2))
2595                 (match_dup 1)))]
2596   "")
2597
2598 (define_insn "*andnqi3_test"
2599   [(set (reg:CC 21)
2600         (compare:CC (and:QI (not:QI (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2601                             (match_operand:QI 1 "src_operand" "0,rR,rS<>"))
2602                     (const_int 0)))
2603    (clobber (match_scratch:QI 0 "=d,d,d"))]
2604   "valid_operands (AND, operands, QImode)"
2605   "@
2606    andn\\t%2,%0
2607    andn3\\t%2,%1,%0
2608    andn3\\t%2,%1,%0"
2609   [(set_attr "type" "binarycc,binarycc,binarycc")
2610    (set_attr "data" "uint16,int16,uint16")])
2611
2612 (define_insn "*andnqi3_set"
2613   [(set (reg:CC 21)
2614         (compare:CC (and:QI (not:QI (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2615                             (match_operand:QI 1 "src_operand" "0,rR,rS<>"))
2616                     (const_int 0)))
2617    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
2618         (and:QI (not:QI (match_dup 2))
2619                 (match_dup 1)))]
2620   "valid_operands (AND, operands, QImode)"
2621   "@
2622    andn\\t%2,%0
2623    andn3\\t%2,%1,%0
2624    andn3\\t%2,%1,%0"
2625   [(set_attr "type" "binarycc,binarycc,binarycc")
2626    (set_attr "data" "uint16,int16,uint16")])
2627
2628 ;
2629 ; OR
2630 ;
2631 (define_expand "iorqi3"
2632   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2633                    (ior:QI (match_operand:QI 1 "src_operand" "")
2634                            (match_operand:QI 2 "lsrc_operand" "")))
2635               (clobber (reg:CC 21))])]
2636  ""
2637  "legitimize_operands (IOR, operands, QImode);")
2638
2639 (define_insn "*iorqi3_clobber"
2640   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2641         (ior:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
2642                 (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>,rLm,JR,rS<>")))
2643    (clobber (reg:CC 21))]
2644   "valid_operands (IOR, operands, QImode)"
2645   "@
2646    or\\t%2,%0
2647    or3\\t%2,%1,%0
2648    or3\\t%2,%1,%0
2649    or\\t%2,%0
2650    or3\\t%2,%1,%0
2651    or3\\t%2,%1,%0"
2652   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")
2653    (set_attr "data" "uint16,int16,uint16,uint16,int16,uint16")])
2654
2655 (define_split
2656   [(set (match_operand:QI 0 "std_reg_operand" "")
2657         (ior:QI (match_operand:QI 1 "src_operand" "")
2658                 (match_operand:QI 2 "lsrc_operand" "")))
2659    (clobber (reg:CC 21))]
2660   "reload_completed"
2661   [(set (match_dup 0)
2662         (ior:QI (match_dup 1)
2663                 (match_dup 2)))]
2664   "")
2665
2666 (define_insn "*iorqi3_test"
2667   [(set (reg:CC 21)
2668         (compare:CC (ior:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2669                             (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2670                     (const_int 0)))
2671    (clobber (match_scratch:QI 0 "=d,d,d"))]
2672   "valid_operands (IOR, operands, QImode)"
2673   "@
2674    or\\t%2,%0
2675    or3\\t%2,%1,%0
2676    or3\\t%2,%1,%0"
2677   [(set_attr "type" "binarycc,binarycc,binarycc")
2678    (set_attr "data" "uint16,int16,uint16")])
2679
2680 (define_peephole
2681   [(parallel [(set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
2682                    (ior:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2683                            (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>")))
2684               (clobber (reg:CC 21))])
2685    (set (reg:CC 21)
2686         (compare:CC (match_dup 0) (const_int 0)))]
2687   "valid_operands (IOR, operands, QImode)"
2688   "@
2689    or\\t%2,%0
2690    or3\\t%2,%1,%0
2691    or3\\t%2,%1,%0"
2692   [(set_attr "type" "binarycc,binarycc,binarycc")
2693    (set_attr "data" "uint16,int16,uint16")])
2694   
2695 (define_insn "*iorqi3_set"
2696   [(set (reg:CC 21)
2697         (compare:CC (ior:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2698                             (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2699                     (const_int 0)))
2700    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
2701         (ior:QI (match_dup 1)
2702                 (match_dup 2)))]
2703   "valid_operands (IOR, operands, QImode)"
2704   "@
2705    or\\t%2,%0
2706    or3\\t%2,%1,%0
2707    or3\\t%2,%1,%0"
2708   [(set_attr "type" "binarycc,binarycc,binarycc")
2709    (set_attr "data" "uint16,int16,uint16")])
2710
2711 ; This pattern is used for loading symbol references in several parts. 
2712 (define_insn "iorqi3_noclobber"
2713   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,c")
2714         (ior:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2715                 (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>")))]
2716   "valid_operands (IOR, operands, QImode)"
2717   "@
2718    or\\t%2,%0
2719    or3\\t%2,%1,%0
2720    or3\\t%2,%1,%0"
2721   [(set_attr "type" "binary,binary,binary")
2722    (set_attr "data" "uint16,int16,uint16")])
2723
2724 ;
2725 ; XOR
2726 ;
2727 (define_expand "xorqi3"
2728   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2729                    (xor:QI (match_operand:QI 1 "src_operand" "")
2730                            (match_operand:QI 2 "lsrc_operand" "")))
2731               (clobber (reg:CC 21))])]
2732  ""
2733  "legitimize_operands (XOR, operands, QImode);")
2734
2735 (define_insn "*xorqi3_clobber"
2736   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2737         (xor:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>,0,rR,rS<>")
2738                 (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>,rLm,JR,rS<>")))
2739    (clobber (reg:CC 21))]
2740   "valid_operands (XOR, operands, QImode)"
2741   "@
2742    xor\\t%2,%0
2743    xor3\\t%2,%1,%0
2744    xor3\\t%2,%1,%0
2745    xor\\t%2,%0
2746    xor3\\t%2,%1,%0
2747    xor3\\t%2,%1,%0"
2748   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")
2749    (set_attr "data" "uint16,int16,uint16,uint16,int16,uint16")])
2750
2751 (define_insn "*xorqi3_noclobber"
2752   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
2753         (xor:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2754                 (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>")))]
2755   "valid_operands (XOR, operands, QImode)"
2756   "@
2757    xor\\t%2,%0
2758    xor3\\t%2,%1,%0
2759    xor3\\t%2,%1,%0"
2760   [(set_attr "type" "binary,binary,binary")
2761    (set_attr "data" "uint16,int16,uint16")])
2762
2763 (define_split
2764   [(set (match_operand:QI 0 "std_reg_operand" "")
2765         (xor:QI (match_operand:QI 1 "src_operand" "")
2766                 (match_operand:QI 2 "lsrc_operand" "")))
2767    (clobber (reg:CC 21))]
2768   "reload_completed"
2769   [(set (match_dup 0)
2770         (xor:QI (match_dup 1)
2771                 (match_dup 2)))]
2772   "")
2773
2774 (define_insn "*xorqi3_test"
2775   [(set (reg:CC 21)
2776         (compare:CC (xor:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2777                             (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2778                     (const_int 0)))
2779    (clobber (match_scratch:QI 0 "=d,d,d"))]
2780   "valid_operands (XOR, operands, QImode)"
2781   "@
2782    xor\\t%2,%0
2783    xor3\\t%2,%1,%0
2784    xor3\\t%2,%1,%0"
2785   [(set_attr "type" "binarycc,binarycc,binarycc")
2786    (set_attr "data" "uint16,int16,uint16")])
2787
2788 (define_insn "*xorqi3_set"
2789   [(set (reg:CC 21)
2790         (compare:CC (xor:QI (match_operand:QI 1 "src_operand" "%0,rR,rS<>")
2791                             (match_operand:QI 2 "lsrc_operand" "rLm,JR,rS<>"))
2792                     (const_int 0)))
2793    (set (match_operand:QI 0 "ext_reg_operand" "=d,d,d")
2794         (xor:QI (match_dup 1)
2795                 (match_dup 2)))]
2796   "valid_operands (XOR, operands, QImode)"
2797   "@
2798    xor\\t%2,%0
2799    xor3\\t%2,%1,%0
2800    xor3\\t%2,%1,%0"
2801   [(set_attr "type" "binarycc,binarycc,binarycc")
2802    (set_attr "data" "uint16,int16,uint16")])
2803
2804 ;
2805 ; LSH/ASH (left)
2806 ;
2807 ; The C3x and C4x have two shift instructions ASH and LSH
2808 ; If the shift count is positive, a left shift is performed
2809 ; otherwise a right shift is performed.  The number of bits
2810 ; shifted is determined by the seven LSBs of the shift count.
2811 ; If the absolute value of the count is 32 or greater, the result
2812 ; using the LSH instruction is zero; with the ASH insn the result
2813 ; is zero or negative 1.   Note that the ISO C standard allows 
2814 ; the result to be machine dependent whenever the shift count
2815 ; exceeds the size of the object.
2816 (define_expand "ashlqi3"
2817   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2818                    (ashift:QI (match_operand:QI 1 "src_operand" "")
2819                               (match_operand:QI 2 "src_operand" "")))
2820               (clobber (reg:CC 21))])]
2821  ""
2822  "legitimize_operands (ASHIFT, operands, QImode);")
2823
2824 (define_insn "*ashlqi3_clobber"
2825   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2826         (ashift:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>,0,rR,rS<>")
2827                    (match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")))
2828    (clobber (reg:CC 21))]
2829   "valid_operands (ASHIFT, operands, QImode)"
2830   "@
2831    ash\\t%2,%0
2832    ash3\\t%2,%1,%0
2833    ash3\\t%2,%1,%0
2834    ash\\t%2,%0
2835    ash3\\t%2,%1,%0
2836    ash3\\t%2,%1,%0"
2837   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
2838 ; Default to int16 data attr.
2839
2840 (define_insn "*ashlqi3_set"
2841   [(set (reg:CC 21)
2842         (compare:CC
2843           (ashift:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>")
2844                      (match_operand:QI 2 "src_operand" "rIm,JR,rS<>"))
2845           (const_int 0)))
2846    (set (match_operand:QI 0 "reg_operand" "=d,d,d")
2847         (ashift:QI (match_dup 1)
2848                    (match_dup 2)))]
2849   "valid_operands (ASHIFT, operands, QImode)"
2850   "@
2851    ash\\t%2,%0
2852    ash3\\t%2,%1,%0
2853    ash3\\t%2,%1,%0"
2854   [(set_attr "type" "binarycc,binarycc,binarycc")])
2855 ; Default to int16 data attr.
2856
2857 (define_insn "ashlqi3_noclobber"
2858   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
2859         (ashift:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>")
2860                    (match_operand:QI 2 "src_operand" "rIm,JR,rS<>")))]
2861   "valid_operands (ASHIFT, operands, QImode)"
2862   "@
2863    ash\\t%2,%0
2864    ash3\\t%2,%1,%0
2865    ash3\\t%2,%1,%0"
2866   [(set_attr "type" "binary,binary,binary")])
2867 ; Default to int16 data attr.
2868
2869 (define_split
2870   [(set (match_operand:QI 0 "std_reg_operand" "")
2871         (ashift:QI (match_operand:QI 1 "src_operand" "")
2872                    (match_operand:QI 2 "src_operand" "")))
2873    (clobber (reg:CC 21))]
2874   "reload_completed"
2875   [(set (match_dup 0)
2876         (ashift:QI (match_dup 1)
2877                    (match_dup 2)))]
2878   "")
2879
2880 ; This is only used by lshrhi3_reg where we need a LSH insn that will
2881 ; shift both ways.
2882 (define_insn "*lshlqi3_clobber"
2883   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2884         (ashift:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>,0,rR,rS<>")
2885                    (unspec:QI [(match_operand:QI 2 "src_operand" "rIm,JR,rS<>,rIm,JR,rS<>")] UNSPEC_LSH)))
2886    (clobber (reg:CC 21))]
2887   "valid_operands (ASHIFT, operands, QImode)"
2888   "@
2889    lsh\\t%2,%0
2890    lsh3\\t%2,%1,%0
2891    lsh3\\t%2,%1,%0
2892    lsh\\t%2,%0
2893    lsh3\\t%2,%1,%0
2894    lsh3\\t%2,%1,%0"
2895   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
2896 ; Default to int16 data attr.
2897
2898 ;
2899 ; LSH (right)
2900 ;
2901 ; Logical right shift on the C[34]x works by negating the shift count,
2902 ; then emitting a right shift with the shift count negated.  This means
2903 ; that all actual shift counts in the RTL will be positive.
2904 ;
2905 (define_expand "lshrqi3"
2906   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
2907                    (lshiftrt:QI (match_operand:QI 1 "src_operand" "")
2908                                 (match_operand:QI 2 "src_operand" "")))
2909               (clobber (reg:CC 21))])]
2910   ""
2911   "legitimize_operands (LSHIFTRT, operands, QImode);")
2912
2913
2914 (define_insn "*lshrqi3_24_clobber"
2915   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2916         (lshiftrt:QI (match_operand:QI 1 "src_operand" "mr,mr")
2917                      (const_int 24)))
2918    (clobber (reg:CC 21))]
2919   "! TARGET_C3X"
2920   "lbu3\\t%1,%0"
2921   [(set_attr "type" "unarycc")])
2922
2923
2924 (define_insn "*ashrqi3_24_clobber"
2925   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2926         (ashiftrt:QI (match_operand:QI 1 "src_operand" "mr,mr")
2927                      (const_int 24)))
2928    (clobber (reg:CC 21))]
2929   "! TARGET_C3X"
2930   "lb3\\t%1,%0"
2931   [(set_attr "type" "unarycc")])
2932
2933
2934 (define_insn "lshrqi3_16_clobber"
2935   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2936         (lshiftrt:QI (match_operand:QI 1 "src_operand" "mr,mr")
2937                      (const_int 16)))
2938    (clobber (reg:CC 21))]
2939   "! TARGET_C3X"
2940   "lhu1\\t%1,%0"
2941   [(set_attr "type" "unarycc")])
2942
2943
2944 (define_insn "*ashrqi3_16_clobber"
2945   [(set (match_operand:QI 0 "reg_operand" "=d,c")
2946         (ashiftrt:QI (match_operand:QI 1 "src_operand" "mr,mr")
2947                      (const_int 16)))
2948    (clobber (reg:CC 21))]
2949   "! TARGET_C3X"
2950   "lh1\\t%1,%0"
2951   [(set_attr "type" "unarycc")])
2952
2953
2954 ; When the shift count is greater than the size of the word
2955 ; the result can be implementation specific
2956 (define_insn "*lshrqi3_const_clobber"
2957   [(set (match_operand:QI 0 "reg_operand" "=d,c,?d,?c")
2958         (lshiftrt:QI (match_operand:QI 1 "src_operand" "0,0,r,r")
2959                      (match_operand:QI 2 "const_int_operand" "n,n,J,J")))
2960    (clobber (reg:CC 21))]
2961   "valid_operands (LSHIFTRT, operands, QImode)"
2962   "@
2963    lsh\\t%n2,%0
2964    lsh\\t%n2,%0
2965    lsh3\\t%n2,%1,%0
2966    lsh3\\t%n2,%1,%0"
2967   [(set_attr "type" "binarycc,binary,binarycc,binary")])
2968
2969 (define_insn "*lshrqi3_const_noclobber"
2970   [(set (match_operand:QI 0 "std_reg_operand" "=c,?c")
2971         (lshiftrt:QI (match_operand:QI 1 "src_operand" "0,r")
2972                      (match_operand:QI 2 "const_int_operand" "n,J")))]
2973   "valid_operands (LSHIFTRT, operands, QImode)"
2974   "@
2975    lsh\\t%n2,%0
2976    lsh3\\t%n2,%1,%0"
2977   [(set_attr "type" "binary,binary")])
2978
2979 ; When the shift count is greater than the size of the word
2980 ; the result can be implementation specific
2981 (define_insn "*lshrqi3_const_set"
2982   [(set (reg:CC 21)
2983         (compare:CC
2984           (lshiftrt:QI (match_operand:QI 1 "src_operand" "0,r")
2985                        (match_operand:QI 2 "const_int_operand" "n,J"))
2986           (const_int 0)))
2987    (set (match_operand:QI 0 "reg_operand" "=?d,d")
2988         (lshiftrt:QI (match_dup 1)
2989                      (match_dup 2)))]
2990   "valid_operands (LSHIFTRT, operands, QImode)"
2991   "@
2992    lsh\\t%n2,%0
2993    lsh3\\t%n2,%1,%0"
2994   [(set_attr "type" "binarycc,binarycc")])
2995
2996 (define_insn "*lshrqi3_nonconst_clobber"
2997   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
2998         (lshiftrt:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>,0,rR,rS<>")
2999                      (neg:QI (match_operand:QI 2 "src_operand" "rm,R,rS<>,rm,R,rS<>"))))
3000    (clobber (reg:CC 21))]
3001   "valid_operands (LSHIFTRT, operands, QImode)"
3002   "@
3003    lsh\\t%2,%0
3004    lsh3\\t%2,%1,%0
3005    lsh3\\t%2,%1,%0
3006    lsh\\t%2,%0
3007    lsh3\\t%2,%1,%0
3008    lsh3\\t%2,%1,%0"
3009   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
3010 ; Default to int16 data attr.
3011
3012 (define_insn "*lshrqi3_nonconst_noclobber"
3013   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
3014         (lshiftrt:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>")
3015                      (neg:QI (match_operand:QI 2 "src_operand" "rm,R,rS<>"))))]
3016   "valid_operands (LSHIFTRT, operands, QImode)"
3017   "@
3018    lsh\\t%2,%0
3019    lsh3\\t%2,%1,%0
3020    lsh3\\t%2,%1,%0"
3021   [(set_attr "type" "binary,binary,binary")])
3022 ; Default to int16 data attr.
3023
3024 ;
3025 ; ASH (right)
3026 ;
3027 ; Arithmetic right shift on the C[34]x works by negating the shift count,
3028 ; then emitting a right shift with the shift count negated.  This means
3029 ; that all actual shift counts in the RTL will be positive.
3030
3031 (define_expand "ashrqi3"
3032   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
3033                    (ashiftrt:QI (match_operand:QI 1 "src_operand" "")
3034                                 (match_operand:QI 2 "src_operand" "")))
3035               (clobber (reg:CC 21))])]
3036   ""
3037   "legitimize_operands (ASHIFTRT, operands, QImode);")
3038
3039 ; When the shift count is greater than the size of the word
3040 ; the result can be implementation specific
3041 (define_insn "*ashrqi3_const_clobber"
3042   [(set (match_operand:QI 0 "reg_operand" "=d,c,?d,?c")
3043         (ashiftrt:QI (match_operand:QI 1 "src_operand" "0,0,r,r")
3044                      (match_operand:QI 2 "const_int_operand" "n,n,J,J")))
3045    (clobber (reg:CC 21))]
3046   "valid_operands (ASHIFTRT, operands, QImode)"
3047   "@
3048    ash\\t%n2,%0
3049    ash\\t%n2,%0
3050    ash3\\t%n2,%1,%0
3051    ash3\\t%n2,%1,%0"
3052   [(set_attr "type" "binarycc,binary,binarycc,binary")])
3053
3054 (define_insn "*ashrqi3_const_noclobber"
3055   [(set (match_operand:QI 0 "std_reg_operand" "=c,?c")
3056         (ashiftrt:QI (match_operand:QI 1 "src_operand" "0,r")
3057                      (match_operand:QI 2 "const_int_operand" "n,J")))]
3058   "valid_operands (ASHIFTRT, operands, QImode)"
3059   "@
3060    ash\\t%n2,%0
3061    ash3\\t%n2,%1,%0"
3062   [(set_attr "type" "binarycc,binarycc")])
3063
3064 ; When the shift count is greater than the size of the word
3065 ; the result can be implementation specific
3066 (define_insn "*ashrqi3_const_set"
3067   [(set (reg:CC 21)
3068         (compare:CC
3069           (ashiftrt:QI (match_operand:QI 1 "src_operand" "0,r")
3070                        (match_operand:QI 2 "const_int_operand" "n,J"))
3071           (const_int 0)))
3072    (set (match_operand:QI 0 "reg_operand" "=?d,d")
3073         (ashiftrt:QI (match_dup 1)
3074                      (match_dup 2)))]
3075   "valid_operands (ASHIFTRT, operands, QImode)"
3076   "@
3077    ash\\t%n2,%0
3078    ash3\\t%n2,%1,%0"
3079   [(set_attr "type" "binarycc,binarycc")])
3080
3081 (define_insn "*ashrqi3_nonconst_clobber"
3082   [(set (match_operand:QI 0 "reg_operand" "=d,d,?d,c,c,?c")
3083         (ashiftrt:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>,0,rR,rS<>")
3084                      (neg:QI (match_operand:QI 2 "src_operand" "rm,R,rS<>,rm,R,rS<>"))))
3085    (clobber (reg:CC 21))]
3086   "valid_operands (ASHIFTRT, operands, QImode)"
3087   "@
3088    ash\\t%2,%0
3089    ash3\\t%2,%1,%0
3090    ash3\\t%2,%1,%0
3091    ash\\t%2,%0
3092    ash3\\t%2,%1,%0
3093    ash3\\t%2,%1,%0"
3094   [(set_attr "type" "binarycc,binarycc,binarycc,binary,binary,binary")])
3095 ; Default to int16 data attr.
3096
3097 (define_insn "*ashrqi3_nonconst_noclobber"
3098   [(set (match_operand:QI 0 "std_reg_operand" "=c,c,?c")
3099         (ashiftrt:QI (match_operand:QI 1 "src_operand" "0,rR,rS<>")
3100                      (neg:QI (match_operand:QI 2 "src_operand" "rm,R,rS<>"))))]
3101   "valid_operands (ASHIFTRT, operands, QImode)"
3102   "@
3103    ash\\t%2,%0
3104    ash3\\t%2,%1,%0
3105    ash3\\t%2,%1,%0"
3106   [(set_attr "type" "binary,binary,binary")])
3107 ; Default to int16 data attr.
3108
3109 ;
3110 ; CMPI
3111 ;
3112 ; Unfortunately the C40 doesn't allow cmpi3 7, *ar0++ so the next best
3113 ; thing would be to get the small constant loaded into a register (say r0)
3114 ; so that it could be hoisted out of the loop so that we only
3115 ; would need to do cmpi3 *ar0++, r0.  Now the loop optimization pass
3116 ; comes before the flow pass (which finds autoincrements) so we're stuck.
3117 ; Ideally, GCC requires another loop optimization pass (preferably after
3118 ; reload) so that it can hoist invariants out of loops.
3119 ; The current solution modifies legitimize_operands () so that small
3120 ; constants are forced into a pseudo register.
3121
3122 (define_expand "cmpqi"
3123   [(set (reg:CC 21)
3124         (compare:CC (match_operand:QI 0 "src_operand" "")
3125                     (match_operand:QI 1 "src_operand" "")))]
3126   ""
3127   "legitimize_operands (COMPARE, operands, QImode);
3128    c4x_compare_op0 = operands[0];
3129    c4x_compare_op1 = operands[1];
3130    DONE;")
3131
3132 (define_insn "*cmpqi_test"
3133   [(set (reg:CC 21)
3134         (compare:CC (match_operand:QI 0 "src_operand" "r,rR,rS<>")
3135                     (match_operand:QI 1 "src_operand" "rIm,JR,rS<>")))]
3136   "valid_operands (COMPARE, operands, QImode)"
3137   "@
3138    cmpi\\t%1,%0
3139    cmpi3\\t%1,%0
3140    cmpi3\\t%1,%0"
3141   [(set_attr "type" "compare,compare,compare")])
3142
3143 (define_insn "*cmpqi_test_noov"
3144   [(set (reg:CC_NOOV 21)
3145         (compare:CC_NOOV (match_operand:QI 0 "src_operand" "r,rR,rS<>")
3146                          (match_operand:QI 1 "src_operand" "rIm,JR,rS<>")))]
3147   "valid_operands (COMPARE, operands, QImode)"
3148   "@
3149    cmpi\\t%1,%0
3150    cmpi3\\t%1,%0
3151    cmpi3\\t%1,%0"
3152   [(set_attr "type" "compare,compare,compare")])
3153
3154
3155 ;
3156 ; BIT-FIELD INSTRUCTIONS
3157 ;
3158
3159 ;
3160 ; LBx/LHw (C4x only)
3161 ;
3162 (define_expand "extv"
3163   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
3164                    (sign_extract:QI (match_operand:QI 1 "src_operand" "")
3165                                     (match_operand:QI 2 "const_int_operand" "")
3166                                     (match_operand:QI 3 "const_int_operand" "")))
3167               (clobber (reg:CC 21))])]
3168  "! TARGET_C3X"
3169  "if ((INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16)
3170       || (INTVAL (operands[3]) % INTVAL (operands[2]) != 0))
3171         FAIL;
3172  ")
3173
3174 (define_insn "*extv_clobber"
3175   [(set (match_operand:QI 0 "reg_operand" "=d,c")
3176         (sign_extract:QI (match_operand:QI 1 "src_operand" "rLm,rLm")
3177                          (match_operand:QI 2 "const_int_operand" "n,n")
3178                          (match_operand:QI 3 "const_int_operand" "n,n")))
3179    (clobber (reg:CC 21))]
3180   "! TARGET_C3X
3181    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
3182    && (INTVAL (operands[3]) % INTVAL (operands[2]) == 0)"
3183   "*
3184    if (INTVAL (operands[2]) == 8)
3185      {
3186        operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
3187        return \"lb%3\\t%1,%0\";
3188      }
3189    operands[3] = GEN_INT (INTVAL (operands[3]) / 16);
3190    return \"lh%3\\t%1,%0\";
3191   "
3192   [(set_attr "type" "binarycc,binary")
3193    (set_attr "data" "int16,int16")])
3194
3195 (define_insn "*extv_clobber_test"
3196   [(set (reg:CC 21)
3197         (compare:CC (sign_extract:QI (match_operand:QI 1 "src_operand" "rLm")
3198                                      (match_operand:QI 2 "const_int_operand" "n")
3199                                      (match_operand:QI 3 "const_int_operand" "n"))
3200                     (const_int 0)))
3201    (clobber (match_scratch:QI 0 "=d"))]
3202   "! TARGET_C3X
3203    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
3204    && (INTVAL (operands[3]) % INTVAL (operands[2]) == 0)"
3205   "*
3206    if (INTVAL (operands[2]) == 8)
3207      {
3208        operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
3209        return \"lb%3\\t%1,%0\";
3210      }
3211    operands[3] = GEN_INT (INTVAL (operands[3]) / 16);
3212    return \"lh%3\\t%1,%0\";
3213   "
3214   [(set_attr "type" "binarycc")
3215    (set_attr "data" "int16")])
3216
3217 (define_insn "*extv_clobber_set"
3218   [(set (reg:CC 21)
3219         (compare:CC (sign_extract:QI (match_operand:QI 1 "src_operand" "rLm")
3220                                      (match_operand:QI 2 "const_int_operand" "n")
3221                                      (match_operand:QI 3 "const_int_operand" "n"))
3222                     (const_int 0)))
3223    (set (match_operand:QI 0 "reg_operand" "=d")
3224         (sign_extract:QI (match_dup 1)
3225                          (match_dup 2)
3226                          (match_dup 3)))]
3227   "! TARGET_C3X
3228    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
3229    && (INTVAL (operands[3]) % INTVAL (operands[2]) == 0)"
3230   "*
3231    if (INTVAL (operands[2]) == 8)
3232      {
3233        operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
3234        return \"lb%3\\t%1,%0\";
3235      }
3236    operands[3] = GEN_INT (INTVAL (operands[3]) / 16);
3237    return \"lh%3\\t%1,%0\";
3238   "
3239   [(set_attr "type" "binarycc")
3240    (set_attr "data" "int16")])
3241
3242 ;
3243 ; LBUx/LHUw (C4x only)
3244 ;
3245 (define_expand "extzv"
3246   [(parallel [(set (match_operand:QI 0 "reg_operand" "")
3247                    (zero_extract:QI (match_operand:QI 1 "src_operand" "")
3248                                     (match_operand:QI 2 "const_int_operand" "")
3249                                     (match_operand:QI 3 "const_int_operand" "")))
3250               (clobber (reg:CC 21))])]
3251  "! TARGET_C3X"
3252  "if ((INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16)
3253       || (INTVAL (operands[3]) % INTVAL (operands[2]) != 0))
3254         FAIL;
3255  ")
3256
3257 (define_insn "*extzv_clobber"
3258   [(set (match_operand:QI 0 "reg_operand" "=d,c")
3259         (zero_extract:QI (match_operand:QI 1 "src_operand" "rLm,rLm")
3260                          (match_operand:QI 2 "const_int_operand" "n,n")
3261                          (match_operand:QI 3 "const_int_operand" "n,n")))
3262    (clobber (reg:CC 21))]
3263   "! TARGET_C3X
3264    && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
3265    && (INTVAL (operands[3]) % INTVAL (operands[2]) == 0)"
3266   "*
3267    if (INTVAL (operands[2]) == 8)
3268      {
3269        operands[3] = GEN_INT (INTVAL (operands[3]) / 8);
3270        return \"lbu%3\\t%1,%0\";
3271      }
3272    operands[3] = GEN_INT (INTVAL (operands[3]) / 16);
3273    return \"lhu%3\\t%1,%0\";
3274   "
3275   [(set_attr "type" "binarycc,binary")
3276    (set_attr "data" "uint16,uint16")])
3277
3278 (define_insn "*extzv_test"
3279   [(set (reg:CC 21)
3280         (compare:CC (zero_extract:QI (match_operand:QI 1 "src_operand" "rLm")
3281                                      (match_operand:QI 2 "const_int_operand" "n")
3282                                      (match_operand:QI 3 "const_int_operand" "n"))
3283                     (const_int 0)))
3284    (clobber (match_scratch:QI 0 "=d"))]
3285   "! TARGET_C3X
3286    && (INTVAL (ope