Mercurial > hg > CbC > CbC_gcc
view gcc/config/mcore/mcore.md @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | 84e7813d76e9 |
| children |
line wrap: on
line source
;; Machine description the Motorola MCore ;; Copyright (C) 1993-2020 Free Software Foundation, Inc. ;; Contributed by Motorola. ;; This file is part of GCC. ;; GCC is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation; either version 3, or (at your option) ;; any later version. ;; GCC is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with GCC; see the file COPYING3. If not see ;; <http://www.gnu.org/licenses/>. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al. ;; ------------------------------------------------------------------------- ;; Attributes ;; ------------------------------------------------------------------------- ; Target CPU. (define_attr "type" "brcond,branch,jmp,load,store,move,alu,shift" (const_string "alu")) ;; If a branch destination is within -2048..2047 bytes away from the ;; instruction it can be 2 bytes long. All other conditional branches ;; are 10 bytes long, and all other unconditional branches are 8 bytes. ;; ;; the assembler handles the long-branch span case for us if we use ;; the "jb*" mnemonics for jumps/branches. This pushes the span ;; calculations and the literal table placement into the assembler, ;; where their interactions can be managed in a single place. ;; All MCORE instructions are two bytes long. (define_attr "length" "" (const_int 2)) ;; Scheduling. We only model a simple load latency. (define_insn_reservation "any_insn" 1 (eq_attr "type" "!load") "nothing") (define_insn_reservation "memory" 2 (eq_attr "type" "load") "nothing") (include "predicates.md") (include "constraints.md") ;; ------------------------------------------------------------------------- ;; Test and bit test ;; ------------------------------------------------------------------------- (define_insn "" [(set (reg:SI 17) (sign_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 1) (match_operand:SI 1 "mcore_literal_K_operand" "K")))] "" "btsti %0,%1" [(set_attr "type" "shift")]) (define_insn "" [(set (reg:SI 17) (zero_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 1) (match_operand:SI 1 "mcore_literal_K_operand" "K")))] "" "btsti %0,%1" [(set_attr "type" "shift")]) ;;; This is created by combine. (define_insn "" [(set (reg:CC 17) (ne:CC (zero_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 1) (match_operand:SI 1 "mcore_literal_K_operand" "K")) (const_int 0)))] "" "btsti %0,%1" [(set_attr "type" "shift")]) ;; Created by combine from conditional patterns below (see sextb/btsti rx,31) (define_insn "" [(set (reg:CC 17) (ne:CC (lshiftrt:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 7)) (const_int 0)))] "GET_CODE(operands[0]) == SUBREG && GET_MODE(SUBREG_REG(operands[0])) == QImode" "btsti %0,7" [(set_attr "type" "shift")]) (define_insn "" [(set (reg:CC 17) (ne:CC (lshiftrt:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 15)) (const_int 0)))] "GET_CODE(operands[0]) == SUBREG && GET_MODE(SUBREG_REG(operands[0])) == HImode" "btsti %0,15" [(set_attr "type" "shift")]) (define_split [(set (pc) (if_then_else (ne (eq:CC (zero_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "") (const_int 1) (match_operand:SI 1 "mcore_literal_K_operand" "")) (const_int 0)) (const_int 0)) (label_ref (match_operand 2 "" "")) (pc)))] "" [(set (reg:CC 17) (zero_extract:SI (match_dup 0) (const_int 1) (match_dup 1))) (set (pc) (if_then_else (eq (reg:CC 17) (const_int 0)) (label_ref (match_dup 2)) (pc)))] "") (define_split [(set (pc) (if_then_else (eq (ne:CC (zero_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "") (const_int 1) (match_operand:SI 1 "mcore_literal_K_operand" "")) (const_int 0)) (const_int 0)) (label_ref (match_operand 2 "" "")) (pc)))] "" [(set (reg:CC 17) (zero_extract:SI (match_dup 0) (const_int 1) (match_dup 1))) (set (pc) (if_then_else (eq (reg:CC 17) (const_int 0)) (label_ref (match_dup 2)) (pc)))] "") ;; XXX - disabled by nickc because it fails on libiberty/fnmatch.c ;; ;; ; Experimental - relax immediates for and, andn, or, and tst to allow ;; ; any immediate value (or an immediate at all -- or, andn, & tst). ;; ; This is done to allow bit field masks to fold together in combine. ;; ; The reload phase will force the immediate into a register at the ;; ; very end. This helps in some cases, but hurts in others: we'd ;; ; really like to cse these immediates. However, there is a phase ;; ; ordering problem here. cse picks up individual masks and cse's ;; ; those, but not folded masks (cse happens before combine). It's ;; ; not clear what the best solution is because we really want cse ;; ; before combine (leaving the bit field masks alone). To pick up ;; ; relaxed immediates use -mrelax-immediates. It might take some ;; ; experimenting to see which does better (i.e. regular imms vs. ;; ; arbitrary imms) for a particular code. BRC ;; ;; (define_insn "" ;; [(set (reg:CC 17) ;; (ne:CC (and:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") ;; (match_operand:SI 1 "mcore_arith_any_imm_operand" "rI")) ;; (const_int 0)))] ;; "TARGET_RELAX_IMM" ;; "tst %0,%1") ;; ;; (define_insn "" ;; [(set (reg:CC 17) ;; (ne:CC (and:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") ;; (match_operand:SI 1 "mcore_arith_M_operand" "r")) ;; (const_int 0)))] ;; "!TARGET_RELAX_IMM" ;; "tst %0,%1") (define_insn "" [(set (reg:CC 17) (ne:CC (and:SI (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_M_operand" "r")) (const_int 0)))] "" "tst %0,%1") (define_split [(parallel[ (set (reg:CC 17) (ne:CC (ne:SI (leu:CC (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "mcore_arith_reg_operand" "")) (const_int 0)) (const_int 0))) (clobber (match_operand:CC 2 "mcore_arith_reg_operand" ""))])] "" [(set (reg:CC 17) (ne:SI (match_dup 0) (const_int 0))) (set (reg:CC 17) (leu:CC (match_dup 0) (match_dup 1)))]) ;; ------------------------------------------------------------------------- ;; SImode signed integer comparisons ;; ------------------------------------------------------------------------- (define_insn "decne_t" [(set (reg:CC 17) (ne:CC (plus:SI (match_operand:SI 0 "mcore_arith_reg_operand" "+r") (const_int -1)) (const_int 0))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))] "" "decne %0") ;; The combiner seems to prefer the following to the former. ;; (define_insn "" [(set (reg:CC 17) (ne:CC (match_operand:SI 0 "mcore_arith_reg_operand" "+r") (const_int 1))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))] "" "decne %0") (define_insn "cmpnesi_t" [(set (reg:CC 17) (ne:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "cmpne %0,%1") (define_insn "cmpneisi_t" [(set (reg:CC 17) (ne:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_K_operand" "K")))] "" "cmpnei %0,%1") (define_insn "cmpgtsi_t" [(set (reg:CC 17) (gt:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "cmplt %1,%0") (define_insn "" [(set (reg:CC 17) (gt:CC (plus:SI (match_operand:SI 0 "mcore_arith_reg_operand" "+r") (const_int -1)) (const_int 0))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))] "" "decgt %0") (define_insn "cmpltsi_t" [(set (reg:CC 17) (lt:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "cmplt %0,%1") ; cmplti is 1-32 (define_insn "cmpltisi_t" [(set (reg:CC 17) (lt:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_J_operand" "J")))] "" "cmplti %0,%1") ; covers cmplti x,0 (define_insn "" [(set (reg:CC 17) (lt:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 0)))] "" "btsti %0,31") (define_insn "" [(set (reg:CC 17) (lt:CC (plus:SI (match_operand:SI 0 "mcore_arith_reg_operand" "+r") (const_int -1)) (const_int 0))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1)))] "" "declt %0") ;; ------------------------------------------------------------------------- ;; SImode unsigned integer comparisons ;; ------------------------------------------------------------------------- (define_insn "cmpgeusi_t" [(set (reg:CC 17) (geu:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "cmphs %0,%1") (define_insn "cmpgeusi_0" [(set (reg:CC 17) (geu:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (const_int 0)))] "" "cmpnei %0, 0") (define_insn "cmpleusi_t" [(set (reg:CC 17) (leu:CC (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "cmphs %1,%0") ;; ------------------------------------------------------------------------- ;; Logical operations ;; ------------------------------------------------------------------------- ;; Logical AND clearing a single bit. andsi3 knows that we have this ;; pattern and allows the constant literal pass through. ;; ;; RBE 2/97: don't need this pattern any longer... ;; RBE: I don't think we need both "S" and exact_log2() clauses. ;;(define_insn "" ;; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ;; (and:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") ;; (match_operand:SI 2 "const_int_operand" "S")))] ;; "mcore_arith_S_operand (operands[2])" ;; "bclri %0,%Q2") ;; (define_insn "andnsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (and:SI (not:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r")) (match_operand:SI 2 "mcore_arith_reg_operand" "0")))] "" "andn %0,%1") (define_expand "andsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (and:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "nonmemory_operand" "")))] "" " { if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 0 && ! mcore_arith_S_operand (operands[2])) { HOST_WIDE_INT not_value = ~ INTVAL (operands[2]); if ( CONST_OK_FOR_I (not_value) || CONST_OK_FOR_M (not_value) || CONST_OK_FOR_N (not_value)) { operands[2] = copy_to_mode_reg (SImode, GEN_INT (not_value)); emit_insn (gen_andnsi3 (operands[0], operands[2], operands[1])); DONE; } } if (! mcore_arith_K_S_operand (operands[2], SImode)) operands[2] = copy_to_mode_reg (SImode, operands[2]); }") (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (and:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0,r,0") (match_operand:SI 2 "mcore_arith_any_imm_operand" "r,K,0,S")))] "TARGET_RELAX_IMM" "* { switch (which_alternative) { case 0: return \"and %0,%2\"; case 1: return \"andi %0,%2\"; case 2: return \"and %0,%1\"; /* case -1: return \"bclri %0,%Q2\"; will not happen */ case 3: return mcore_output_bclri (operands[0], INTVAL (operands[2])); default: gcc_unreachable (); } }") ;; This was the old "S" which was "!(2^n)" */ ;; case -1: return \"bclri %0,%Q2\"; will not happen */ (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (and:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0,r,0") (match_operand:SI 2 "mcore_arith_K_S_operand" "r,K,0,S")))] "!TARGET_RELAX_IMM" "* { switch (which_alternative) { case 0: return \"and %0,%2\"; case 1: return \"andi %0,%2\"; case 2: return \"and %0,%1\"; case 3: return mcore_output_bclri (operands[0], INTVAL (operands[2])); default: gcc_unreachable (); } }") ;(define_insn "iorsi3" ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ; (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") ; (match_operand:SI 2 "mcore_arith_reg_operand" "r")))] ; "" ; "or %0,%2") ; need an expand to resolve ambiguity betw. the two iors below. (define_expand "iorsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "nonmemory_operand" "")))] "" " { if (! mcore_arith_M_operand (operands[2], SImode)) operands[2] = copy_to_mode_reg (SImode, operands[2]); }") (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r") (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0,0,0") (match_operand:SI 2 "mcore_arith_any_imm_operand" "r,M,T")))] "TARGET_RELAX_IMM" "* { switch (which_alternative) { case 0: return \"or %0,%2\"; case 1: return \"bseti %0,%P2\"; case 2: return mcore_output_bseti (operands[0], INTVAL (operands[2])); default: gcc_unreachable (); } }") (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r") (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0,0,0") (match_operand:SI 2 "mcore_arith_M_operand" "r,M,T")))] "!TARGET_RELAX_IMM" "* { switch (which_alternative) { case 0: return \"or %0,%2\"; case 1: return \"bseti %0,%P2\"; case 2: return mcore_output_bseti (operands[0], INTVAL (operands[2])); default: gcc_unreachable (); } }") ;(define_insn "" ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ; (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") ; (match_operand:SI 2 "const_int_operand" "M")))] ; "exact_log2 (INTVAL (operands[2])) >= 0" ; "bseti %0,%P2") ;(define_insn "" ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ; (ior:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") ; (match_operand:SI 2 "const_int_operand" "i")))] ; "mcore_num_ones (INTVAL (operands[2])) < 3" ; "* return mcore_output_bseti (operands[0], INTVAL (operands[2]));") (define_insn "xorsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (xor:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") (match_operand:SI 2 "mcore_arith_reg_operand" "r")))] "" "xor %0,%2") ;; ------------------------------------------------------------------------- ;; Shifts and rotates ;; ------------------------------------------------------------------------- ;; Only allow these if the shift count is a convenient constant. (define_expand "rotlsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (rotate:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "nonmemory_operand" "")))] "" "if (! mcore_literal_K_operand (operands[2], SImode)) FAIL; ") ;; We can only do constant rotates, which is what this pattern provides. ;; The combiner will put it together for us when we do: ;; (x << N) | (x >> (32 - N)) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (rotate:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (match_operand:SI 2 "mcore_literal_K_operand" "K")))] "" "rotli %0,%2" [(set_attr "type" "shift")]) (define_insn "ashlsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r") (ashift:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0") (match_operand:SI 2 "mcore_arith_K_operand_not_0" "r,K")))] "" "@ lsl %0,%2 lsli %0,%2" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (ashift:SI (const_int 1) (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "bgenr %0,%1" [(set_attr "type" "shift")]) (define_insn "ashrsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r") (ashiftrt:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0") (match_operand:SI 2 "mcore_arith_K_operand_not_0" "r,K")))] "" "@ asr %0,%2 asri %0,%2" [(set_attr "type" "shift")]) (define_insn "lshrsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r") (lshiftrt:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0") (match_operand:SI 2 "mcore_arith_K_operand_not_0" "r,K")))] "" "@ lsr %0,%2 lsri %0,%2" [(set_attr "type" "shift")]) ;(define_expand "ashldi3" ; [(parallel[(set (match_operand:DI 0 "mcore_arith_reg_operand" "") ; (ashift:DI (match_operand:DI 1 "mcore_arith_reg_operand" "") ; (match_operand:DI 2 "immediate_operand" ""))) ; ; (clobber (reg:CC 17))])] ; ; "" ; " ;{ ; if (GET_CODE (operands[2]) != CONST_INT ; || INTVAL (operands[2]) != 1) ; FAIL; ;}") ; ;(define_insn "" ; [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=r") ; (ashift:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0") ; (const_int 1))) ; (clobber (reg:CC 17))] ; "" ; "lsli %R0,0\;rotli %0,0" ; [(set_attr "length" "4") (set_attr "type" "shift")]) ;; ------------------------------------------------------------------------- ;; Index instructions ;; ------------------------------------------------------------------------- ;; The second of each set of patterns is borrowed from the alpha.md file. ;; These variants of the above insns can occur if the second operand ;; is the frame pointer. This is a kludge, but there doesn't ;; seem to be a way around it. Only recognize them while reloading. ;; We must use reload_operand for some operands in case frame pointer ;; elimination put a MEM with invalid address there. Otherwise, ;; the result of the substitution will not match this pattern, and reload ;; will not be able to correctly fix the result. ;; indexing longlongs or doubles (8 bytes) (define_insn "indexdi_t" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (plus:SI (mult:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 8)) (match_operand:SI 2 "mcore_arith_reg_operand" "0")))] "" "* if (! mcore_is_same_reg (operands[1], operands[2])) { output_asm_insn (\"ixw\\t%0,%1\", operands); output_asm_insn (\"ixw\\t%0,%1\", operands); } else { output_asm_insn (\"ixh\\t%0,%1\", operands); output_asm_insn (\"ixh\\t%0,%1\", operands); } return \"\"; " ;; if operands[1] == operands[2], the first option above is wrong! -- dac ;; was this... -- dac ;; ixw %0,%1\;ixw %0,%1" [(set_attr "length" "4")]) (define_insn "" [(set (match_operand:SI 0 "mcore_reload_operand" "=r,r,r") (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "mcore_reload_operand" "r,r,r") (const_int 8)) (match_operand:SI 2 "mcore_arith_reg_operand" "0,0,0")) (match_operand:SI 3 "mcore_addsub_operand" "r,J,L")))] "reload_in_progress" "@ ixw %0,%1\;ixw %0,%1\;addu %0,%3 ixw %0,%1\;ixw %0,%1\;addi %0,%3 ixw %0,%1\;ixw %0,%1\;subi %0,%M3" [(set_attr "length" "6")]) ;; indexing longs (4 bytes) (define_insn "indexsi_t" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (plus:SI (mult:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 4)) (match_operand:SI 2 "mcore_arith_reg_operand" "0")))] "" "ixw %0,%1") (define_insn "" [(set (match_operand:SI 0 "mcore_reload_operand" "=r,r,r") (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "mcore_reload_operand" "r,r,r") (const_int 4)) (match_operand:SI 2 "mcore_arith_reg_operand" "0,0,0")) (match_operand:SI 3 "mcore_addsub_operand" "r,J,L")))] "reload_in_progress" "@ ixw %0,%1\;addu %0,%3 ixw %0,%1\;addi %0,%3 ixw %0,%1\;subi %0,%M3" [(set_attr "length" "4")]) ;; indexing shorts (2 bytes) (define_insn "indexhi_t" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (plus:SI (mult:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 2)) (match_operand:SI 2 "mcore_arith_reg_operand" "0")))] "" "ixh %0,%1") (define_insn "" [(set (match_operand:SI 0 "mcore_reload_operand" "=r,r,r") (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "mcore_reload_operand" "r,r,r") (const_int 2)) (match_operand:SI 2 "mcore_arith_reg_operand" "0,0,0")) (match_operand:SI 3 "mcore_addsub_operand" "r,J,L")))] "reload_in_progress" "@ ixh %0,%1\;addu %0,%3 ixh %0,%1\;addi %0,%3 ixh %0,%1\;subi %0,%M3" [(set_attr "length" "4")]) ;; ;; Other sizes may be handy for indexing. ;; the tradeoffs to consider when adding these are ;; code size, execution time [vs. mul it is easy to win], ;; and register pressure -- these patterns don't use an extra ;; register to build the offset from the base ;; and whether the compiler will not come up with some other idiom. ;; ;; ------------------------------------------------------------------------- ;; Addition, Subtraction instructions ;; ------------------------------------------------------------------------- (define_expand "addsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "nonmemory_operand" "")))] "" " { /* If this is an add to the frame pointer, then accept it as is so that we can later fold in the fp/sp offset from frame pointer elimination. */ if (flag_omit_frame_pointer && GET_CODE (operands[1]) == REG && (REGNO (operands[1]) == VIRTUAL_STACK_VARS_REGNUM || REGNO (operands[1]) == FRAME_POINTER_REGNUM)) { emit_insn (gen_addsi3_fp (operands[0], operands[1], operands[2])); DONE; } /* Convert adds to subtracts if this makes loading the constant cheaper. But only if we are allowed to generate new pseudos. */ if (! (reload_in_progress || reload_completed) && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < -32) { HOST_WIDE_INT neg_value = - INTVAL (operands[2]); if ( CONST_OK_FOR_I (neg_value) || CONST_OK_FOR_M (neg_value) || CONST_OK_FOR_N (neg_value)) { operands[2] = copy_to_mode_reg (SImode, GEN_INT (neg_value)); emit_insn (gen_subsi3 (operands[0], operands[1], operands[2])); DONE; } } if (! mcore_addsub_operand (operands[2], SImode)) operands[2] = copy_to_mode_reg (SImode, operands[2]); }") ;; RBE: for some constants which are not in the range which allows ;; us to do a single operation, we will try a paired addi/addi instead ;; of a movi/addi. This relieves some register pressure at the expense ;; of giving away some potential constant reuse. ;; ;; RBE 6/17/97: this didn't buy us anything, but I keep the pattern ;; for later reference ;; ;; (define_insn "addsi3_i2" ;; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ;; (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") ;; (match_operand:SI 2 "const_int_operand" "g")))] ;; "GET_CODE(operands[2]) == CONST_INT ;; && ((INTVAL (operands[2]) > 32 && INTVAL(operands[2]) <= 64) ;; || (INTVAL (operands[2]) < -32 && INTVAL(operands[2]) >= -64))" ;; "* ;; { ;; HOST_WIDE_INT n = INTVAL(operands[2]); ;; if (n > 0) ;; { ;; operands[2] = GEN_INT(n - 32); ;; return \"addi\\t%0,32\;addi\\t%0,%2\"; ;; } ;; else ;; { ;; n = (-n); ;; operands[2] = GEN_INT(n - 32); ;; return \"subi\\t%0,32\;subi\\t%0,%2\"; ;; } ;; }" ;; [(set_attr "length" "4")]) (define_insn "addsi3_i" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r") (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0,0,0") (match_operand:SI 2 "mcore_addsub_operand" "r,J,L")))] "" "@ addu %0,%2 addi %0,%2 subi %0,%M2") ;; This exists so that address computations based on the frame pointer ;; can be folded in when frame pointer elimination occurs. Ordinarily ;; this would be bad because it allows insns which would require reloading, ;; but without it, we get multiple adds where one would do. (define_insn "addsi3_fp" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r") (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0,0,0") (match_operand:SI 2 "immediate_operand" "r,J,L")))] "flag_omit_frame_pointer && (reload_in_progress || reload_completed || REGNO (operands[1]) == FRAME_POINTER_REGNUM)" "@ addu %0,%2 addi %0,%2 subi %0,%M2") ;; RBE: for some constants which are not in the range which allows ;; us to do a single operation, we will try a paired addi/addi instead ;; of a movi/addi. This relieves some register pressure at the expense ;; of giving away some potential constant reuse. ;; ;; RBE 6/17/97: this didn't buy us anything, but I keep the pattern ;; for later reference ;; ;; (define_insn "subsi3_i2" ;; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ;; (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") ;; (match_operand:SI 2 "const_int_operand" "g")))] ;; "TARGET_RBETEST && GET_CODE(operands[2]) == CONST_INT ;; && ((INTVAL (operands[2]) > 32 && INTVAL(operands[2]) <= 64) ;; || (INTVAL (operands[2]) < -32 && INTVAL(operands[2]) >= -64))" ;; "* ;; { ;; HOST_WIDE_INT n = INTVAL(operands[2]); ;; if ( n > 0) ;; { ;; operands[2] = GEN_INT( n - 32); ;; return \"subi\\t%0,32\;subi\\t%0,%2\"; ;; } ;; else ;; { ;; n = (-n); ;; operands[2] = GEN_INT(n - 32); ;; return \"addi\\t%0,32\;addi\\t%0,%2\"; ;; } ;; }" ;; [(set_attr "length" "4")]) ;(define_insn "subsi3" ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") ; (minus:SI (match_operand:SI 1 "mcore_arith_K_operand" "0,0,r,K") ; (match_operand:SI 2 "mcore_arith_J_operand" "r,J,0,0")))] ; "" ; "@ ; sub %0,%2 ; subi %0,%2 ; rsub %0,%1 ; rsubi %0,%1") (define_insn "subsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r") (minus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,0,r") (match_operand:SI 2 "mcore_arith_J_operand" "r,J,0")))] "" "@ subu %0,%2 subi %0,%2 rsub %0,%1") (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (minus:SI (match_operand:SI 1 "mcore_literal_K_operand" "K") (match_operand:SI 2 "mcore_arith_reg_operand" "0")))] "" "rsubi %0,%1") (define_insn "adddi3" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "%0") (match_operand:DI 2 "mcore_arith_reg_operand" "r"))) (clobber (reg:CC 17))] "" "* { if (TARGET_LITTLE_END) return \"cmplt %0,%0\;addc %0,%2\;addc %R0,%R2\"; return \"cmplt %R0,%R0\;addc %R0,%R2\;addc %0,%2\"; }" [(set_attr "length" "6")]) ;; special case for "longlong += 1" (define_insn "" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0") (const_int 1))) (clobber (reg:CC 17))] "" "* { if (TARGET_LITTLE_END) return \"addi %0,1\;cmpnei %0,0\;incf %R0\"; return \"addi %R0,1\;cmpnei %R0,0\;incf %0\"; }" [(set_attr "length" "6")]) ;; special case for "longlong -= 1" (define_insn "" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0") (const_int -1))) (clobber (reg:CC 17))] "" "* { if (TARGET_LITTLE_END) return \"cmpnei %0,0\;decf %R0\;subi %0,1\"; return \"cmpnei %R0,0\;decf %0\;subi %R0,1\"; }" [(set_attr "length" "6")]) ;; special case for "longlong += const_int" ;; we have to use a register for the const_int because we don't ;; have an unsigned compare immediate... only +/- 1 get to ;; play the no-extra register game because they compare with 0. ;; This winds up working out for any literal that is synthesized ;; with a single instruction. The more complicated ones look ;; like the get broken into subreg's to get initialized too soon ;; for us to catch here. -- RBE 4/25/96 ;; only allow for-sure positive values. (define_insn "" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0") (match_operand:SI 2 "const_int_operand" "r"))) (clobber (reg:CC 17))] "GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) > 0 && ! (INTVAL (operands[2]) & 0x80000000)" "* { gcc_assert (GET_MODE (operands[2]) == SImode); if (TARGET_LITTLE_END) return \"addu %0,%2\;cmphs %0,%2\;incf %R0\"; return \"addu %R0,%2\;cmphs %R0,%2\;incf %0\"; }" [(set_attr "length" "6")]) ;; optimize "long long" + "unsigned long" ;; won't trigger because of how the extension is expanded upstream. ;; (define_insn "" ;; [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") ;; (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "%0") ;; (zero_extend:DI (match_operand:SI 2 "mcore_arith_reg_operand" "r")))) ;; (clobber (reg:CC 17))] ;; "0" ;; "cmplt %R0,%R0\;addc %R0,%2\;inct %0" ;; [(set_attr "length" "6")]) ;; optimize "long long" + "signed long" ;; won't trigger because of how the extension is expanded upstream. ;; (define_insn "" ;; [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") ;; (plus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "%0") ;; (sign_extend:DI (match_operand:SI 2 "mcore_arith_reg_operand" "r")))) ;; (clobber (reg:CC 17))] ;; "0" ;; "cmplt %R0,%R0\;addc %R0,%2\;inct %0\;btsti %2,31\;dect %0" ;; [(set_attr "length" "6")]) (define_insn "subdi3" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (minus:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0") (match_operand:DI 2 "mcore_arith_reg_operand" "r"))) (clobber (reg:CC 17))] "" "* { if (TARGET_LITTLE_END) return \"cmphs %0,%0\;subc %0,%2\;subc %R0,%R2\"; return \"cmphs %R0,%R0\;subc %R0,%R2\;subc %0,%2\"; }" [(set_attr "length" "6")]) ;; ------------------------------------------------------------------------- ;; Multiplication instructions ;; ------------------------------------------------------------------------- (define_insn "mulsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (mult:SI (match_operand:SI 1 "mcore_arith_reg_operand" "%0") (match_operand:SI 2 "mcore_arith_reg_operand" "r")))] "" "mult %0,%2") ;; ;; 32/32 signed division -- added to the MCORE instruction set spring 1997 ;; ;; Different constraints based on the architecture revision... ;; (define_expand "divsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (div:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "TARGET_DIV" "") ;; MCORE Revision 1.50: restricts the divisor to be in r1. (6/97) ;; (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (div:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (match_operand:SI 2 "mcore_arith_reg_operand" "b")))] "TARGET_DIV" "divs %0,%2") ;; ;; 32/32 signed division -- added to the MCORE instruction set spring 1997 ;; ;; Different constraints based on the architecture revision... ;; (define_expand "udivsi3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (udiv:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "TARGET_DIV" "") ;; MCORE Revision 1.50: restricts the divisor to be in r1. (6/97) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (udiv:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (match_operand:SI 2 "mcore_arith_reg_operand" "b")))] "TARGET_DIV" "divu %0,%2") ;; ------------------------------------------------------------------------- ;; Unary arithmetic ;; ------------------------------------------------------------------------- (define_insn "negsi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (neg:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0")))] "" "* { return \"rsubi %0,0\"; }") (define_insn "abssi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (abs:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0")))] "" "abs %0") (define_insn "negdi2" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=&r") (neg:DI (match_operand:DI 1 "mcore_arith_reg_operand" "0"))) (clobber (reg:CC 17))] "" "* { if (TARGET_LITTLE_END) return \"cmpnei %0,0\\n\\trsubi %0,0\\n\\tnot %R0\\n\\tincf %R0\"; return \"cmpnei %R0,0\\n\\trsubi %R0,0\\n\\tnot %0\\n\\tincf %0\"; }" [(set_attr "length" "8")]) (define_insn "one_cmplsi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (not:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0")))] "" "not %0") ;; ------------------------------------------------------------------------- ;; Zero extension instructions ;; ------------------------------------------------------------------------- (define_expand "zero_extendhisi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (zero_extend:SI (match_operand:HI 1 "mcore_arith_reg_operand" "")))] "" "") (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r") (zero_extend:SI (match_operand:HI 1 "general_operand" "0,m")))] "" "@ zexth %0 ld.h %0,%1" [(set_attr "type" "shift,load")]) ;; ldh gives us a free zero-extension. The combiner picks up on this. (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (zero_extend:SI (mem:HI (match_operand:SI 1 "mcore_arith_reg_operand" "r"))))] "" "ld.h %0,(%1)" [(set_attr "type" "load")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (zero_extend:SI (mem:HI (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (match_operand:SI 2 "const_int_operand" "")))))] "(INTVAL (operands[2]) >= 0) && (INTVAL (operands[2]) < 32) && ((INTVAL (operands[2])&1) == 0)" "ld.h %0,(%1,%2)" [(set_attr "type" "load")]) (define_expand "zero_extendqisi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (zero_extend:SI (match_operand:QI 1 "general_operand" "")))] "" "") ;; RBE: XXX: we don't recognize that the xtrb3 kills the CC register. (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,b,r") (zero_extend:SI (match_operand:QI 1 "general_operand" "0,r,m")))] "" "@ zextb %0 xtrb3 %0,%1 ld.b %0,%1" [(set_attr "type" "shift,shift,load")]) ;; ldb gives us a free zero-extension. The combiner picks up on this. (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (zero_extend:SI (mem:QI (match_operand:SI 1 "mcore_arith_reg_operand" "r"))))] "" "ld.b %0,(%1)" [(set_attr "type" "load")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (zero_extend:SI (mem:QI (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (match_operand:SI 2 "const_int_operand" "")))))] "(INTVAL (operands[2]) >= 0) && (INTVAL (operands[2]) < 16)" "ld.b %0,(%1,%2)" [(set_attr "type" "load")]) (define_expand "zero_extendqihi2" [(set (match_operand:HI 0 "mcore_arith_reg_operand" "") (zero_extend:HI (match_operand:QI 1 "general_operand" "")))] "" "") ;; RBE: XXX: we don't recognize that the xtrb3 kills the CC register. (define_insn "" [(set (match_operand:HI 0 "mcore_arith_reg_operand" "=r,b,r") (zero_extend:HI (match_operand:QI 1 "general_operand" "0,r,m")))] "" "@ zextb %0 xtrb3 %0,%1 ld.b %0,%1" [(set_attr "type" "shift,shift,load")]) ;; ldb gives us a free zero-extension. The combiner picks up on this. ;; this doesn't catch references that are into a structure. ;; note that normally the compiler uses the above insn, unless it turns ;; out that we're dealing with a volatile... (define_insn "" [(set (match_operand:HI 0 "mcore_arith_reg_operand" "=r") (zero_extend:HI (mem:QI (match_operand:SI 1 "mcore_arith_reg_operand" "r"))))] "" "ld.b %0,(%1)" [(set_attr "type" "load")]) (define_insn "" [(set (match_operand:HI 0 "mcore_arith_reg_operand" "=r") (zero_extend:HI (mem:QI (plus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (match_operand:SI 2 "const_int_operand" "")))))] "(INTVAL (operands[2]) >= 0) && (INTVAL (operands[2]) < 16)" "ld.b %0,(%1,%2)" [(set_attr "type" "load")]) ;; ------------------------------------------------------------------------- ;; Sign extension instructions ;; ------------------------------------------------------------------------- (define_expand "extendsidi2" [(set (match_operand:DI 0 "mcore_arith_reg_operand" "=r") (match_operand:SI 1 "mcore_arith_reg_operand" "r"))] "" " { int low, high; if (TARGET_LITTLE_END) low = 0, high = 4; else low = 4, high = 0; emit_insn (gen_rtx_SET (gen_rtx_SUBREG (SImode, operands[0], low), operands[1])); emit_insn (gen_rtx_SET (gen_rtx_SUBREG (SImode, operands[0], high), gen_rtx_ASHIFTRT (SImode, gen_rtx_SUBREG (SImode, operands[0], low), GEN_INT (31)))); DONE; }" ) (define_insn "extendhisi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (sign_extend:SI (match_operand:HI 1 "mcore_arith_reg_operand" "0")))] "" "sexth %0") (define_insn "extendqisi2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (sign_extend:SI (match_operand:QI 1 "mcore_arith_reg_operand" "0")))] "" "sextb %0") (define_insn "extendqihi2" [(set (match_operand:HI 0 "mcore_arith_reg_operand" "=r") (sign_extend:HI (match_operand:QI 1 "mcore_arith_reg_operand" "0")))] "" "sextb %0") ;; ------------------------------------------------------------------------- ;; Move instructions ;; ------------------------------------------------------------------------- ;; SImode (define_expand "movsi" [(set (match_operand:SI 0 "general_operand" "") (match_operand:SI 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (SImode, operands[1]); }") (define_insn "" [(set (match_operand:SI 0 "mcore_general_movdst_operand" "=r,r,a,r,a,r,m") (match_operand:SI 1 "mcore_general_movsrc_operand" "r,P,i,c,R,m,r"))] "(register_operand (operands[0], SImode) || register_operand (operands[1], SImode))" "* return mcore_output_move (insn, operands, SImode);" [(set_attr "type" "move,move,move,move,load,load,store")]) ;; ;; HImode ;; (define_expand "movhi" [(set (match_operand:HI 0 "general_operand" "") (match_operand:HI 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (HImode, operands[1]); else if (CONSTANT_P (operands[1]) && (GET_CODE (operands[1]) != CONST_INT || (! CONST_OK_FOR_I (INTVAL (operands[1])) && ! CONST_OK_FOR_M (INTVAL (operands[1])) && ! CONST_OK_FOR_N (INTVAL (operands[1])))) && ! reload_completed && ! reload_in_progress) { rtx reg = gen_reg_rtx (SImode); emit_insn (gen_movsi (reg, operands[1])); operands[1] = gen_lowpart (HImode, reg); } }") (define_insn "" [(set (match_operand:HI 0 "mcore_general_movdst_operand" "=r,r,a,r,r,m") (match_operand:HI 1 "mcore_general_movsrc_operand" "r,P,i,c,m,r"))] "(register_operand (operands[0], HImode) || register_operand (operands[1], HImode))" "* return mcore_output_move (insn, operands, HImode);" [(set_attr "type" "move,move,move,move,load,store")]) ;; ;; QImode ;; (define_expand "movqi" [(set (match_operand:QI 0 "general_operand" "") (match_operand:QI 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (QImode, operands[1]); else if (CONSTANT_P (operands[1]) && (GET_CODE (operands[1]) != CONST_INT || (! CONST_OK_FOR_I (INTVAL (operands[1])) && ! CONST_OK_FOR_M (INTVAL (operands[1])) && ! CONST_OK_FOR_N (INTVAL (operands[1])))) && ! reload_completed && ! reload_in_progress) { rtx reg = gen_reg_rtx (SImode); emit_insn (gen_movsi (reg, operands[1])); operands[1] = gen_lowpart (QImode, reg); } }") (define_insn "" [(set (match_operand:QI 0 "mcore_general_movdst_operand" "=r,r,a,r,r,m") (match_operand:QI 1 "mcore_general_movsrc_operand" "r,P,i,c,m,r"))] "(register_operand (operands[0], QImode) || register_operand (operands[1], QImode))" "* return mcore_output_move (insn, operands, QImode);" [(set_attr "type" "move,move,move,move,load,store")]) ;; DImode (define_expand "movdi" [(set (match_operand:DI 0 "general_operand" "") (match_operand:DI 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (DImode, operands[1]); else if (GET_CODE (operands[1]) == CONST_INT && ! CONST_OK_FOR_I (INTVAL (operands[1])) && ! CONST_OK_FOR_M (INTVAL (operands[1])) && ! CONST_OK_FOR_N (INTVAL (operands[1]))) { int i; for (i = 0; i < UNITS_PER_WORD * 2; i += UNITS_PER_WORD) emit_move_insn (simplify_gen_subreg (SImode, operands[0], DImode, i), simplify_gen_subreg (SImode, operands[1], DImode, i)); DONE; } }") (define_insn "movdi_i" [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,r,r,a,r,m") (match_operand:DI 1 "mcore_general_movsrc_operand" "I,M,N,r,R,m,r"))] "" "* return mcore_output_movedouble (operands, DImode);" [(set_attr "length" "4") (set_attr "type" "move,move,move,move,load,load,store")]) ;; SFmode (define_expand "movsf" [(set (match_operand:SF 0 "general_operand" "") (match_operand:SF 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (SFmode, operands[1]); }") (define_insn "movsf_i" [(set (match_operand:SF 0 "nonimmediate_operand" "=r,r,m") (match_operand:SF 1 "general_operand" "r,m,r"))] "" "@ mov %0,%1 ld.w %0,%1 st.w %1,%0" [(set_attr "type" "move,load,store")]) ;; DFmode (define_expand "movdf" [(set (match_operand:DF 0 "general_operand" "") (match_operand:DF 1 "general_operand" ""))] "" " { if (GET_CODE (operands[0]) == MEM) operands[1] = force_reg (DFmode, operands[1]); }") (define_insn "movdf_k" [(set (match_operand:DF 0 "nonimmediate_operand" "=r,r,m") (match_operand:DF 1 "general_operand" "r,m,r"))] "" "* return mcore_output_movedouble (operands, DFmode);" [(set_attr "length" "4") (set_attr "type" "move,load,store")]) ;; Load/store multiple ;; ??? This is not currently used. (define_insn "ldm" [(set (match_operand:TI 0 "mcore_arith_reg_operand" "=r") (mem:TI (match_operand:SI 1 "mcore_arith_reg_operand" "r")))] "" "ldq %U0,(%1)") ;; ??? This is not currently used. (define_insn "stm" [(set (mem:TI (match_operand:SI 0 "mcore_arith_reg_operand" "r")) (match_operand:TI 1 "mcore_arith_reg_operand" "r"))] "" "stq %U1,(%0)") (define_expand "load_multiple" [(match_par_dup 3 [(set (match_operand:SI 0 "" "") (match_operand:SI 1 "" "")) (use (match_operand:SI 2 "" ""))])] "" " { int regno, count, i; /* Support only loading a constant number of registers from memory and only if at least two registers. The last register must be r15. */ if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 2 || GET_CODE (operands[1]) != MEM || XEXP (operands[1], 0) != stack_pointer_rtx || GET_CODE (operands[0]) != REG || REGNO (operands[0]) + INTVAL (operands[2]) != 16) FAIL; count = INTVAL (operands[2]); regno = REGNO (operands[0]); operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count)); for (i = 0; i < count; i++) XVECEXP (operands[3], 0, i) = gen_rtx_SET (gen_rtx_REG (SImode, regno + i), gen_rtx_MEM (SImode, plus_constant (Pmode, stack_pointer_rtx, i * 4))); }") (define_insn "" [(match_parallel 0 "mcore_load_multiple_operation" [(set (match_operand:SI 1 "mcore_arith_reg_operand" "=r") (mem:SI (match_operand:SI 2 "register_operand" "r")))])] "GET_CODE (operands[2]) == REG && REGNO (operands[2]) == STACK_POINTER_REGNUM" "ldm %1-r15,(%2)") (define_expand "store_multiple" [(match_par_dup 3 [(set (match_operand:SI 0 "" "") (match_operand:SI 1 "" "")) (use (match_operand:SI 2 "" ""))])] "" " { int regno, count, i; /* Support only storing a constant number of registers to memory and only if at least two registers. The last register must be r15. */ if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) < 2 || GET_CODE (operands[0]) != MEM || XEXP (operands[0], 0) != stack_pointer_rtx || GET_CODE (operands[1]) != REG || REGNO (operands[1]) + INTVAL (operands[2]) != 16) FAIL; count = INTVAL (operands[2]); regno = REGNO (operands[1]); operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count)); for (i = 0; i < count; i++) XVECEXP (operands[3], 0, i) = gen_rtx_SET ( gen_rtx_MEM (SImode, plus_constant (Pmode, stack_pointer_rtx, i * 4)), gen_rtx_REG (SImode, regno + i)); }") (define_insn "" [(match_parallel 0 "mcore_store_multiple_operation" [(set (mem:SI (match_operand:SI 2 "register_operand" "r")) (match_operand:SI 1 "mcore_arith_reg_operand" "r"))])] "GET_CODE (operands[2]) == REG && REGNO (operands[2]) == STACK_POINTER_REGNUM" "stm %1-r15,(%2)") ;; ------------------------------------------------------------------------ ;; Define the real conditional branch instructions. ;; ------------------------------------------------------------------------ ;; At top-level, condition test are eq/ne, because we ;; are comparing against the condition register (which ;; has the result of the true relational test (define_insn "branch_true" [(set (pc) (if_then_else (ne (reg:CC 17) (const_int 0)) (label_ref (match_operand 0 "" "")) (pc)))] "" "jbt %l0" [(set_attr "type" "brcond")]) (define_insn "branch_false" [(set (pc) (if_then_else (eq (reg:CC 17) (const_int 0)) (label_ref (match_operand 0 "" "")) (pc)))] "" "jbf %l0" [(set_attr "type" "brcond")]) (define_insn "inverse_branch_true" [(set (pc) (if_then_else (ne (reg:CC 17) (const_int 0)) (pc) (label_ref (match_operand 0 "" ""))))] "" "jbf %l0" [(set_attr "type" "brcond")]) (define_insn "inverse_branch_false" [(set (pc) (if_then_else (eq (reg:CC 17) (const_int 0)) (pc) (label_ref (match_operand 0 "" ""))))] "" "jbt %l0" [(set_attr "type" "brcond")]) ;; Conditional branch insns (define_expand "cbranchsi4" [(set (pc) (if_then_else (match_operator 0 "ordered_comparison_operator" [(match_operand:SI 1 "mcore_compare_operand") (match_operand:SI 2 "nonmemory_operand")]) (label_ref (match_operand 3 "")) (pc)))] "" " { bool invert; invert = mcore_gen_compare (GET_CODE (operands[0]), operands[1], operands[2]); if (invert) emit_jump_insn (gen_branch_false (operands[3])); else emit_jump_insn (gen_branch_true (operands[3])); DONE; }") ;; ------------------------------------------------------------------------ ;; Jump and linkage insns ;; ------------------------------------------------------------------------ (define_insn "jump_real" [(set (pc) (label_ref (match_operand 0 "" "")))] "" "jbr %l0" [(set_attr "type" "branch")]) (define_expand "jump" [(set (pc) (label_ref (match_operand 0 "" "")))] "" " { emit_jump_insn (gen_jump_real (operand0)); DONE; } ") (define_insn "indirect_jump" [(set (pc) (match_operand:SI 0 "mcore_arith_reg_operand" "r"))] "" "jmp %0" [(set_attr "type" "jmp")]) (define_expand "call" [(parallel[(call (match_operand:SI 0 "" "") (match_operand 1 "" "")) (clobber (reg:SI 15))])] "" " { if (GET_CODE (operands[0]) == MEM && ! register_operand (XEXP (operands[0], 0), SImode) && ! mcore_symbolic_address_p (XEXP (operands[0], 0))) operands[0] = gen_rtx_MEM (GET_MODE (operands[0]), force_reg (Pmode, XEXP (operands[0], 0))); }") (define_insn "call_internal" [(call (mem:SI (match_operand:SI 0 "mcore_call_address_operand" "riR")) (match_operand 1 "" "")) (clobber (reg:SI 15))] "" "* return mcore_output_call (operands, 0);") (define_expand "call_value" [(parallel[(set (match_operand 0 "register_operand" "") (call (match_operand:SI 1 "" "") (match_operand 2 "" ""))) (clobber (reg:SI 15))])] "" " { if (GET_CODE (operands[0]) == MEM && ! register_operand (XEXP (operands[0], 0), SImode) && ! mcore_symbolic_address_p (XEXP (operands[0], 0))) operands[1] = gen_rtx_MEM (GET_MODE (operands[1]), force_reg (Pmode, XEXP (operands[1], 0))); }") (define_insn "call_value_internal" [(set (match_operand 0 "register_operand" "=r") (call (mem:SI (match_operand:SI 1 "mcore_call_address_operand" "riR")) (match_operand 2 "" ""))) (clobber (reg:SI 15))] "" "* return mcore_output_call (operands, 1);") (define_insn "call_value_struct" [(parallel [(set (match_parallel 0 "" [(expr_list (match_operand 3 "register_operand" "") (match_operand 4 "immediate_operand" "")) (expr_list (match_operand 5 "register_operand" "") (match_operand 6 "immediate_operand" ""))]) (call (match_operand:SI 1 "" "") (match_operand 2 "" ""))) (clobber (reg:SI 15))])] "" "* return mcore_output_call (operands, 1);" ) ;; ------------------------------------------------------------------------ ;; Misc insns ;; ------------------------------------------------------------------------ (define_insn "nop" [(const_int 0)] "" "or r0,r0") (define_insn "tablejump" [(set (pc) (match_operand:SI 0 "mcore_arith_reg_operand" "r")) (use (label_ref (match_operand 1 "" "")))] "" "jmp %0" [(set_attr "type" "jmp")]) (define_insn "*return" [(return)] "reload_completed && ! mcore_naked_function_p ()" "jmp r15" [(set_attr "type" "jmp")]) (define_insn "*no_return" [(return)] "reload_completed && mcore_naked_function_p ()" "" [(set_attr "length" "0")] ) (define_expand "prologue" [(const_int 0)] "" "mcore_expand_prolog (); DONE;") (define_expand "epilogue" [(return)] "" "mcore_expand_epilog ();") ;; ------------------------------------------------------------------------ ;; Scc instructions ;; ------------------------------------------------------------------------ (define_insn "mvc" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (ne:SI (reg:CC 17) (const_int 0)))] "" "mvc %0" [(set_attr "type" "move")]) (define_insn "mvcv" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (eq:SI (reg:CC 17) (const_int 0)))] "" "mvcv %0" [(set_attr "type" "move")]) ; in 0.97 use (LE 0) with (LT 1) and complement c. BRC (define_split [(parallel[ (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (ne:SI (gt:CC (match_operand:SI 1 "mcore_arith_reg_operand" "") (const_int 0)) (const_int 0))) (clobber (reg:SI 17))])] "" [(set (reg:CC 17) (lt:CC (match_dup 1) (const_int 1))) (set (match_dup 0) (eq:SI (reg:CC 17) (const_int 0)))]) (define_expand "cstoresi4" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operator:SI 1 "ordered_comparison_operator" [(match_operand:SI 2 "mcore_compare_operand" "") (match_operand:SI 3 "nonmemory_operand" "")]))] "" " { bool invert; invert = mcore_gen_compare (GET_CODE (operands[1]), operands[2], operands[3]); if (invert) emit_insn (gen_mvcv (operands[0])); else emit_insn (gen_mvc (operands[0])); DONE; }") (define_insn "incscc" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (plus:SI (ne (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_reg_operand" "0")))] "" "inct %0") (define_insn "incscc_false" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (plus:SI (eq (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_reg_operand" "0")))] "" "incf %0") (define_insn "decscc" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (minus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (ne (reg:CC 17) (const_int 0))))] "" "dect %0") (define_insn "decscc_false" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (minus:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (eq (reg:CC 17) (const_int 0))))] "" "decf %0") ;; ------------------------------------------------------------------------ ;; Conditional move patterns. ;; ------------------------------------------------------------------------ (define_expand "smaxsi3" [(set (reg:CC 17) (lt:CC (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" ""))) (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_dup 1) (match_dup 2)))] "" "") (define_split [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (smax:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "" [(set (reg:CC 17) (lt:SI (match_dup 1) (match_dup 2))) (set (match_dup 0) (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_dup 1) (match_dup 2)))] "") ; no tstgt in 0.97, so just use cmplti (btsti x,31) and reverse move ; condition BRC (define_split [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (smax:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (const_int 0)))] "" [(set (reg:CC 17) (lt:CC (match_dup 1) (const_int 0))) (set (match_dup 0) (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_dup 1) (const_int 0)))] "") (define_expand "sminsi3" [(set (reg:CC 17) (lt:CC (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" ""))) (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_dup 1) (match_dup 2)))] "" "") (define_split [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (smin:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "" [(set (reg:CC 17) (lt:SI (match_dup 1) (match_dup 2))) (set (match_dup 0) (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_dup 1) (match_dup 2)))] "") ;(define_split ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") ; (smin:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") ; (const_int 0)))] ; "" ; [(set (reg:CC 17) ; (gt:CC (match_dup 1) (const_int 0))) ; (set (match_dup 0) ; (if_then_else:SI (eq (reg:CC 17) (const_int 0)) ; (match_dup 1) (const_int 0)))] ; "") ; changed these unsigned patterns to use geu instead of ltu. it appears ; that the c-torture & ssrl test suites didn't catch these! only showed ; up in friedman's clib work. BRC 7/7/95 (define_expand "umaxsi3" [(set (reg:CC 17) (geu:CC (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" ""))) (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_dup 2) (match_dup 1)))] "" "") (define_split [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (umax:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "" [(set (reg:CC 17) (geu:SI (match_dup 1) (match_dup 2))) (set (match_dup 0) (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_dup 2) (match_dup 1)))] "") (define_expand "uminsi3" [(set (reg:CC 17) (geu:CC (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" ""))) (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_dup 2) (match_dup 1)))] "" "") (define_split [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (umin:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "mcore_arith_reg_operand" "")))] "" [(set (reg:CC 17) (geu:SI (match_dup 1) (match_dup 2))) (set (match_dup 0) (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_dup 2) (match_dup 1)))] "") ;; ------------------------------------------------------------------------ ;; conditional move patterns really start here ;; ------------------------------------------------------------------------ ;; the "movtK" patterns are experimental. they are intended to account for ;; gcc's mucking on code such as: ;; ;; free_ent = ((block_compress) ? 257 : 256 ); ;; ;; these patterns help to get a tstne/bgeni/inct (or equivalent) sequence ;; when both arms have constants that are +/- 1 of each other. ;; ;; note in the following patterns that the "movtK" ones should be the first ;; one defined in each sequence. this is because the general pattern also ;; matches, so use ordering to determine priority (it's easier this way than ;; adding conditions to the general patterns). BRC ;; ;; the U and Q constraints are necessary to ensure that reload does the ;; 'right thing'. U constrains the operand to 0 and Q to 1 for use in the ;; clrt & clrf and clrt/inct & clrf/incf patterns. BRC 6/26 ;; ;; ??? there appears to be some problems with these movtK patterns for ops ;; other than eq & ne. need to fix. 6/30 BRC ;; ------------------------------------------------------------------------ ;; ne ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_1" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] " GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ( (INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov (operands, 1, NULL);" [(set_attr "length" "4")]) (define_insn "movt0" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movt %0,%1 movf %0,%2 clrt %0 clrf %0") ;; ------------------------------------------------------------------------ ;; eq ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] " GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ( (INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov (operands, 0, NULL);" [(set_attr "length" "4")]) (define_insn "movf0" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (reg:CC 17) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movf %0,%1 movt %0,%2 clrf %0 clrt %0") ; turns lsli rx,imm/btsti rx,31 into btsti rx,imm. not done by a peephole ; because the instructions are not adjacent (peepholes are related by posn - ; not by dataflow). BRC (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 1) (match_operand:SI 2 "mcore_literal_K_operand" "K,K,K,K")) (const_int 0)) (match_operand:SI 3 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 4 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ btsti %1,%2\;movf %0,%3 btsti %1,%2\;movt %0,%4 btsti %1,%2\;clrf %0 btsti %1,%2\;clrt %0" [(set_attr "length" "4")]) ; turns sextb rx/btsti rx,31 into btsti rx,7. must be QImode to be safe. BRC (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (lshiftrt:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 7)) (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "GET_CODE (operands[1]) == SUBREG && GET_MODE (SUBREG_REG (operands[1])) == QImode" "@ btsti %1,7\;movf %0,%2 btsti %1,7\;movt %0,%3 btsti %1,7\;clrf %0 btsti %1,7\;clrt %0" [(set_attr "length" "4")]) ;; ------------------------------------------------------------------------ ;; ne ;; ------------------------------------------------------------------------ ;; Combine creates this from an andn instruction in a scc sequence. ;; We must recognize it to get conditional moves generated. ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (ne (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 0)) (match_operand:SI 2 "mcore_arith_O_operand" "O") (match_operand:SI 3 "mcore_arith_O_operand" "O")))] " GET_CODE (operands[2]) == CONST_INT && GET_CODE (operands[3]) == CONST_INT && ( (INTVAL (operands[2]) - INTVAL (operands[3]) == 1) || (INTVAL (operands[3]) - INTVAL (operands[2]) == 1))" "* { rtx out_operands[4]; out_operands[0] = operands[0]; out_operands[1] = operands[2]; out_operands[2] = operands[3]; out_operands[3] = operands[1]; return mcore_output_cmov (out_operands, 1, \"cmpnei %3,0\"); }" [(set_attr "length" "6")]) (define_insn "movt2" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ cmpnei %1,0\;movt %0,%2 cmpnei %1,0\;movf %0,%3 cmpnei %1,0\;clrt %0 cmpnei %1,0\;clrf %0" [(set_attr "length" "4")]) ; turns lsli rx,imm/btsti rx,31 into btsti rx,imm. not done by a peephole ; because the instructions are not adjacent (peepholes are related by posn - ; not by dataflow). BRC (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 1) (match_operand:SI 2 "mcore_literal_K_operand" "K,K,K,K")) (const_int 0)) (match_operand:SI 3 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 4 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ btsti %1,%2\;movt %0,%3 btsti %1,%2\;movf %0,%4 btsti %1,%2\;clrt %0 btsti %1,%2\;clrf %0" [(set_attr "length" "4")]) ; turns sextb rx/btsti rx,31 into btsti rx,7. must be QImode to be safe. BRC (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (lshiftrt:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 7)) (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "GET_CODE (operands[1]) == SUBREG && GET_MODE (SUBREG_REG (operands[1])) == QImode" "@ btsti %1,7\;movt %0,%2 btsti %1,7\;movf %0,%3 btsti %1,7\;clrt %0 btsti %1,7\;clrf %0" [(set_attr "length" "4")]) ;; ------------------------------------------------------------------------ ;; eq/eq ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_4" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (eq (eq:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ((INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov(operands, 1, NULL);" [(set_attr "length" "4")]) (define_insn "movt3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (eq:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movt %0,%1 movf %0,%2 clrt %0 clrf %0") ;; ------------------------------------------------------------------------ ;; eq/ne ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_5" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (eq (ne:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ((INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov (operands, 0, NULL);" [(set_attr "length" "4")]) (define_insn "movf1" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (ne:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movf %0,%1 movt %0,%2 clrf %0 clrt %0") ;; ------------------------------------------------------------------------ ;; eq ;; ------------------------------------------------------------------------ ;; Combine creates this from an andn instruction in a scc sequence. ;; We must recognize it to get conditional moves generated. ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_6" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (eq (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 0)) (match_operand:SI 2 "mcore_arith_O_operand" "O") (match_operand:SI 3 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ((INTVAL (operands[2]) - INTVAL (operands[3]) == 1) || (INTVAL (operands[3]) - INTVAL (operands[2]) == 1))" "* { rtx out_operands[4]; out_operands[0] = operands[0]; out_operands[1] = operands[2]; out_operands[2] = operands[3]; out_operands[3] = operands[1]; return mcore_output_cmov (out_operands, 0, \"cmpnei %3,0\"); }" [(set_attr "length" "6")]) (define_insn "movf3" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (eq (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ cmpnei %1,0\;movf %0,%2 cmpnei %1,0\;movt %0,%3 cmpnei %1,0\;clrf %0 cmpnei %1,0\;clrt %0" [(set_attr "length" "4")]) ;; ------------------------------------------------------------------------ ;; ne/eq ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_7" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (ne (eq:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ((INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov (operands, 0, NULL);" [(set_attr "length" "4")]) (define_insn "movf4" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (eq:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movf %0,%1 movt %0,%2 clrf %0 clrt %0") ;; ------------------------------------------------------------------------ ;; ne/ne ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_8" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (ne (ne:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_O_operand" "O") (match_operand:SI 2 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[1]) == CONST_INT && GET_CODE (operands[2]) == CONST_INT && ((INTVAL (operands[1]) - INTVAL (operands[2]) == 1) || (INTVAL (operands[2]) - INTVAL (operands[1]) == 1))" "* return mcore_output_cmov (operands, 1, NULL);" [(set_attr "length" "4")]) (define_insn "movt4" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ne (ne:SI (reg:CC 17) (const_int 0)) (const_int 0)) (match_operand:SI 1 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 2 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ movt %0,%1 movf %0,%2 clrt %0 clrf %0") ;; Also need patterns to recognize lt/ge, since otherwise the compiler will ;; try to output not/asri/tstne/movf. ;; ------------------------------------------------------------------------ ;; lt ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_9" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (lt (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 0)) (match_operand:SI 2 "mcore_arith_O_operand" "O") (match_operand:SI 3 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[2]) == CONST_INT && GET_CODE (operands[3]) == CONST_INT && ((INTVAL (operands[2]) - INTVAL (operands[3]) == 1) || (INTVAL (operands[3]) - INTVAL (operands[2]) == 1))" "* { rtx out_operands[4]; out_operands[0] = operands[0]; out_operands[1] = operands[2]; out_operands[2] = operands[3]; out_operands[3] = operands[1]; return mcore_output_cmov (out_operands, 1, \"btsti %3,31\"); }" [(set_attr "length" "6")]) (define_insn "movt5" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (lt (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ btsti %1,31\;movt %0,%2 btsti %1,31\;movf %0,%3 btsti %1,31\;clrt %0 btsti %1,31\;clrf %0" [(set_attr "length" "4")]) ;; ------------------------------------------------------------------------ ;; ge ;; ------------------------------------------------------------------------ ; experimental conditional move with two constants +/- 1 BRC (define_insn "movtK_10" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (if_then_else:SI (ge (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 0)) (match_operand:SI 2 "mcore_arith_O_operand" "O") (match_operand:SI 3 "mcore_arith_O_operand" "O")))] "GET_CODE (operands[2]) == CONST_INT && GET_CODE (operands[3]) == CONST_INT && ((INTVAL (operands[2]) - INTVAL (operands[3]) == 1) || (INTVAL (operands[3]) - INTVAL (operands[2]) == 1))" "* { rtx out_operands[4]; out_operands[0] = operands[0]; out_operands[1] = operands[2]; out_operands[2] = operands[3]; out_operands[3] = operands[1]; return mcore_output_cmov (out_operands, 0, \"btsti %3,31\"); }" [(set_attr "length" "6")]) (define_insn "movf5" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,r,r,r") (if_then_else:SI (ge (match_operand:SI 1 "mcore_arith_reg_operand" "r,r,r,r") (const_int 0)) (match_operand:SI 2 "mcore_arith_imm_operand" "r,0,U,0") (match_operand:SI 3 "mcore_arith_imm_operand" "0,r,0,U")))] "" "@ btsti %1,31\;movf %0,%2 btsti %1,31\;movt %0,%3 btsti %1,31\;clrf %0 btsti %1,31\;clrt %0" [(set_attr "length" "4")]) ;; ------------------------------------------------------------------------ ;; Bitfield extract (xtrbN) ;; ------------------------------------------------------------------------ ; sometimes we're better off using QI/HI mode and letting the machine indep. ; part expand insv and extv. ; ; e.g., sequences like:a [an insertion] ; ; ldw r8,(r6) ; movi r7,0x00ffffff ; and r8,r7 r7 dead ; stw r8,(r6) r8 dead ; ; become: ; ; movi r8,0 ; stb r8,(r6) r8 dead ; ; it looks like always using SI mode is a win except in this type of code ; (when adjacent bit fields collapse on a byte or halfword boundary). when ; expanding with SI mode, non-adjacent bit field masks fold, but with QI/HI ; mode, they do not. one thought is to add some peepholes to cover cases ; like the above, but this is not a general solution. ; ; -mword-bitfields expands/inserts using SI mode. otherwise, do it with ; the smallest mode possible (using the machine indep. expansions). BRC ;(define_expand "extv" ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") ; (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") ; (match_operand:SI 2 "const_int_operand" "") ; (match_operand:SI 3 "const_int_operand" ""))) ; (clobber (reg:CC 17))] ; "" ; " ;{ ; if (INTVAL (operands[1]) != 8 || INTVAL (operands[2]) % 8 != 0) ; { ; if (TARGET_W_FIELD) ; { ; rtx lshft = GEN_INT (32 - (INTVAL (operands[2]) + INTVAL (operands[3]))); ; rtx rshft = GEN_INT (32 - INTVAL (operands[2])); ; ; emit_insn (gen_rtx_SET (operands[0], operands[1])); ; emit_insn (gen_rtx_SET (operands[0], ; gen_rtx_ASHIFT (SImode, operands[0], lshft))); ; emit_insn (gen_rtx_SET (operands[0], ; gen_rtx_ASHIFTRT (SImode, operands[0], rshft))); ; DONE; ; } ; else ; FAIL; ; } ;}") (define_expand "extv" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "const_int_operand" "") (match_operand:SI 3 "const_int_operand" ""))) (clobber (reg:CC 17))] "" " { if (INTVAL (operands[2]) == 8 && INTVAL (operands[3]) % 8 == 0) { /* 8-bit field, aligned properly, use the xtrb[0123]+sext sequence. */ /* not DONE, not FAIL, but let the RTL get generated.... */ } else if (TARGET_W_FIELD) { /* Arbitrary placement; note that the tree->rtl generator will make something close to this if we return FAIL */ rtx lshft = GEN_INT (32 - (INTVAL (operands[2]) + INTVAL (operands[3]))); rtx rshft = GEN_INT (32 - INTVAL (operands[2])); rtx tmp1 = gen_reg_rtx (SImode); rtx tmp2 = gen_reg_rtx (SImode); emit_insn (gen_rtx_SET (tmp1, operands[1])); emit_insn (gen_rtx_SET (tmp2, gen_rtx_ASHIFT (SImode, tmp1, lshft))); emit_insn (gen_rtx_SET (operands[0], gen_rtx_ASHIFTRT (SImode, tmp2, rshft))); DONE; } else { /* Let the caller choose an alternate sequence. */ FAIL; } }") (define_expand "extzv" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (match_operand:SI 2 "const_int_operand" "") (match_operand:SI 3 "const_int_operand" ""))) (clobber (reg:CC 17))] "" " { if (INTVAL (operands[2]) == 8 && INTVAL (operands[3]) % 8 == 0) { /* 8-bit field, aligned properly, use the xtrb[0123] sequence. */ /* Let the template generate some RTL.... */ } else if (CONST_OK_FOR_K ((1 << INTVAL (operands[2])) - 1)) { /* A narrow bit-field (<=5 bits) means we can do a shift to put it in place and then use an andi to extract it. This is as good as a shiftleft/shiftright. */ rtx shifted; rtx mask = GEN_INT ((1 << INTVAL (operands[2])) - 1); if (INTVAL (operands[3]) == 0) { shifted = operands[1]; } else { rtx rshft = GEN_INT (INTVAL (operands[3])); shifted = gen_reg_rtx (SImode); emit_insn (gen_rtx_SET (shifted, gen_rtx_LSHIFTRT (SImode, operands[1], rshft))); } emit_insn (gen_rtx_SET (operands[0], gen_rtx_AND (SImode, shifted, mask))); DONE; } else if (TARGET_W_FIELD) { /* Arbitrary pattern; play shift/shift games to get it. * this is pretty much what the caller will do if we say FAIL */ rtx lshft = GEN_INT (32 - (INTVAL (operands[2]) + INTVAL (operands[3]))); rtx rshft = GEN_INT (32 - INTVAL (operands[2])); rtx tmp1 = gen_reg_rtx (SImode); rtx tmp2 = gen_reg_rtx (SImode); emit_insn (gen_rtx_SET (tmp1, operands[1])); emit_insn (gen_rtx_SET (tmp2, gen_rtx_ASHIFT (SImode, tmp1, lshft))); emit_insn (gen_rtx_SET (operands[0], gen_rtx_LSHIFTRT (SImode, tmp2, rshft))); DONE; } else { /* Make the compiler figure out some alternative mechanism. */ FAIL; } /* Emit the RTL pattern; something will match it later. */ }") (define_expand "insv" [(set (zero_extract:SI (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "const_int_operand" "") (match_operand:SI 2 "const_int_operand" "")) (match_operand:SI 3 "general_operand" "")) (clobber (reg:CC 17))] "" " { if (mcore_expand_insv (operands)) { DONE; } else { FAIL; } }") ;; ;; the xtrb[0123] instructions handily get at 8-bit fields on nice boundaries. ;; but then, they do force you through r1. ;; ;; the combiner will build such patterns for us, so we'll make them available ;; for its use. ;; ;; Note that we have both SIGNED and UNSIGNED versions of these... ;; ;; ;; These no longer worry about the clobbering of CC bit; not sure this is ;; good... ;; ;; the SIGNED versions of these ;; (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,b") (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,r") (const_int 8) (const_int 24)))] "" "@ asri %0,24 xtrb0 %0,%1\;sextb %0" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=b") (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 8) (const_int 16)))] "" "xtrb1 %0,%1\;sextb %0" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=b") (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 8) (const_int 8)))] "" "xtrb2 %0,%1\;sextb %0" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (sign_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0") (const_int 8) (const_int 0)))] "" "sextb %0" [(set_attr "type" "shift")]) ;; the UNSIGNED uses of xtrb[0123] ;; (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,b") (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,r") (const_int 8) (const_int 24)))] "" "@ lsri %0,24 xtrb0 %0,%1" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=b") (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 8) (const_int 16)))] "" "xtrb1 %0,%1" [(set_attr "type" "shift")]) (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=b") (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "r") (const_int 8) (const_int 8)))] "" "xtrb2 %0,%1" [(set_attr "type" "shift")]) ;; This can be peepholed if it follows a ldb ... (define_insn "" [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r,b") (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "0,r") (const_int 8) (const_int 0)))] "" "@ zextb %0 xtrb3 %0,%1\;zextb %0" [(set_attr "type" "shift")]) ;; ------------------------------------------------------------------------ ;; Block move - adapted from m88k.md ;; ------------------------------------------------------------------------ (define_expand "cpymemsi" [(parallel [(set (mem:BLK (match_operand:BLK 0 "" "")) (mem:BLK (match_operand:BLK 1 "" ""))) (use (match_operand:SI 2 "general_operand" "")) (use (match_operand:SI 3 "immediate_operand" ""))])] "" " { if (mcore_expand_block_move (operands)) DONE; else FAIL; }") ;; ;;; ??? These patterns are meant to be generated from expand_block_move, ;; ;;; but they currently are not. ;; ;; (define_insn "" ;; [(set (match_operand:QI 0 "mcore_arith_reg_operand" "=r") ;; (match_operand:BLK 1 "mcore_general_movsrc_operand" "m"))] ;; "" ;; "ld.b %0,%1" ;; [(set_attr "type" "load")]) ;; ;; (define_insn "" ;; [(set (match_operand:HI 0 "mcore_arith_reg_operand" "=r") ;; (match_operand:BLK 1 "mcore_general_movsrc_operand" "m"))] ;; "" ;; "ld.h %0,%1" ;; [(set_attr "type" "load")]) ;; ;; (define_insn "" ;; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") ;; (match_operand:BLK 1 "mcore_general_movsrc_operand" "m"))] ;; "" ;; "ld.w %0,%1" ;; [(set_attr "type" "load")]) ;; ;; (define_insn "" ;; [(set (match_operand:BLK 0 "mcore_general_movdst_operand" "=m") ;; (match_operand:QI 1 "mcore_arith_reg_operand" "r"))] ;; "" ;; "st.b %1,%0" ;; [(set_attr "type" "store")]) ;; ;; (define_insn "" ;; [(set (match_operand:BLK 0 "mcore_general_movdst_operand" "=m") ;; (match_operand:HI 1 "mcore_arith_reg_operand" "r"))] ;; "" ;; "st.h %1,%0" ;; [(set_attr "type" "store")]) ;; ;; (define_insn "" ;; [(set (match_operand:BLK 0 "mcore_general_movdst_operand" "=m") ;; (match_operand:SI 1 "mcore_arith_reg_operand" "r"))] ;; "" ;; "st.w %1,%0" ;; [(set_attr "type" "store")]) ;; ------------------------------------------------------------------------ ;; Misc Optimizing quirks ;; ------------------------------------------------------------------------ ;; pair to catch constructs like: (int *)((p+=4)-4) which happen ;; in stdarg/varargs traversal. This changes a 3 insn sequence to a 2 ;; insn sequence. -- RBE 11/30/95 (define_insn "" [(parallel[ (set (match_operand:SI 0 "mcore_arith_reg_operand" "=r") (match_operand:SI 1 "mcore_arith_reg_operand" "+r")) (set (match_dup 1) (plus:SI (match_dup 1) (match_operand 2 "mcore_arith_any_imm_operand" "")))])] "GET_CODE(operands[2]) == CONST_INT" "#" [(set_attr "length" "4")]) (define_split [(parallel[ (set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "mcore_arith_reg_operand" "")) (set (match_dup 1) (plus:SI (match_dup 1) (match_operand 2 "mcore_arith_any_imm_operand" "")))])] "GET_CODE(operands[2]) == CONST_INT && operands[0] != operands[1]" [(set (match_dup 0) (match_dup 1)) (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]) ;;; Peepholes ; note: in the following patterns, use mcore_is_dead() to ensure that the ; reg we may be trashing really is dead. reload doesn't always mark ; deaths, so mcore_is_dead() (see mcore.c) scans forward to find its death. BRC ;;; A peephole to convert the 3 instruction sequence generated by reload ;;; to load a FP-offset address into a 2 instruction sequence. ;;; ??? This probably never matches anymore. (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "const_int_operand" "J")) (set (match_dup 0) (neg:SI (match_dup 0))) (set (match_dup 0) (plus:SI (match_dup 0) (match_operand:SI 2 "mcore_arith_reg_operand" "r")))] "CONST_OK_FOR_J (INTVAL (operands[1]))" "error\;mov %0,%2\;subi %0,%1") ;; Moves of inlinable constants are done late, so when a 'not' is generated ;; it is never combined with the following 'and' to generate an 'andn' b/c ;; the combiner never sees it. use a peephole to pick up this case (happens ;; mostly with bitfields) BRC (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "r") (match_operand:SI 1 "const_int_operand" "i")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "r") (and:SI (match_dup 2) (match_dup 0)))] "mcore_const_trick_uses_not (INTVAL (operands[1])) && operands[0] != operands[2] && mcore_is_dead (insn, operands[0])" "* return mcore_output_andn (insn, operands);") ; when setting or clearing just two bits, it's cheapest to use two bseti's ; or bclri's. only happens when relaxing immediates. BRC (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "const_int_operand" "")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "") (ior:SI (match_dup 2) (match_dup 0)))] "TARGET_HARDLIT && mcore_num_ones (INTVAL (operands[1])) == 2 && mcore_is_dead (insn, operands[0])" "* return mcore_output_bseti (operands[2], INTVAL (operands[1]));") (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "const_int_operand" "")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "") (and:SI (match_dup 2) (match_dup 0)))] "TARGET_HARDLIT && mcore_num_zeros (INTVAL (operands[1])) == 2 && mcore_is_dead (insn, operands[0])" "* return mcore_output_bclri (operands[2], INTVAL (operands[1]));") ; change an and with a mask that has a single cleared bit into a bclri. this ; handles QI and HI mode values using the knowledge that the most significant ; bits don't matter. (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "const_int_operand" "")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "") (and:SI (match_operand:SI 3 "mcore_arith_reg_operand" "") (match_dup 0)))] "GET_CODE (operands[3]) == SUBREG && GET_MODE (SUBREG_REG (operands[3])) == QImode && mcore_num_zeros (INTVAL (operands[1]) | 0xffffff00) == 1 && mcore_is_dead (insn, operands[0])" "* if (! mcore_is_same_reg (operands[2], operands[3])) output_asm_insn (\"mov\\t%2,%3\", operands); return mcore_output_bclri (operands[2], INTVAL (operands[1]) | 0xffffff00);") /* Do not fold these together -- mode is lost at final output phase. */ (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "const_int_operand" "")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "") (and:SI (match_operand:SI 3 "mcore_arith_reg_operand" "") (match_dup 0)))] "GET_CODE (operands[3]) == SUBREG && GET_MODE (SUBREG_REG (operands[3])) == HImode && mcore_num_zeros (INTVAL (operands[1]) | 0xffff0000) == 1 && operands[2] == operands[3] && mcore_is_dead (insn, operands[0])" "* if (! mcore_is_same_reg (operands[2], operands[3])) output_asm_insn (\"mov\\t%2,%3\", operands); return mcore_output_bclri (operands[2], INTVAL (operands[1]) | 0xffff0000);") ; This peephole helps when using -mwide-bitfields to widen fields so they ; collapse. This, however, has the effect that a narrower mode is not used ; when desirable. ; ; e.g., sequences like: ; ; ldw r8,(r6) ; movi r7,0x00ffffff ; and r8,r7 r7 dead ; stw r8,(r6) r8 dead ; ; get peepholed to become: ; ; movi r8,0 ; stb r8,(r6) r8 dead ; ; Do only easy addresses that have no offset. This peephole is also applied ; to halfwords. We need to check that the load is non-volatile before we get ; rid of it. (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "memory_operand" "")) (set (match_operand:SI 2 "mcore_arith_reg_operand" "") (match_operand:SI 3 "const_int_operand" "")) (set (match_dup 0) (and:SI (match_dup 0) (match_dup 2))) (set (match_operand:SI 4 "memory_operand" "") (match_dup 0))] "mcore_is_dead (insn, operands[0]) && ! MEM_VOLATILE_P (operands[1]) && mcore_is_dead (insn, operands[2]) && (mcore_byte_offset (INTVAL (operands[3])) > -1 || mcore_halfword_offset (INTVAL (operands[3])) > -1) && ! MEM_VOLATILE_P (operands[4]) && GET_CODE (XEXP (operands[4], 0)) == REG" "* { int ofs; machine_mode mode; rtx base_reg = XEXP (operands[4], 0); if ((ofs = mcore_byte_offset (INTVAL (operands[3]))) > -1) mode = QImode; else if ((ofs = mcore_halfword_offset (INTVAL (operands[3]))) > -1) mode = HImode; else gcc_unreachable (); if (ofs > 0) operands[4] = gen_rtx_MEM (mode, gen_rtx_PLUS (SImode, base_reg, GEN_INT(ofs))); else operands[4] = gen_rtx_MEM (mode, base_reg); if (mode == QImode) return \"movi %0,0\\n\\tst.b %0,%4\"; return \"movi %0,0\\n\\tst.h %0,%4\"; }") ; from sop11. get btsti's for (LT A 0) where A is a QI or HI value (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "r") (sign_extend:SI (match_operand:QI 1 "mcore_arith_reg_operand" "0"))) (set (reg:CC 17) (lt:CC (match_dup 0) (const_int 0)))] "mcore_is_dead (insn, operands[0])" "btsti %0,7") (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "r") (sign_extend:SI (match_operand:HI 1 "mcore_arith_reg_operand" "0"))) (set (reg:CC 17) (lt:CC (match_dup 0) (const_int 0)))] "mcore_is_dead (insn, operands[0])" "btsti %0,15") ; Pick up a tst. This combination happens because the immediate is not ; allowed to fold into one of the operands of the tst. Does not happen ; when relaxing immediates. BRC (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (match_operand:SI 1 "mcore_arith_reg_operand" "")) (set (match_dup 0) (and:SI (match_dup 0) (match_operand:SI 2 "mcore_literal_K_operand" ""))) (set (reg:CC 17) (ne:CC (match_dup 0) (const_int 0)))] "mcore_is_dead (insn, operands[0])" "movi %0,%2\;tst %1,%0") (define_peephole [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") (if_then_else:SI (ne (zero_extract:SI (match_operand:SI 1 "mcore_arith_reg_operand" "") (const_int 1) (match_operand:SI 2 "mcore_literal_K_operand" "")) (const_int 0)) (match_operand:SI 3 "mcore_arith_imm_operand" "") (match_operand:SI 4 "mcore_arith_imm_operand" ""))) (set (reg:CC 17) (ne:CC (match_dup 0) (const_int 0)))] "" "* { unsigned int op0 = REGNO (operands[0]); if (GET_CODE (operands[3]) == REG) { if (REGNO (operands[3]) == op0 && GET_CODE (operands[4]) == CONST_INT && INTVAL (operands[4]) == 0) return \"btsti %1,%2\\n\\tclrf %0\"; else if (GET_CODE (operands[4]) == REG) { if (REGNO (operands[4]) == op0) return \"btsti %1,%2\\n\\tmovf %0,%3\"; else if (REGNO (operands[3]) == op0) return \"btsti %1,%2\\n\\tmovt %0,%4\"; } gcc_unreachable (); } else if (GET_CODE (operands[3]) == CONST_INT && INTVAL (operands[3]) == 0 && GET_CODE (operands[4]) == REG) return \"btsti %1,%2\\n\\tclrt %0\"; gcc_unreachable (); }") ; experimental - do the constant folding ourselves. note that this isn't ; re-applied like we'd really want. i.e., four ands collapse into two ; instead of one. this is because peepholes are applied as a sliding ; window. the peephole does not generate new rtl's, but instead slides ; across the rtl's generating machine instructions. it would be nice ; if the peephole optimizer is changed to re-apply patterns and to gen ; new rtl's. this is more flexible. the pattern below helps when we're ; not using relaxed immediates. BRC ;(define_peephole ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "") ; (match_operand:SI 1 "const_int_operand" "")) ; (set (match_operand:SI 2 "mcore_arith_reg_operand" "") ; (and:SI (match_dup 2) (match_dup 0))) ; (set (match_dup 0) ; (match_operand:SI 3 "const_int_operand" "")) ; (set (match_dup 2) ; (and:SI (match_dup 2) (match_dup 0)))] ; "!TARGET_RELAX_IMM && mcore_is_dead (insn, operands[0]) && ; mcore_const_ok_for_inline (INTVAL (operands[1]) & INTVAL (operands[3]))" ; "* ;{ ; rtx out_operands[2]; ; out_operands[0] = operands[0]; ; out_operands[1] = GEN_INT (INTVAL (operands[1]) & INTVAL (operands[3])); ; ; output_inline_const (SImode, out_operands); ; ; output_asm_insn (\"and %2,%0\", operands); ; ; return \"\"; ;}") ; BRC: for inlining get rid of extra test - experimental ;(define_peephole ; [(set (match_operand:SI 0 "mcore_arith_reg_operand" "r") ; (ne:SI (reg:CC 17) (const_int 0))) ; (set (reg:CC 17) (ne:CC (match_dup 0) (const_int 0))) ; (set (pc) ; (if_then_else (eq (reg:CC 17) (const_int 0)) ; (label_ref (match_operand 1 "" "")) ; (pc)))] ; "" ; "* ;{ ; if (get_attr_length (insn) == 10) ; { ; output_asm_insn (\"bt 2f\\n\\tjmpi [1f]\", operands); ; output_asm_insn (\".align 2\\n1:\", operands); ; output_asm_insn (\".long %1\\n2:\", operands); ; return \"\"; ; } ; return \"bf %l1\"; ;}") ;;; Special patterns for dealing with the constant pool. ;;; 4 byte integer in line. (define_insn "consttable_4" [(unspec_volatile [(match_operand:SI 0 "general_operand" "=g")] 0)] "" "* { assemble_integer (operands[0], 4, BITS_PER_WORD, 1); return \"\"; }" [(set_attr "length" "4")]) ;;; align to a four byte boundary. (define_insn "align_4" [(unspec_volatile [(const_int 0)] 1)] "" ".align 2") ;;; Handle extra constant pool entries created during final pass. (define_insn "consttable_end" [(unspec_volatile [(const_int 0)] 2)] "" "* return mcore_output_jump_label_table ();") ;; ;; Stack allocation -- in particular, for alloca(). ;; this is *not* what we use for entry into functions. ;; ;; This is how we allocate stack space. If we are allocating a ;; constant amount of space and we know it is less than 4096 ;; bytes, we need do nothing. ;; ;; If it is more than 4096 bytes, we need to probe the stack ;; periodically. ;; ;; operands[1], the distance is a POSITIVE number indicating that we ;; are allocating stack space ;; (define_expand "allocate_stack" [(set (reg:SI 0) (plus:SI (reg:SI 0) (match_operand:SI 1 "general_operand" ""))) (set (match_operand:SI 0 "register_operand" "=r") (match_dup 2))] "" " { /* If he wants no probing, just do it for him. */ if (mcore_stack_increment == 0) { emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,operands[1])); ;; emit_move_insn (operands[0], virtual_stack_dynamic_rtx); DONE; } /* For small constant growth, we unroll the code. */ if (GET_CODE (operands[1]) == CONST_INT && INTVAL (operands[1]) < 8 * STACK_UNITS_MAXSTEP) { HOST_WIDE_INT left = INTVAL(operands[1]); /* If it's a long way, get close enough for a last shot. */ if (left >= STACK_UNITS_MAXSTEP) { rtx tmp = gen_reg_rtx (Pmode); emit_insn (gen_movsi (tmp, GEN_INT (STACK_UNITS_MAXSTEP))); do { rtx memref = gen_rtx_MEM (SImode, stack_pointer_rtx); MEM_VOLATILE_P (memref) = 1; emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp)); emit_insn (gen_movsi (memref, stack_pointer_rtx)); left -= STACK_UNITS_MAXSTEP; } while (left > STACK_UNITS_MAXSTEP); } /* Perform the final adjustment. */ emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, GEN_INT (-left))); ;; emit_move_insn (operands[0], virtual_stack_dynamic_rtx); DONE; } else { rtx_code_label *out_label = 0; rtx_code_label *loop_label = gen_label_rtx (); rtx step = gen_reg_rtx (Pmode); rtx tmp = gen_reg_rtx (Pmode); rtx test, memref; #if 1 emit_insn (gen_movsi (tmp, operands[1])); emit_insn (gen_movsi (step, GEN_INT (STACK_UNITS_MAXSTEP))); if (GET_CODE (operands[1]) != CONST_INT) { out_label = gen_label_rtx (); test = gen_rtx_GEU (VOIDmode, step, tmp); /* quick out */ emit_jump_insn (gen_cbranchsi4 (test, step, tmp, out_label)); } /* Run a loop that steps it incrementally. */ emit_label (loop_label); /* Extend a step, probe, and adjust remaining count. */ emit_insn(gen_subsi3(stack_pointer_rtx, stack_pointer_rtx, step)); memref = gen_rtx_MEM (SImode, stack_pointer_rtx); MEM_VOLATILE_P (memref) = 1; emit_insn(gen_movsi(memref, stack_pointer_rtx)); emit_insn(gen_subsi3(tmp, tmp, step)); /* Loop condition -- going back up. */ test = gen_rtx_LTU (VOIDmode, step, tmp); emit_jump_insn (gen_cbranchsi4 (test, step, tmp, loop_label)); if (out_label) emit_label (out_label); /* Bump the residual. */ emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp)); ;; emit_move_insn (operands[0], virtual_stack_dynamic_rtx); DONE; #else /* simple one-shot -- ensure register and do a subtract. * This does NOT comply with the ABI. */ emit_insn (gen_movsi (tmp, operands[1])); emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp)); ;; emit_move_insn (operands[0], virtual_stack_dynamic_rtx); DONE; #endif } }")