home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / config / tahoe.md < prev    next >
Text File  |  1994-02-06  |  55KB  |  2,157 lines
  1. ;;- Machine description for GNU compiler
  2. ;;- Tahoe version
  3. ;;   Copyright (C) 1989 Free Software Foundation, Inc.
  4.  
  5. ;; This file is part of GNU CC.
  6.  
  7. ;; GNU CC is free software; you can redistribute it and/or modify
  8. ;; it under the terms of the GNU General Public License as published by
  9. ;; the Free Software Foundation; either version 2, or (at your option)
  10. ;; any later version.
  11.  
  12. ;; GNU CC is distributed in the hope that it will be useful,
  13. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ;; GNU General Public License for more details.
  16.  
  17. ;; You should have received a copy of the GNU General Public License
  18. ;; along with GNU CC; see the file COPYING.  If not, write to
  19. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.  
  22. ; File: tahoe.md
  23. ;
  24. ; Original port made at the University of Buffalo by Devon Bowen,
  25. ; Dale Wiles and Kevin Zachmann.
  26. ;
  27. ; Piet van Oostrum (piet@cs.ruu.nl) made changes for HCX/UX, fixed
  28. ; some bugs and made some improvements (hopefully).
  29. ;
  30. ; Mail bugs reports or fixes to:    gcc@cs.buffalo.edu
  31.  
  32.  
  33. ; movdi must call the output_move_double routine to move it around since
  34. ; the tahoe doesn't efficiently support 8 bit moves.
  35.  
  36. (define_insn "movdi"
  37.   [(set (match_operand:DI 0 "general_operand" "=g")
  38.     (match_operand:DI 1 "general_operand" "g"))]
  39.   ""
  40.   "*
  41. {
  42.   CC_STATUS_INIT;
  43.   return output_move_double (operands);
  44. }")
  45.  
  46.  
  47. ; the trick in the movsi is accessing the contents of the sp register.  The
  48. ; tahoe doesn't allow you to access it directly so you have to access the
  49. ; address of the top of the stack instead.
  50.  
  51. (define_insn "movsi"
  52.   [(set (match_operand:SI 0 "general_operand" "=g")
  53.     (match_operand:SI 1 "general_operand" "g"))]
  54.   ""
  55.   "*
  56. {
  57.    rtx link;
  58.    if (operands[1] == const1_rtx
  59.       && (link = find_reg_note (insn, REG_WAS_0, 0))
  60.       && ! XEXP (link, 0)->volatil
  61.       && GET_CODE (XEXP (link, 0)) != NOTE
  62.       && no_labels_between_p (XEXP (link, 0), insn))
  63.     return \"incl %0\";
  64.    if (GET_CODE (operands[1]) == SYMBOL_REF || GET_CODE (operands[1]) == CONST)
  65.     {
  66.       if (push_operand (operands[0], SImode))
  67.     return \"pushab %a1\";
  68.       return \"movab %a1,%0\";
  69.     }
  70.   if (operands[1] == const0_rtx)
  71.     return \"clrl %0\";
  72.   if (push_operand (operands[0], SImode))
  73.     return \"pushl %1\";
  74.   if (GET_CODE(operands[1]) == REG && REGNO(operands[1]) == 14)
  75.     return \"moval (sp),%0\";
  76.   return \"movl %1,%0\";
  77. }")
  78.  
  79.  
  80. (define_insn "movhi"
  81.   [(set (match_operand:HI 0 "general_operand" "=g")
  82.     (match_operand:HI 1 "general_operand" "g"))]
  83.   ""
  84.   "*
  85. {
  86.  rtx link;
  87.  if (operands[1] == const1_rtx
  88.      && (link = find_reg_note (insn, REG_WAS_0, 0))
  89.      && ! XEXP (link, 0)->volatil
  90.      && GET_CODE (XEXP (link, 0)) != NOTE
  91.      && no_labels_between_p (XEXP (link, 0), insn))
  92.     return \"incw %0\";
  93.   if (operands[1] == const0_rtx)
  94.     return \"clrw %0\";
  95.   return \"movw %1,%0\";
  96. }")
  97.  
  98.  
  99. (define_insn "movqi"
  100.   [(set (match_operand:QI 0 "general_operand" "=g")
  101.     (match_operand:QI 1 "general_operand" "g"))]
  102.   ""
  103.   "*
  104. {
  105.   if (operands[1] == const0_rtx)
  106.     return \"clrb %0\";
  107.   return \"movb %1,%0\";
  108. }")
  109.  
  110.  
  111. ; movsf has three cases since they can move from one place to another
  112. ; or to/from the fpp and since different instructions are needed for
  113. ; each case.  The fpp related instructions don't set the flags properly.
  114.  
  115. (define_insn "movsf"
  116.   [(set (match_operand:SF 0 "general_operand" "=g,=a,=g")
  117.     (match_operand:SF 1 "general_operand" "g,g,a"))]
  118.   ""
  119.   "*
  120. {
  121.   CC_STATUS_INIT;
  122.   switch (which_alternative)
  123.     {
  124.     case 0: return \"movl %1,%0\";
  125.     case 1: return \"ldf %1\";
  126.     case 2: return \"stf %0\";
  127.    }
  128. }")
  129.  
  130.  
  131. ; movdf has a number of different cases.  If it's going to or from
  132. ; the fpp, use the special instructions to do it.  If not, use the
  133. ; output_move_double function.
  134.  
  135. (define_insn "movdf"
  136.   [(set (match_operand:DF 0 "general_operand" "=a,=g,?=g")
  137.     (match_operand:DF 1 "general_operand" "g,a,g"))]
  138.   ""
  139.   "*
  140. {
  141.   CC_STATUS_INIT;
  142.   switch (which_alternative)
  143.     {
  144.     case 0:
  145.       return \"ldd %1\";
  146.     case 1:
  147.       if (push_operand (operands[0], DFmode))
  148.         return \"pushd\";
  149.       else
  150.         return \"std %0\";
  151.     case 2:
  152.       return output_move_double (operands);
  153.    }
  154. }")
  155.  
  156.  
  157. ;========================================================================
  158. ; The tahoe has the following semantics for byte (and similar for word)
  159. ; operands: if the operand is a register or immediate, it takes the full 32
  160. ; bit operand, if the operand is memory, it sign-extends the byte.  The
  161. ; operation is performed on the 32 bit values.  If the destination is a
  162. ; register, the full 32 bit result is stored, if the destination is memory,
  163. ; of course only the low part is stored.  The condition code is based on the
  164. ; 32 bit operation.  Only on the movz instructions the byte from memory is
  165. ; zero-extended rather than sign-extended.
  166.  
  167. ; This means that for arithmetic instructions we can use addb etc.  to
  168. ; perform a long add from a signed byte from memory to a register.  Of
  169. ; course this would also work for logical operations, but that doesn't seem
  170. ; very useful.
  171.  
  172. (define_insn ""
  173.   [(set (match_operand:SI 0 "register_operand" "=r")
  174.     (plus:SI (sign_extend:SI (match_operand:QI 1 "memory_operand" "m"))
  175.          (sign_extend:SI (match_operand:QI 2 "memory_operand" "m"))))]
  176.   ""
  177.   "addb3 %1,%2,%0")
  178.  
  179. (define_insn ""
  180.   [(set (match_operand:SI 0 "register_operand" "=r")
  181.     (plus:SI (match_operand:SI 1 "nonmemory_operand" "%ri")
  182.          (sign_extend:SI (match_operand:QI 2 "memory_operand" "m"))))]
  183.   ""
  184.   "*
  185. {
  186.   if (rtx_equal_p (operands[0], operands[1]))
  187.     return \"addb2 %2,%0\";
  188.   return \"addb3 %1,%2,%0\";
  189. }")
  190.  
  191. ; We can also consider the result to be a half integer
  192.  
  193. (define_insn ""
  194.   [(set (match_operand:HI 0 "register_operand" "=r")
  195.     (plus:HI (sign_extend:HI (match_operand:QI 1 "memory_operand" "m"))
  196.          (sign_extend:HI (match_operand:QI 2 "memory_operand" "m"))))]
  197.   ""
  198.   "addb3 %1,%2,%0")
  199.  
  200. (define_insn ""
  201.   [(set (match_operand:HI 0 "register_operand" "=r")
  202.     (plus:HI (match_operand:HI 1 "nonmemory_operand" "%ri")
  203.          (sign_extend:HI (match_operand:QI 2 "memory_operand" "m"))))]
  204.   ""
  205.   "*
  206. {
  207.   if (rtx_equal_p (operands[0], operands[1]))
  208.     return \"addb2 %2,%0\";
  209.   return \"addb3 %1,%2,%0\";
  210. }")
  211.  
  212. ; The same applies to words (HI)
  213.  
  214. (define_insn ""
  215.   [(set (match_operand:SI 0 "register_operand" "=r")
  216.     (plus:SI (sign_extend:SI (match_operand:HI 1 "memory_operand" "m"))
  217.          (sign_extend:SI (match_operand:HI 2 "memory_operand" "m"))))]
  218.   ""
  219.   "addw3 %1,%2,%0")
  220.  
  221. (define_insn ""
  222.   [(set (match_operand:SI 0 "register_operand" "=r")
  223.     (plus:SI (match_operand:SI 1 "nonmemory_operand" "%ri")
  224.          (sign_extend:SI (match_operand:HI 2 "memory_operand" "m"))))]
  225.   ""
  226.   "*
  227. {
  228.   if (rtx_equal_p (operands[0], operands[1]))
  229.     return \"addw2 %2,%0\";
  230.   return \"addw3 %1,%2,%0\";
  231. }")
  232.  
  233. ; ======================= Now for subtract ==============================
  234.  
  235. (define_insn ""
  236.   [(set (match_operand:SI 0 "register_operand" "=r")
  237.     (minus:SI (sign_extend:SI (match_operand:QI 1 "memory_operand" "m"))
  238.           (sign_extend:SI (match_operand:QI 2 "memory_operand" "m"))))]
  239.   ""
  240.   "subb3 %2,%1,%0")
  241.  
  242. (define_insn ""
  243.   [(set (match_operand:SI 0 "register_operand" "=r")
  244.     (minus:SI (match_operand:SI 1 "nonmemory_operand" "ri")
  245.           (sign_extend:SI (match_operand:QI 2 "memory_operand" "m"))))]
  246.   ""
  247.   "*
  248. {
  249.   if (rtx_equal_p (operands[0], operands[1]))
  250.     return \"subb2 %2,%0\";
  251.   return \"subb3 %2,%1,%0\";
  252. }")
  253.  
  254. (define_insn ""
  255.   [(set (match_operand:SI 0 "register_operand" "=r")
  256.     (minus:SI (sign_extend:SI (match_operand:QI 1 "memory_operand" "m"))
  257.           (match_operand:SI 2 "nonmemory_operand" "ri")))]
  258.   ""
  259.   "subb3 %2,%1,%0")
  260.  
  261. ; We can also consider the result to be a half integer
  262.  
  263. (define_insn ""
  264.   [(set (match_operand:HI 0 "register_operand" "=r")
  265.     (minus:HI (sign_extend:HI (match_operand:QI 1 "memory_operand" "m"))
  266.          (sign_extend:HI (match_operand:QI 2 "memory_operand" "m"))))]
  267.   ""
  268.   "subb3 %2,%1,%0")
  269.  
  270. (define_insn ""
  271.   [(set (match_operand:HI 0 "register_operand" "=r")
  272.     (minus:HI (match_operand:HI 1 "nonmemory_operand" "%ri")
  273.          (sign_extend:HI (match_operand:QI 2 "memory_operand" "m"))))]
  274.   ""
  275.   "*
  276. {
  277.   if (rtx_equal_p (operands[0], o