Subversion Repositories open8_urisc

; Hitachi SHmedia instruction set description.  -*- Scheme -*-

;

; Copyright 2000, 2001, 2007, 2009 Free Software Foundation, Inc.

;

; Contributed by Red Hat Inc; developed under contract from Hitachi

; Semiconductor (America) Inc.

;

; This file is part of the GNU Binutils.

;

; This program 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 of the License, or

; (at your option) any later version.

;

; This program 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 this program; if not, write to the Free Software

; Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

; MA 02110-1301, USA.

; dshmf -- define-normal-sh-media-field

(define-pmacro (dshmf xname xcomment ignored xstart xlength)

  (dnf xname xcomment ((ISA media)) xstart xlength))

; dshmop -- define-normal-sh-media-operand

(define-pmacro (dshmop xname xcomment ignored xhardware xfield)

  (dnop xname xcomment ((ISA media)) xhardware xfield))

; dnshmi -- define-normal-sh-media-insn

(define-pmacro (dshmi xname xcomment xattrs xsyntax xformat xsemantics)

  (define-insn

    (name xname)

    (comment xcomment)

    (.splice attrs (.unsplice xattrs) (ISA media))

    (syntax xsyntax)

    (format xformat)

    (semantics xsemantics)))

; Saturation functions.

; Force a value `i' into words `n' bits wide.

; See Hitachi SH-5 CPU core, volume 2, p. 25 for details.

; saturate -- signed saturatation function

(define-pmacro (saturate mode n i)

  (if mode (lt i (neg mode (sll mode 1 (sub n 1))))

      (neg (sll mode 1 (sub n 1)))

      (if mode (lt i (sll mode 1 (sub n 1)))

          i

          (sub mode (sll mode 1 (sub n 1)) 1))))

; usaturate -- unsigned saturation function

(define-pmacro (usaturate mode n i)

  (if mode (lt i (const mode 0))

      (const mode 0)

      (if mode (lt i (sll mode 1 n))

          i

          (sub mode (sll mode 1 n) 1))))

; Ifields.

(dshmf f-op          "Opcode"                       ()  31  6)

(dshmf f-ext         "Extension opcode"             ()  19  4)

(dshmf f-rsvd        "Reserved"             (RESERVED)   3  4)

(dshmf f-left        "Left register"                ()  25  6)

(dshmf f-right       "Right register"               ()  15  6)

(dshmf f-dest        "Destination register"         ()   9  6)

(define-multi-ifield

  (name f-left-right)

  (comment "Left and right matched register pair")

  (attrs (ISA media))

  (mode UINT)

  (subfields f-left f-right)

  (insert (sequence ()

                    (set (ifield f-left)

                         (and (ifield f-left-right) 63))

                    (set (ifield f-right)

                         (and (ifield f-left-right) 63))))

  (extract (set (ifield f-left-right) (ifield f-left)))

)

(dshmf f-tra         "Target register"              ()   6  3)

(dshmf f-trb         "Target register"              ()  22  3)

(dshmf f-likely      "Likely bit"                   ()   9  1)

(dshmf f-25          "Three unused bits at bit 25"  ()  25  3)

(dshmf f-8-2         "Two unused bits at bit 8"     ()   8  2)

(df f-imm6   "Immediate value (6 bits)"      ((ISA media)) 15 6 INT #f #f)

(df f-imm10  "Immediate value (10 bits)"     ((ISA media)) 19 10 INT #f #f)

(df f-imm16  "Immediate value (16 bits)"     ((ISA media)) 25 16 INT #f #f)

(dshmf f-uimm6       "Immediate value (6 bits)"     ()  15  6)

(dshmf f-uimm16      "Immediate value (16 bits)"    ()  25 16)

; Various displacement fields.

; The 10 bit field, for example, has different scaling for displacements.

(df f-disp6          "Displacement (6 bits)"        ((ISA media)) 15 6 INT #f #f)

(df f-disp6x32       "Displacement (6 bits)"        ((ISA media)) 15 6 INT

    ((value pc) (sra SI value 5))

    ((value pc) (sll SI value 5)))

(df f-disp10         "Displacement (10 bits)"       ((ISA media)) 19 10 INT #f #f)

(df f-disp10x8       "Displacement (10 bits)"       ((ISA media)) 19 10 INT

    ((value pc) (sra SI value 3))

    ((value pc) (sll SI value 3)))

(df f-disp10x4       "Displacement (10 bits)"       ((ISA media)) 19 10 INT

    ((value pc) (sra SI value 2))

    ((value pc) (sll SI value 2)))

(df f-disp10x2       "Displacement (10 bits)"       ((ISA media)) 19 10 INT

    ((value pc) (sra SI value 1))

    ((value pc) (sll SI value 1)))

(df f-disp16         "Displacement (16 bits)"       ((ISA media) PCREL-ADDR) 25 16 INT

    ((value pc) (sra DI value 2))

    ((value pc) (add DI (sll DI value 2) pc)))

; Operands.

(dshmop rm        "Left general purpose reg"            ()  h-gr    f-left)

(dshmop rn        "Right general purpose reg"           ()  h-gr    f-right)

(dshmop rd        "Destination general purpose reg"     ()  h-gr    f-dest)

(dshmop frg       "Left single precision register"      ()  h-fr    f-left)

(dshmop frh       "Right single precision register"     ()  h-fr    f-right)

(dshmop frf       "Destination single precision reg"    ()  h-fr    f-dest)

(dshmop frgh      "Single precision register pair"      ()  h-fr    f-left-right)

(dshmop fpf       "Pair of single precision registers"  ()  h-fp    f-dest)

(dshmop fvg       "Left single precision vector"        ()  h-fv    f-left)

(dshmop fvh       "Right single precision vector"       ()  h-fv    f-right)

(dshmop fvf       "Destination single precision vector" ()  h-fv    f-dest)

(dshmop mtrxg     "Left single precision matrix"        ()  h-fmtx  f-left)

(dshmop drg       "Left double precision register"      ()  h-dr    f-left)

(dshmop drh       "Right double precision register"     ()  h-dr    f-right)

(dshmop drf       "Destination double precision reg"    ()  h-dr    f-dest)

(dshmop drgh      "Double precision register pair"      ()  h-dr    f-left-right)

(dshmop fpscr     "Floating point status register"      ()  h-fpscr f-nil)

(dshmop crj       "Control register j"                  ()  h-cr    f-dest)

(dshmop crk       "Control register k"                  ()  h-cr    f-left)

(dshmop tra       "Target register a"                   ()  h-tr    f-tra)

(dshmop trb       "Target register b"                   ()  h-tr    f-trb)

(dshmop disp6     "Displacement (6 bits)"               ()  h-sint  f-disp6)

(dshmop disp6x32  "Displacement (6 bits, scale 32)"     ()  h-sint  f-disp6x32)

(dshmop disp10    "Displacement (10 bits)"              ()  h-sint  f-disp10)

(dshmop disp10x2  "Displacement (10 bits, scale 2)"     ()  h-sint  f-disp10x2)

(dshmop disp10x4  "Displacement (10 bits, scale 4)"     ()  h-sint  f-disp10x4)

(dshmop disp10x8  "Displacement (10 bits, scale 8)"     ()  h-sint  f-disp10x8)

(dshmop disp16    "Displacement (16 bits)"              ()  h-sint  f-disp16)

(dshmop imm6      "Immediate (6 bits)"                  ()  h-sint  f-imm6)

(dshmop imm10     "Immediate (10 bits)"                 ()  h-sint  f-imm10)

(dshmop imm16     "Immediate (16 bits)"                 ()  h-sint  f-imm16)

(dshmop uimm6     "Immediate (6 bits)"                  ()  h-uint  f-uimm6)

(dshmop uimm16    "Unsigned immediate (16 bits)"        ()  h-uint  f-uimm16)

; FIXME: provide these parse/print functions in `sh-media.opc'.

(define-operand (name likely) (comment "Likely branch?") (attrs (ISA media))

  (type h-uint) (index f-likely) (handlers (parse "likely") (print "likely")))

; Instructions.

(dshmi add "Add"

       ()

       "add $rm, $rn, $rd"

       (+ (f-op 0) rm (f-ext 9) rn rd (f-rsvd 0))

       (set rd (add rm rn)))

(dshmi addl "Add long"

       ()

       "add.l $rm, $rn, $rd"

       (+ (f-op 0) rm (f-ext 8) rn rd (f-rsvd 0))

       (set rd (add (subword SI rm 1) (subword SI rn 1))))

(dshmi addi "Add immediate"

       ()

       "addi $rm, $disp10, $rd"

       (+ (f-op 52) rm disp10 rd (f-rsvd 0))

       (set rd (add rm (ext DI disp10))))

(dshmi addil "Add immediate long"

       ()

       "addi.l $rm, $disp10, $rd"

       (+ (f-op 53) rm disp10 rd (f-rsvd 0))

       (set rd (ext DI (add (ext SI disp10) (subword SI rm 1)))))

(dshmi addzl "Add zero extended long"

       ()

       "addz.l $rm, $rn, $rd"

       (+ (f-op 0) rm (f-ext 12) rn rd (f-rsvd 0))

       (set rd (zext DI (add (subword SI rm 1) (subword SI rn 1)))))

(dshmi alloco "Allocate operand cache block"

       ()

       "alloco $rm, $disp6x32"

       (+ (f-op 56) rm (f-ext 4) disp6x32 (f-dest 63) (f-rsvd 0))

       (unimp "alloco"))

(dshmi and "AND"

       ()

       "and $rm, $rn, $rd"

       (+ (f-op 1) rm (f-ext 11) rn rd (f-rsvd 0))

       (set rd (and rm rn)))

(dshmi andc "AND complement"

       ()

       "andc $rm, $rn, $rd"

       (+ (f-op 1) rm (f-ext 15) rn rd (f-rsvd 0))

       (set rd (and rm (inv rn))))

(dshmi andi "AND immediate"

       ()

       "andi $rm, $disp10, $rd"

       (+ (f-op 54) rm disp10 rd (f-rsvd 0))

       (set rd (and rm (ext DI disp10))))

(dshmi beq "Branch if equal"

       ()

       "beq$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 1) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (eq rm rn)

           (set pc tra)))

(dshmi beqi "Branch if equal immediate"

       ()

       "beqi$likely $rm, $imm6, $tra"

       (+ (f-op 57) rm (f-ext 1) imm6 likely (f-8-2 0) tra (f-rsvd 0))

       (if (eq rm (ext DI imm6))

           (set pc tra)))

(dshmi bge "Branch if greater than or equal"

       ()

       "bge$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 3) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (ge rm rn)

           (set pc tra)))

(dshmi bgeu "Branch if greater than or equal (unsigned comparison)"

       ()

       "bgeu$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 11) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (geu rm rn)

           (set pc tra)))

(dshmi bgt "Branch greater than"

       ()

       "bgt$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 7) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (gt rm rn)

           (set pc tra)))

(dshmi bgtu "Branch greater than (unsigned comparison)"

       ()

       "bgtu$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 15) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (gtu rm rn)

           (set pc tra)))

(dshmi blink "Branch and link"

       ()

       "blink $trb, $rd"

       (+ (f-op 17) (f-25 0) trb (f-ext 1) (f-right 63) rd (f-rsvd 0))

       (sequence ()

                 (set rd (or (add pc 4) 1))

                 (set pc trb)))

(dshmi bne "Branch if not equal"

       ()

       "bne$likely $rm, $rn, $tra"

       (+ (f-op 25) rm (f-ext 5) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (ne rm rn)

           (set pc tra)))

(dshmi bnei "Branch if not equal immediate"

       ()

       "bnei$likely $rm, $imm6, $tra"

       (+ (f-op 57) rm (f-ext 5) rn likely (f-8-2 0) tra (f-rsvd 0))

       (if (ne rm (ext DI imm6))

           (set pc tra)))

(dshmi brk "Breakpoint instruction"

       ()

       "brk"

       (+ (f-op 27) (f-left 63) (f-ext 5) (f-right 63) (f-dest 63) (f-rsvd 0))

       (c-call "sh64_break" pc))

(define-pmacro (-byterev-step)

  (sequence ()

    (set result (or (sll result 8) (and source 255)))

    (set source (srl source 8)))

)

(dshmi byterev "Byte reverse"

       ()

       "byterev $rm, $rd"

       (+ (f-op 0) rm (f-ext 15) (f-right 63) rd (f-rsvd 0))

       (sequence ((DI source) (DI result))

                 (set source rm)

                 (set result 0)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (-byterev-step)

                 (set rd result)))

(dshmi cmpeq "Compare equal"

       ()

       "cmpeq $rm, $rn, $rd"

       (+ (f-op 0) rm (f-ext 1) rn rd (f-rsvd 0))

       (set rd (if DI (eq rm rn) 1 0)))

(dshmi cmpgt "Compare greater than"

       ()

       "cmpgt $rm, $rn, $rd"

       (+ (f-op 0) rm (f-ext 3) rn rd (f-rsvd 0))

       (set rd (if DI (gt rm rn) 1 0)))

(dshmi cmpgtu "Compare greater than (unsigned comparison)"

       ()

       "cmpgtu $rm,$rn, $rd"

       (+ (f-op 0) rm (f-ext 7) rn rd (f-rsvd 0))

       (set rd (if DI (gtu rm rn) 1 0)))

(dshmi cmveq "Conditional move if equal to zero"

       ()

       "cmveq $rm, $rn, $rd"

       (+ (f-op 8) rm (f-ext 1) rn rd (f-rsvd 0))

       (if (eq rm 0)

           (set rd rn)))

(dshmi cmvne "Conditional move if not equal to zero"

       ()

       "cmvne $rm, $rn, $rd"

       (+ (f-op 8) rm (f-ext 5) rn rd (f-rsvd 0))

       (if (ne rm 0)

           (set rd rn)))

(dshmi fabsd "Floating point absolute (double)"

       ()

       "fabs.d $drgh, $drf"

       (+ (f-op 6) drgh (f-ext 1) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fabsd" drgh)))

(dshmi fabss "Floating point absolute (single)"

       ()

       "fabs.s $frgh, $frf"

       (+ (f-op 6) frgh (f-ext 0) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fabss" frgh)))

(dshmi faddd "Floating point add (double)"

       ()

       "fadd.d $drg, $drh, $drf"

       (+ (f-op 13) drg (f-ext 1) drh drf (f-rsvd 0))

       (set drf (c-call DF "sh64_faddd" drg drh)))

(dshmi fadds "Floating point add (single)"

       ()

       "fadd.s $frg, $frh, $frf"

       (+ (f-op 13) frg (f-ext 0) frh frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fadds" frg frh)))

(dshmi fcmpeqd "Floating point compare if equal (double)"

       ()

       "fcmpeq.d $drg, $drh, $rd"

       (+ (f-op 12) drg (f-ext 9) drh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpeqd" drg drh))))

(dshmi fcmpeqs "Floating point compare if equal (single)"

       ()

       "fcmpeq.s $frg, $frh, $rd"

       (+ (f-op 12) frg (f-ext 8) frh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpeqs" frg frh))))

(dshmi fcmpged "Floating compare compare if greater than or equal (double)"

       ()

       "fcmpge.d $drg, $drh, $rd"

       (+ (f-op 12) drg (f-ext 15) drh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpged" drg drh))))

(dshmi fcmpges "Floating point compare if greater than or equal (single)"

       ()

       "fcmpge.s $frg, $frh, $rd"

       (+ (f-op 12) frg (f-ext 14) frh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpges" frg frh))))

(dshmi fcmpgtd "Floating point compare if greater than (double)"

       ()

       "fcmpgt.d $drg, $drh, $rd"

       (+ (f-op 12) drg (f-ext 13) drh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpgtd" drg drh))))

(dshmi fcmpgts "Floating point compare if greater than (single)"

       ()

       "fcmpgt.s $frg, $frh, $rd"

       (+ (f-op 12) frg (f-ext 12) frh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpgts" frg frh))))

(dshmi fcmpund "Floating point unordered comparison (double)"

       ()

       "fcmpun.d $drg, $drh, $rd"

       (+ (f-op 12) drg (f-ext 11) drh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpund" drg drh))))

(dshmi fcmpuns "Floating point unordered comparison (single)"

       ()

       "fcmpun.s $frg, $frh, $rd"

       (+ (f-op 12) frg (f-ext 10) frh rd (f-rsvd 0))

       (set rd (zext DI (c-call BI "sh64_fcmpuns" frg frh))))

(dshmi fcnvds "Floating point coversion (double to single)"

       ()

       "fcnv.ds $drgh, $frf"

       (+ (f-op 14) drgh (f-ext 7) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fcnvds" drgh)))

(dshmi fcnvsd "Floating point conversion (single to double)"

       ()

       "fcnv.sd $frgh, $drf"

       (+ (f-op 14) frgh (f-ext 6) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fcnvsd" frgh)))

(dshmi fdivd "Floating point divide (double)"

       ()

       "fdiv.d $drg, $drh, $drf"

       (+ (f-op 13) drg (f-ext 5) drh drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fdivd" drg drh)))

(dshmi fdivs "Floating point divide (single)"

       ()

       "fdiv.s $frg, $frh, $frf"

       (+ (f-op 13) frg (f-ext 4) frh frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fdivs" frg frh)))

(dshmi fgetscr "Floating point get from FPSCR"

       ()

       "fgetscr $frf"

       (+ (f-op 7) (f-left 63) (f-ext 2) (f-right 63) frf (f-rsvd 0))

       (unimp "fputscr"))

       ; FIXME: this should work!

       ; (set frf fpscr))

(dshmi fiprs "Floating point inner product (single)"

       ()

       "fipr.s $fvg, $fvh, $frf"

       (+ (f-op 5) fvg (f-ext 6) fvh frf (f-rsvd 0))

       (sequence ((UQI g) (UQI h) (SF temp))

                 (set g (index-of fvg))

                 (set h (index-of fvh))

                 (set temp (c-call SF "sh64_fmuls" (reg h-fr g) (reg h-fr h)))

                 (set temp (c-call SF "sh64_fadds" temp

                   (c-call SF "sh64_fmuls" (reg h-fr (add g 1)) (reg h-fr (add h 1)))))

                 (set temp (c-call SF "sh64_fadds" temp

                   (c-call SF "sh64_fmuls" (reg h-fr (add g 2)) (reg h-fr (add h 2)))))

                 (set temp (c-call SF "sh64_fadds" temp

                   (c-call SF "sh64_fmuls" (reg h-fr (add g 3)) (reg h-fr (add h 3)))))

                 (set frf temp)))

(dshmi fldd "Floating point load (double)"

       ()

       "fld.d $rm, $disp10x8, $drf"

       (+ (f-op 39) rm disp10x8 drf (f-rsvd 0))

       (set drf (mem DF (add rm disp10x8))))

(dshmi fldp "Floating point load (pair of singles)"

       ()

       "fld.p $rm, $disp10x8, $fpf"

       (+ (f-op 38) rm disp10x8 fpf (f-rsvd 0))

       (sequence ((QI f))

                 (set f (index-of fpf))

                 (set (reg h-fr f) (mem SF (add rm disp10x8)))

                 (set (reg h-fr (add f 1)) (mem SF (add rm (add disp10x8 4))))))

(dshmi flds "Floating point load (single)"

       ()

       "fld.s $rm, $disp10x4, $frf"

       (+ (f-op 37) rm disp10x4 frf (f-rsvd 0))

       (set frf (mem SF (add rm disp10x4))))

(dshmi fldxd "Floating point extended load (double)"

       ()

       "fldx.d $rm, $rn, $drf"

       (+ (f-op 7) rm (f-ext 9) rn frf (f-rsvd 0))

       (set drf (mem DF (add rm rn))))

(dshmi fldxp "Floating point extended load (pair of singles)"

       ()

       "fldx.p $rm, $rn, $fpf"

       (+ (f-op 7) rm (f-ext 13) rn fpf (f-rsvd 0))

       (sequence ((QI f))

                 (set f (index-of fpf))

                 (set (reg h-fr f) (mem SF (add rm rn)))

                 (set (reg h-fr (add f 1)) (mem SF (add rm (add rn 4))))))

(dshmi fldxs "Floating point extended load (single)"

       ()

       "fldx.s $rm, $rn, $frf"

       (+ (f-op 7) rm (f-ext 8) rn frf (f-rsvd 0))

       (set frf (mem SF (add rm rn))))

(dshmi floatld "Floating point conversion (long to double)"

       ()

       "float.ld $frgh, $drf"

       (+ (f-op 14) frgh (f-ext 14) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_floatld" frgh)))

(dshmi floatls "Floating point conversion (long to single)"

       ()

       "float.ls $frgh, $frf"

       (+ (f-op 14) frgh (f-ext 12) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_floatls" frgh)))

(dshmi floatqd "Floating point conversion (quad to double)"

       ()

       "float.qd $drgh, $drf"

       (+ (f-op 14) drgh (f-ext 13) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_floatqd" drgh)))

(dshmi floatqs "Floating point conversion (quad to single)"

       ()

       "float.qs $drgh, $frf"

       (+ (f-op 14) drgh (f-ext 15) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_floatqs" drgh)))

(dshmi fmacs "Floating point multiply and accumulate (single)"

       ()

       "fmac.s $frg, $frh, $frf"

       (+ (f-op 13) frg (f-ext 14) frh frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fadds" frf (c-call SF "sh64_fmuls" frg frh))))

(dshmi fmovd "Floating point move double"

       ()

       "fmov.d $drgh, $drf"

       (+ (f-op 14) drgh (f-ext 1) drf (f-rsvd 0))

       (set drf drgh))

(dshmi fmovdq "Floating point move (double to quad integer)"

       ()

       "fmov.dq $drgh, $rd"

       (+ (f-op 12) drgh (f-ext 1) rd (f-rsvd 0))

       (set rd (subword DI drgh 0)))

(dshmi fmovls "Floating point move (lower to single)"

       ()

       "fmov.ls $rm, $frf"

       (+ (f-op 7) rm (f-ext 0) (f-right 63) frf (f-rsvd 0))

       (set frf (subword SF (subword SI rm 1) 0)))

(dshmi fmovqd "Floating point move (quad to double)"

       ()

       "fmov.qd $rm, $drf"

       (+ (f-op 7) rm (f-ext 1) (f-right 63) frf (f-rsvd 0))

       (set drf (subword DF rm 0)))

(dshmi fmovs "Floating point move (single)"

       ()

       "fmov.s $frgh, $frf"

       (+ (f-op 14) frgh (f-ext 0) frf (f-rsvd 0))

       (set frf frgh))

(dshmi fmovsl "Floating point move (single to lower)"

       ()

       "fmov.sl $frgh, $rd"

       (+ (f-op 12) frgh (f-ext 0) rd (f-rsvd 0))

       (set rd (ext DI (subword SI frgh 1))))

(dshmi fmuld "Floating point multiply (double)"

       ()

       "fmul.d $drg, $drh, $drf"

       (+ (f-op 13) drg (f-ext 7) drh drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fmuld" drg drh)))

(dshmi fmuls "Floating point multiply (single)"

       ()

       "fmul.s $frg, $frh, $frf"

       (+ (f-op 13) frg (f-ext 6) frh frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fmuls" frg frh)))

(dshmi fnegd "Floating point negate (double)"

       ()

       "fneg.d $drgh, $drf"

       (+ (f-op 6) drgh (f-ext 3) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fnegd" drgh)))

(dshmi fnegs "Floating point negate (single)"

       ()

       "fneg.s $frgh, $frf"

       (+ (f-op 6) frgh (f-ext 2) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fnegs" frgh)))

(dshmi fputscr "Floating point put to FPSCR"

       ()

       "fputscr $frgh"

       (+ (f-op 12) frgh (f-ext 2) (f-dest 63) (f-rsvd 0))

       (unimp "fputscr"))

       ; FIXME: this should work!

       ; (set fpscr (subword SI frgh 0)))

(dshmi fsqrtd "Floating point square root (double)"

       ()

       "fsqrt.d $drgh, $drf"

       (+ (f-op 14) drgh (f-ext 5) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_fsqrtd" drgh)))

(dshmi fsqrts "Floating point squart root (single)"

       ()

       "fsqrt.s $frgh, $frf"

       (+ (f-op 14) frgh (f-ext 4) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fsqrts" frgh)))

(dshmi fstd "Floating point store (double)"

       ()

       "fst.d $rm, $disp10x8, $drf"

       (+ (f-op 47) rm disp10x8 drf (f-rsvd 0))

       (set (mem DF (add rm disp10x8)) drf))

(dshmi fstp "Floating point store (pair of singles)"

       ()

       "fst.p $rm, $disp10x8, $fpf"

       (+ (f-op 46) rm disp10x8 fpf (f-rsvd 0))

       (sequence ((QI f))

                 (set f (index-of fpf))

                 (set (mem SF (add rm disp10x8)) (reg h-fr f))

                 (set (mem SF (add rm (add disp10x8 4))) (reg h-fr (add f 1)))))

(dshmi fsts "Floating point store (single)"

       ()

       "fst.s $rm, $disp10x4, $frf"

       (+ (f-op 45) rm disp10x4 frf (f-rsvd 0))

       (set (mem SF (add rm disp10x4)) frf))

(dshmi fstxd "Floating point extended store (double)"

       ()

       "fstx.d $rm, $rn, $drf"

       (+ (f-op 15) rm (f-ext 9) rn drf (f-rsvd 0))

       (set (mem DF (add rm rn)) drf))

(dshmi fstxp "Floating point extended store (pair of singles)"

       ()

       "fstx.p $rm, $rn, $fpf"

       (+ (f-op 15) rm (f-ext 13) rn fpf (f-rsvd 0))

       (sequence ((QI f))

                 (set f (index-of fpf))

                 (set (mem SF (add rm rn)) (reg h-fr f))

                 (set (mem SF (add rm (add rn 4))) (reg h-fr (add f 1)))))

(dshmi fstxs "Floating point extended store (single)"

       ()

       "fstx.s $rm, $rn, $frf"

       (+ (f-op 15) rm (f-ext 8) rn frf (f-rsvd 0))

       (set (mem SF (add rm rn)) frf))

(dshmi fsubd "Floating point subtract (double)"

       ()

       "fsub.d $drg, $drh, $drf"

       (+ (f-op 13) frg (f-ext 3) frh frf (f-rsvd 0))

       (set drf (c-call DF "sh64_fsubd" drg drh)))

(dshmi fsubs "Floating point subtract (single)"

       ()

       "fsub.s $frg, $frh, $frf"

       (+ (f-op 13) frg (f-ext 2) frh frf (f-rsvd 0))

       (set frf (c-call SF "sh64_fsubs" frg frh)))

(dshmi ftrcdl "Floating point conversion (double to long)"

       ()

       "ftrc.dl $drgh, $frf"

       (+ (f-op 14) drgh (f-ext 11) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_ftrcdl" drgh)))

(dshmi ftrcsl "Floating point conversion (single to long)"

       ()

       "ftrc.sl $frgh, $frf"

       (+ (f-op 14) frgh (f-ext 8) frf (f-rsvd 0))

       (set frf (c-call SF "sh64_ftrcsl" frgh)))

(dshmi ftrcdq "Floating point conversion (double to quad)"

       ()

       "ftrc.dq $drgh, $drf"

       (+ (f-op 14) drgh (f-ext 9) frf (f-rsvd 0))

       (set drf (c-call DF "sh64_ftrcdq" drgh)))

(dshmi ftrcsq "Floating point conversion (single to quad)"

       ()

       "ftrc.sq $frgh, $drf"

       (+ (f-op 14) frgh (f-ext 10) drf (f-rsvd 0))

       (set drf (c-call DF "sh64_ftrcsq" frgh)))

(dshmi ftrvs "Floating point matrix multiply"

       ()

       "ftrv.s $mtrxg, $fvh, $fvf"

       (+ (f-op 5) mtrxg (f-ext 14) fvh fvf (f-rsvd 0))

       (c-call "sh64_ftrvs" (index-of mtrxg) (index-of fvh) (index-of fvf)))

(dshmi getcfg "Get configuration register"

       ()

       "getcfg $rm, $disp6, $rd"

       (+ (f-op 48) rm (f-ext 15) disp6 rd (f-rsvd 0))

       (unimp "getcfg"))

(dshmi getcon "Get control register"

       ()

       "getcon $crk, $rd"

       (+ (f-op 9) crk (f-ext 15) (f-right 63) rd (f-rsvd 0))

       (set rd crk))

(dshmi gettr "Get target register"

       ()

       "gettr $trb, $rd"

       (+ (f-op 17) (f-25 0) trb (f-ext 5) (f-right 63) rd (f-rsvd 0))

       (set rd trb))

(dshmi icbi "Invalidate instruction cache block"

       ()

       "icbi $rm, $disp6x32"

       (+ (f-op 56) rm (f-ext 5) disp6x32 (f-dest 63) (f-rsvd 0))

       (unimp "icbi"))

(dshmi ldb "Load byte"

       ()

       "ld.b $rm, $disp10, $rd"

       (+ (f-op 32) rm disp10 rd (f-rsvd 0))

       (set rd (ext DI (mem QI (add rm (ext DI disp10))))))

(dshmi ldl "Load long word"

       ()

       "ld.l $rm, $disp10x4, $rd"

       (+ (f-op 34) rm disp10x4 rd (f-rsvd 0))

       (set rd (ext DI (mem SI (add rm (ext DI disp10x4))))))

(dshmi ldq "Load quad word"

       ()

       "ld.q $rm, $disp10x8, $rd"

       (+ (f-op 35) rm disp10x8 rd (f-rsvd 0))

       (set rd (mem DI (add rm (ext DI disp10x8)))))

(dshmi ldub "Load unsigned byte"

       ()

       "ld.ub $rm, $disp10, $rd"

       (+ (f-op 36) rm disp10 rd (f-rsvd 0))

       (set rd (zext DI (mem QI (add rm (ext DI disp10))))))

(dshmi lduw "Load unsigned word"

       ()

       "ld.uw $rm, $disp10x2, $rd"

       (+ (f-op 44) rm disp10 rd (f-rsvd 0))

       (set rd (zext DI (mem HI (add rm (ext DI disp10x2))))))

(dshmi ldw "Load word"

       ()

       "ld.w $rm, $disp10x2, $rd"

       (+ (f-op 33) rm disp10 rd (f-rsvd 0))

       (set rd (ext DI (mem HI (add rm (ext DI disp10x2))))))

(dshmi ldhil "Load high part (long word)"

       ()

       "ldhi.l $rm, $disp6, $rd"

       (+ (f-op 48) rm (f-ext 6) disp6 rd (f-rsvd 0))

       ; FIXME.

       (unimp "ldhil"))

(dshmi ldhiq "Load high part (quad word)"

       ()

       "ldhi.q $rm, $disp6, $rd"

       (+ (f-op 48) rm (f-ext 7) disp6 rd (f-rsvd 0))

       ; FIXME.

       (unimp "ldhiq"))

(dshmi ldlol "Load low part (long word)"

       ()

       "ldlo.l $rm, $disp6, $rd"

       (+ (f-op 48) rm (f-ext 2) disp6 rd (f-rsvd 0))

       ; FIXME.

       (unimp "ldlol"))

(dshmi ldloq "Load low part (quad word)"

       ()

       "ldlo.q $rm, $disp6, $rd"

       (+ (f-op 48) rm (f-ext 3) disp6 rd (f-rsvd 0))

       ; FIXME;

       (unimp "ldloq"))

(dshmi ldxb "Load byte (extended displacement)"

       ()

       "ldx.b $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 0) rn rd (f-rsvd 0))

       (set rd (ext DI (mem QI (add rm rn)))))

(dshmi ldxl "Load long word (extended displacement)"

       ()

       "ldx.l $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 2) rn rd (f-rsvd 0))

       (set rd (ext DI (mem SI (add rm rn)))))

(dshmi ldxq "Load quad word (extended displacement)"

       ()

       "ldx.q $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 3) rn rd (f-rsvd 0))

       (set rd (mem DI (add rm rn))))

(dshmi ldxub "Load unsigned byte (extended displacement)"

       ()

       "ldx.ub $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 4) rn rd (f-rsvd 0))

       (set rd (zext DI (mem UQI (add rm rn)))))

(dshmi ldxuw "Load unsigned word (extended displacement)"

       ()

       "ldx.uw $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 5) rn rd (f-rsvd 0))

       (set rd (zext DI (mem UHI (add rm rn)))))

(dshmi ldxw "Load word (extended displacement)"

       ()

       "ldx.w $rm, $rn, $rd"

       (+ (f-op 16) rm (f-ext 1) rn rd (f-rsvd 0))

       (set rd (ext DI (mem HI (add rm rn)))))

; Macros to facilitate multimedia instructions.

(define-pmacro (slice-byte expr)

  (sequence ((QI result7) (QI result6) (QI result5) (QI result4)

             (QI result3) (QI result2) (QI result1) (QI result0))

            (set result0 (expr (subword QI rm 7) (subword QI rn 7)))

            (set result1 (expr (subword QI rm 6) (subword QI rn 6)))

            (set result2 (expr (subword QI rm 5) (subword QI rn 5)))

            (set result3 (expr (subword QI rm 4) (subword QI rn 4)))

            (set result4 (expr (subword QI rm 3) (subword QI rn 3)))

            (set result5 (expr (subword QI rm 2) (subword QI rn 2)))

            (set result6 (expr (subword QI rm 1) (subword QI rn 1)))

            (set result7 (expr (subword QI rm 0) (subword QI rn 0)))

            (set rd (-join-qi result7 result6 result5 result4 result3 result2

                           result1 result0))))

(define-pmacro (slice-word expr)

  (sequence ((HI result3) (HI result2) (HI result1) (HI result0))

            (set result0 (expr (subword HI rm 3) (subword HI rn 3)))

            (set result1 (expr (subword HI rm 2) (subword HI rn 2)))

            (set result2 (expr (subword HI rm 1) (subword HI rn 1)))

            (set result3 (expr (subword HI rm 0) (subword HI rn 0)))

            (set rd (-join-hi result3 result2 result1 result0))))

(define-pmacro (slice-word-unop expr)

  (sequence ((HI result3) (HI result2) (HI result1) (HI result0))

            (set result0 (expr (subword HI rm 3)))

            (set result1 (expr (subword HI rm 2)))

            (set result2 (expr (subword HI rm 1)))

            (set result3 (expr (subword HI rm 0)))

            (set rd (-join-hi result3 result2 result1 result0))))

(define-pmacro (slice-long expr)

  (sequence ((SI result1) (SI result0))

            (set result0 (expr (subword SI rm 1) (subword SI rn 1)))

            (set result1 (expr (subword SI rm 0) (subword SI rn 0)))

            (set rd (-join-si result1 result0))))

(define-pmacro (slice-long-unop expr)

  (sequence ((SI result1) (SI result0))

            (set result0 (expr (subword SI rm 1)))

            (set result1 (expr (subword SI rm 0)))

            (set rd (-join-si result1 result0))))

; Multimedia instructions.

(dshmi mabsl "Multimedia absolute value (long word)"

       ()

       "mabs.l $rm, $rd"

       (+ (f-op 10) rm (f-ext 10) (f-right 63) rd (f-rsvd 0))

       (slice-long-unop abs))

(dshmi mabsw "Multimedia absolute value (word)"

       ()

       "mabs.w $rm, $rd"

       (+ (f-op 10) rm (f-ext 9) (f-right 63) rd (f-rsvd 0))

       (slice-word-unop abs))

(dshmi maddl "Multimedia add (long word)"

       ()

       "madd.l $rm, $rn, $rd"

       (+ (f-op 2) rm (f-ext 2) rn rd (f-rsvd 0))

       (slice-long add))

(dshmi maddw "Multimedia add (word)"

       ()

       "madd.w $rm, $rn, $rd"

       (+ (f-op 2) rm (f-ext 1) rn rd (f-rsvd 0))

       (slice-word add))

(define-pmacro (-maddsl arg1 arg2) (saturate SI 32 (add arg1 arg2)))

(dshmi maddsl "Multimedia add (saturating, long word)"

       ()

       "madds.l $rm, $rn, $rd"

       (+ (f-op 2) rm (f-ext 6) rn rd (f-rsvd 0))

       (slice-long -maddsl))

(define-pmacro (-maddsub arg1 arg2) (usaturate QI 8 (add arg1 arg2)))

(dshmi maddsub "Multimedia add (saturating, unsigned byte)"

       ()

       "madds.ub $rm, $rn, $rd"

       (+ (f-op 2) rm (f-ext 4) rn rd (f-rsvd 0))

       (slice-byte -maddsub))

(define-pmacro (-maddsw arg1 arg2) (saturate HI 16 (add arg1 arg2)))

(dshmi maddsw "Multimedia add (saturating, word)"

       ()

       "madds.w $rm, $rn, $rd"

       (+ (f-op 2) rm (f-ext 5) rn rd (f-rsvd 0))

       (slice-word -maddsw))