home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / romp.md < prev    next >
Text File  |  1991-06-04  |  79KB  |  2,574 lines
  1. ;;- Machine description for ROMP chip for GNU C compiler
  2. ;;   Copyright (C) 1988-1991 Free Software Foundation, Inc.
  3. ;;   Contributed by Richard Kenner (kenner@nyu.edu)
  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. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  23.  
  24. ;; Define the attributes for the ROMP.
  25.  
  26. ;; Insn type.  Used to default other attribute values.
  27.  
  28. (define_attr "type"
  29.   "branch,return,fp,load,loadz,store,call,address,arith,compare,multi,misc"
  30.   (const_string "arith"))
  31.  
  32. ;; Length in bytes.
  33.  
  34. (define_attr "length" ""
  35.   (cond [(eq_attr "type" "branch")
  36.      (if_then_else (and (ge (minus (pc) (match_dup 0))
  37.                 (const_int -256))
  38.                 (le (minus (pc) (match_dup 0))
  39.                 (const_int 254)))
  40.                (const_int 2)
  41.                (const_int 4))
  42.      (eq_attr "type" "return")    (const_int 2)
  43.      (eq_attr "type" "fp")        (const_int 10)
  44.      (eq_attr "type" "call")    (const_int 4)
  45.      (eq_attr "type" "load")
  46.        (cond [(match_operand 1 "short_memory_operand" "") (const_int 2)
  47.           (match_operand 1 "symbolic_memory_operand" "") (const_int 8)]
  48.          (const_int 4))
  49.          (eq_attr "type" "loadz")
  50.        (cond [(match_operand 1 "zero_memory_operand" "") (const_int 2)
  51.           (match_operand 1 "symbolic_memory_operand" "") (const_int 8)]
  52.          (const_string "4"))
  53.      (eq_attr "type" "store")
  54.        (cond [(match_operand 0 "short_memory_operand" "") (const_int 2)
  55.           (match_operand 0 "symbolic_memory_operand" "") (const_int 8)]
  56.          (const_int 4))]
  57.     (const_int 4)))
  58.  
  59. ;; Whether insn can be placed in a delay slot.
  60.  
  61. (define_attr "in_delay_slot" "yes,no" 
  62.   (cond [(eq_attr "length" "8,10,38")            (const_string "no")
  63.      (eq_attr "type" "branch,return,call,multi")    (const_string "no")]
  64.     (const_string "yes")))
  65.  
  66. ;; Whether insn needs a delay slot.
  67. (define_attr "needs_delay_slot" "yes,no"
  68.   (if_then_else (eq_attr "type" "branch,return,call")
  69.         (const_string "yes") (const_string "no")))
  70.  
  71. ;; What insn does to the condition code.
  72.  
  73. (define_attr "cc"
  74.   "clobber,none,sets,change0,copy1to0,compare,tbit"
  75.   (cond [(eq_attr "type" "load,loadz")        (const_string "change0")
  76.      (eq_attr "type" "store")        (const_string "none")
  77.      (eq_attr "type" "fp,call")        (const_string "clobber")
  78.      (eq_attr "type" "branch,return")    (const_string "none")
  79.      (eq_attr "type" "address")        (const_string "change0")
  80.      (eq_attr "type" "compare")        (const_string "compare")
  81.      (eq_attr "type" "arith")        (const_string "sets")]
  82.     (const_string "clobber")))
  83.  
  84. ;; Define attributes for `asm' insns.
  85.  
  86. (define_asm_attributes [(set_attr "type" "misc")
  87.             (set_attr "length" "8")
  88.             (set_attr "in_delay_slot" "no")
  89.             (set_attr "cc" "clobber")])
  90.  
  91. ;; Define the delay slot requirements for branches and calls.  We don't have
  92. ;; any annulled insns.
  93. ;;
  94. (define_delay (eq_attr "needs_delay_slot" "yes")
  95.   [(eq_attr "in_delay_slot" "yes") (nil) (nil)])
  96.  
  97. ;; We cannot give a floating-point comparison a delay slot, even though it
  98. ;; could make use of it.  This is because it would confuse next_cc0_user
  99. ;; to do so.  Other fp insns can't get a delay slow because they set their
  100. ;; result and use their input after the delay slot insn is executed.  This
  101. ;; isn't what reorg.c expects.  
  102.  
  103. ;; Define load & store delays.  These were obtained by measurements done by
  104. ;; jfc@athena.mit.edu.
  105. ;;
  106. ;; In general, the memory unit can support at most two simultaneous operations.
  107. ;;
  108. ;; Loads take 5 cycles to return the data and can be pipelined up to the
  109. ;; limit of two simultaneous operations.
  110. (define_function_unit "memory" 1 2 (eq_attr "type" "load,loadz") 5 0)
  111.  
  112. ;; Stores do not return data, but tie up the memory unit for 2 cycles if the
  113. ;; next insn is also a store.
  114. (define_function_unit "memory" 1 2 (eq_attr "type" "store") 1 2
  115.   [(eq_attr "type" "store")])
  116.  
  117. ;; Move word instructions.
  118. ;;
  119. ;; If destination is memory but source is not register, force source to
  120. ;; register.
  121. ;;
  122. ;; If source is a constant that is too large to load in a single insn, build
  123. ;; it in two pieces.
  124. ;;
  125. ;; If destination is memory and source is a register, a temporary register
  126. ;; will be needed.  In that case, make a PARALLEL of the SET and a
  127. ;; CLOBBER of a SCRATCH to allocate the required temporary.
  128. ;;
  129. ;; This temporary is ACTUALLY only needed when the destination is a
  130. ;; relocatable expression.  For generating RTL, however, we always
  131. ;; place the CLOBBER.  In insns where it is not needed, the SCRATCH will
  132. ;; not be allocated to a register.
  133. ;;
  134. ;; Also, avoid creating pseudo-registers or SCRATCH rtx's during reload as
  135. ;; they will not be correctly handled.  We never need pseudos for that
  136. ;; case anyway.
  137. ;;
  138. ;; We do not use DEFINE_SPLIT for loading constants because the number
  139. ;; of cases in the resulting unsplit insn would be too high to deal
  140. ;; with practically.
  141. (define_expand "movsi"
  142.   [(set (match_operand:SI 0 "general_operand" "")
  143.     (match_operand:SI 1 "general_operand" ""))]
  144.   ""
  145.   "
  146. { rtx op0 = operands[0];
  147.   rtx op1 = operands[1];
  148.  
  149.   if (GET_CODE (op1) == REG && REGNO (op1) == 16)
  150.     DONE;
  151.  
  152.   if (GET_CODE (op0) == REG && REGNO (op0) == 16)
  153.     DONE;
  154.  
  155.   if (GET_CODE (op0) == MEM && ! reload_in_progress)
  156.     {
  157.       emit_insn (gen_storesi (operands[0], force_reg (SImode, operands[1])));
  158.       DONE;
  159.     }
  160.   else if (GET_CODE (op1) == CONST_INT)
  161.     {
  162.       int const_val = INTVAL (op1);
  163.  
  164.       /* Try a number of cases to see how to best load the constant.  */
  165.       if ((const_val & 0xffff) == 0
  166.       || (const_val & 0xffff0000) == 0
  167.       || (unsigned) (const_val + 0x8000) < 0x10000)
  168.     /* Can do this in one insn, so generate it.  */
  169.     ;
  170.       else if (((- const_val) & 0xffff) == 0
  171.            || ((- const_val) & 0xffff0000) == 0
  172.            || (unsigned) ((- const_val) + 0x8000) < 0x10000)
  173.     {
  174.       /* Can do this by loading the negative constant and then negating. */
  175.       emit_move_insn (operands[0],
  176.               gen_rtx (CONST_INT, VOIDmode, - const_val));
  177.       emit_insn (gen_negsi2 (operands[0], operands[0]));
  178.       DONE;
  179.     }
  180.       else
  181.     /* Do this the long way.  */
  182.     {
  183.       unsigned int high_part = const_val & 0xffff0000;
  184.       unsigned int low_part = const_val & 0xffff;
  185.       int i;
  186.  
  187.       if (low_part >= 0x10 && exact_log2 (low_part) >= 0)
  188.         i = high_part, high_part = low_part, low_part = i;
  189.  
  190.       emit_move_insn (operands[0],
  191.               gen_rtx (CONST_INT, VOIDmode, low_part));
  192.       emit_insn (gen_iorsi3 (operands[0], operands[0],
  193.                  gen_rtx (CONST_INT, VOIDmode, high_part)));
  194.       DONE;
  195.     }
  196.     }
  197. }")
  198.  
  199. ;; Move from a symbolic memory location to a register is special.  In this
  200. ;; case, we know in advance that the register cannot be r0, so we can improve
  201. ;; register allocation by treating it separately.
  202.  
  203. (define_insn ""
  204.   [(set (match_operand:SI 0 "register_operand" "=b")
  205.     (match_operand:SI 1 "symbolic_memory_operand" "m"))]
  206.   ""
  207.   "load %0,%1"
  208.   [(set_attr "type" "load")])
  209.  
  210. ;; Generic single-word move insn.  We avoid the case where the destination is
  211. ;; a symbolic address, as that needs a temporary register.
  212.  
  213. (define_insn ""
  214.   [(set (match_operand:SI 0 "reg_or_nonsymb_mem_operand" "=r,r,r,r,r,r,r,r,b,Q")
  215.     (match_operand:SI 1 "romp_operand" "rR,I,K,L,M,S,s,Q,m,r"))]
  216.   "register_operand (operands[0], SImode)
  217.    || register_operand (operands[1], SImode)"
  218.   "@
  219.    cas %0,%1,r0
  220.    lis %0,%1
  221.    cal %0,%1(r0)
  222.    cal16 %0,%1(r0)
  223.    cau %0,%H1(r0)
  224.    ail %0,r14,%C1
  225.    get %0,$%1
  226.    l%M1 %0,%1
  227.    load %0,%1
  228.    st%M0 %1,%0"
  229.   [(set_attr "type" "address,address,address,address,address,arith,misc,load,load,store")
  230.    (set_attr "length" "2,2,4,4,4,4,8,*,*,*")])
  231.  
  232. (define_insn "storesi"
  233.   [(set (match_operand:SI 0 "memory_operand" "=Q,m")
  234.     (match_operand:SI 1 "register_operand" "r,r"))
  235.    (clobber (match_scratch:SI 2 "=X,&b"))]
  236.   ""
  237.   "@
  238.    st%M0 %1,%0
  239.    store %1,%0,%2"
  240.   [(set_attr "type" "store")])
  241.  
  242. ;; Now do the same for the QI move instructions.
  243. (define_expand "movqi"
  244.   [(set (match_operand:QI 0 "general_operand" "")
  245.     (match_operand:QI 1 "general_operand" ""))]
  246.   ""
  247.   "
  248. { rtx op0 = operands[0];
  249.  
  250.   if (GET_CODE (op0) == MEM && ! reload_in_progress)
  251.     {
  252.       emit_insn (gen_storeqi (operands[0], force_reg (QImode, operands[1])));
  253.       DONE;
  254.     }
  255. }")
  256.  
  257. (define_insn ""
  258.   [(set (match_operand:QI 0 "register_operand" "=b")
  259.     (match_operand:QI 1 "symbolic_memory_operand" "m"))]
  260.   "" 
  261.   "loadc %0,%1"
  262.   [(set_attr "type" "load")])
  263.  
  264. (define_insn ""
  265.   [(set (match_operand:QI 0 "reg_or_nonsymb_mem_operand" "=r,r,r,r,r,b,Q")
  266.     (match_operand:QI 1 "romp_operand" "r,I,n,s,Q,m,r"))]
  267.   "register_operand (operands[0], QImode)
  268.    || register_operand (operands[1], QImode)"
  269.   "@
  270.    cas %0,%1,r0
  271.    lis %0,%1
  272.    cal %0,%L1(r0)
  273.    get %0,$%1
  274.    lc%M1 %0,%1
  275.    loadc %0,%1
  276.    stc%M0 %1,%0"
  277.   [(set_attr "type" "address,address,address,misc,load,load,store")
  278.    (set_attr "length" "2,2,4,8,*,*,*")])
  279.  
  280. (define_insn "storeqi"
  281.   [(set (match_operand:QI 0 "memory_operand" "=Q,m")
  282.     (match_operand:QI 1 "register_operand" "r,r"))
  283.    (clobber (match_scratch:SI 2 "=X,&b"))]
  284.   ""
  285.   "@
  286.    stc%M0 %1,%0
  287.    storec %1,%0,%2"
  288.   [(set_attr "type" "store")])
  289.  
  290. ;; Finally, the HI instructions.
  291. (define_expand "movhi"
  292.   [(set (match_operand:HI 0 "general_operand" "")
  293.     (match_operand:HI 1 "general_operand" ""))]
  294.   ""
  295.   "
  296. { rtx op0 = operands[0];
  297.  
  298.   if (GET_CODE (op0) == MEM && ! reload_in_progress)
  299.     {
  300.       emit_insn (gen_storehi (operands[0], force_reg (HImode, operands[1])));
  301.       DONE;
  302.     }
  303. }")
  304.  
  305. (define_insn ""
  306.   [(set (match_operand:HI 0 "register_operand" "=b")
  307.     (match_operand:HI 1 "symbolic_memory_operand" "m"))]
  308.   ""
  309.   "loadha %0,%1"
  310.   [(set_attr "type" "load")])
  311.  
  312. (define_insn ""
  313.   [(set (match_operand:HI 0 "reg_or_nonsymb_mem_operand" "=r,r,r,r,r,b,Q")
  314.     (match_operand:HI 1 "romp_operand" "r,I,n,s,Q,m,r"))]
  315.   "register_operand (operands[0], HImode)
  316.    || register_operand (operands[1], HImode)"
  317.   "@
  318.    cas %0,%1,r0
  319.    lis %0,%1
  320.    cal %0,%L1(r0)
  321.    get %0,$%1
  322.    lh%N1 %0,%1
  323.    loadh %0,%1
  324.    sth%M0 %1,%0"
  325.   [(set_attr "type" "address,address,address,misc,loadz,loadz,store")
  326.    (set_attr "length" "2,2,4,8,*,*,*")])
  327.  
  328. (define_insn "storehi"
  329.   [(set (match_operand:HI 0 "memory_operand" "=Q,m")
  330.     (match_operand:HI 1 "register_operand" "r,r"))
  331.    (clobber (match_scratch:SI 2 "=X,&b"))]
  332.   ""
  333.   "@
  334.    sth%M0 %1,%0
  335.    storeh %1,%0,%2"
  336.   [(set_attr "type" "store")])
  337.  
  338. ;; For DI move, if we have a constant, break the operation apart into
  339. ;; two SImode moves because the optimizer may be able to do a better job
  340. ;; with the resulting code.
  341. ;;
  342. ;; For memory stores, make the required pseudo for a temporary in case we
  343. ;; are storing into an absolute address.
  344. (define_expand "movdi"
  345.   [(set (match_operand:DI 0 "general_operand" "")
  346.     (match_operand:DI 1 "general_operand" ""))]
  347.   ""
  348.   "
  349. { rtx op0 = operands[0];
  350.   rtx op1 = operands[1];
  351.  
  352.   if (CONSTANT_P (op1))
  353.     {
  354.       rtx seq;
  355.  
  356.       start_sequence ();
  357.       emit_move_insn (operand_subword (op0, 0, 1, DImode),
  358.               operand_subword (op1, 0, 1, DImode));
  359.       emit_move_insn (operand_subword (op0, 1, 1, DImode),
  360.               operand_subword (op1, 1, 1, DImode));
  361.       seq = gen_sequence ();
  362.       end_sequence ();
  363.  
  364.       emit_no_conflict_block (seq, op0, op1, 0, op1);
  365.       DONE;
  366.     }
  367.  
  368.   if (GET_CODE (op0) == MEM && ! reload_in_progress)
  369.     {
  370.       emit_insn (gen_storedi (operands[0], force_reg (DImode, operands[1])));
  371.       DONE;
  372.     }
  373. }")
  374.  
  375. (define_insn ""
  376.  [(set (match_operand:DI 0 "reg_or_nonsymb_mem_operand" "=r,r,r,Q")
  377.        (match_operand:DI 1 "reg_or_mem_operand" "r,Q,m,r"))]
  378.   "register_operand (operands[0], DImode)
  379.    || register_operand (operands[1], DImode)"
  380.   "*
  381. {
  382.   switch (which_alternative)
  383.     {
  384.     case 0:
  385.       return \"cas %0,%1,r0\;cas %O0,%O1,r0\";
  386.     case 1:
  387.       /* Here we must see which word to load first.  We default to the
  388.      low-order word unless it occurs in the address.  */
  389.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  390.                  operands[1], 0))
  391.     return \"l%M1 %O0,%O1\;l%M1 %0,%1\";
  392.       else
  393.     return \"l%M1 %0,%1\;l%M1 %O0,%O1\";
  394.     case 2:
  395.       return \"get %O0,$%1\;ls %0,0(%O0)\;ls %O0,4(%O0)\";
  396.     case 3:
  397.       return \"st%M0 %1,%0\;st%M0 %O1,%O0\";
  398.     }
  399. }"
  400.   [(set_attr "type" "multi")
  401.    (set_attr "cc" "change0,change0,change0,none")
  402.    (set_attr "length" "4,12,8,8")])
  403.  
  404. (define_insn "storedi"
  405.   [(set (match_operand:DI 0 "memory_operand" "=Q,m")
  406.     (match_operand:DI 1 "register_operand" "r,r"))
  407.    (clobber (match_scratch:SI 2 "=X,&b"))]
  408.   ""
  409.   "@
  410.    st%M0 %1,%0\;st%M0 %O1,%O0
  411.    get %2,$%0\;sts %1,0(%2)\;sts %O1,4(%2)"
  412.   [(set_attr "type" "multi,multi")
  413.    (set_attr "cc" "none,none")
  414.    (set_attr "length" "8,12")])
  415.  
  416. ;; Split symbolic memory operands differently.  We first load the address
  417. ;; into a register and then do the two loads or stores.  We can only do
  418. ;; this if operand_subword won't produce a SUBREG, which is only when
  419. ;; operands[0] is a hard register.  Thus, these won't be used during the
  420. ;; first insn scheduling pass.
  421. (define_split
  422.   [(set (match_operand:DI 0 "register_operand" "")
  423.     (match_operand:DI 1 "symbolic_memory_operand" ""))]
  424.   "GET_CODE (operands[0]) == REG
  425.    && REGNO (operands[0]) < FIRST_PSEUDO_REGISTER"
  426.   [(set (match_dup 2) (match_dup 3))
  427.    (set (match_dup 4) (match_dup 5))
  428.    (set (match_dup 6) (match_dup 7))]
  429.   "
  430. { operands[2] = operand_subword (operands[0], 1, 0, DImode);
  431.   operands[3] = XEXP (operands[1], 0);
  432.   operands[4] = operand_subword (operands[0], 0, 0, DImode);
  433.   operands[5] = gen_rtx (MEM, SImode, operands[2]);
  434.   operands[6] = operands[2];
  435.   operands[7] = gen_rtx (MEM, SImode,
  436.              gen_rtx (PLUS, SImode, operands[2],
  437.                   gen_rtx (CONST_INT, VOIDmode, 4)));
  438.  
  439.   if (operands[2] == 0 || operands[4] == 0)
  440.     FAIL;
  441. }")
  442.  
  443. (define_split
  444.   [(set (match_operand:DI 0 "symbolic_memory_operand" "")
  445.     (match_operand:DI 1 "register_operand" ""))
  446.    (clobber (match_operand:SI 2 "register_operand" ""))] 
  447.   "GET_CODE (operands[0]) == REG
  448.    && REGNO (operands[0]) < FIRST_PSEUDO_REGISTER"
  449.   [(set (match_dup 2) (match_dup 3))
  450.    (set (match_dup 4) (match_dup 5))
  451.    (set (match_dup 6) (match_dup 7))]
  452.   "
  453. { operands[3] = XEXP (operands[0], 0);
  454.   operands[4] = gen_rtx (MEM, SImode, operands[2]);
  455.   operands[5] = operand_subword (operands[1], 0, 0, DImode);
  456.   operands[6] = gen_rtx (MEM, SImode,
  457.              gen_rtx (PLUS, SImode, operands[2],
  458.                   gen_rtx (CONST_INT, VOIDmode, 4)));
  459.   operands[7] = operand_subword (operands[1], 1, 0, DImode);
  460.  
  461.   if (operands[5] == 0 || operands[7] == 0)
  462.     FAIL;
  463. }")
  464.  
  465. ;; If the output is a register and the input is memory, we have to be careful
  466. ;; and see which word needs to be loaded first.
  467. (define_split
  468.   [(set (match_operand:DI 0 "general_operand" "")
  469.     (match_operand:DI 1 "general_operand" ""))]
  470.   "! symbolic_memory_operand (operands[0], DImode)
  471.    && ! symbolic_memory_operand (operands[1], DImode)
  472.    && ! (GET_CODE (operands[0]) == REG
  473.          && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
  474.    && ! (GET_CODE (operands[1]) == REG
  475.          && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)"
  476.   [(set (match_dup 2) (match_dup 3))
  477.    (set (match_dup 4) (match_dup 5))]
  478.   "
  479. { if (GET_CODE (operands[0]) != REG
  480.       || ! refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  481.                   operands[1], 0))
  482.     {
  483.       operands[2] = operand_subword (operands[0], 0, 0, DImode);
  484.       operands[3] = operand_subword (operands[1], 0, 0, DImode);
  485.       operands[4] = operand_subword (operands[0], 1, 0, DImode);
  486.       operands[5] = operand_subword (operands[1], 1, 0, DImode);
  487.     }
  488.   else
  489.     {
  490.       operands[2] = operand_subword (operands[0], 1, 0, DImode);
  491.       operands[3] = operand_subword (operands[1], 1, 0, DImode);
  492.       operands[4] = operand_subword (operands[0], 0, 0, DImode);
  493.       operands[5] = operand_subword (operands[1], 0, 0, DImode);
  494.     }
  495.  
  496.   if (operands[2] == 0 || operands[3] == 0
  497.       || operands[4] == 0 || operands[5] == 0)
  498.     FAIL;
  499. }")
  500.  
  501. (define_split
  502.  [(set (match_operand:DI 0 "general_operand" "")
  503.        (match_operand:DI 1 "general_operand" ""))
  504.   (clobber (match_operand:SI 6 "register_operand" ""))]
  505.   "! symbolic_memory_operand (operands[0], DImode)
  506.    && ! symbolic_memory_operand (operands[1], DImode)
  507.    && ! (GET_CODE (operands[0]) == REG
  508.          && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
  509.    && ! (GET_CODE (operands[1]) == REG
  510.          && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)"
  511.  [(parallel [(set (match_dup 2) (match_dup 3))
  512.          (clobber (match_dup 6))])
  513.   (parallel [(set (match_dup 4) (match_dup 5))
  514.          (clobber (match_dup 6))])]
  515.  "
  516. { operands[2] = operand_subword (operands[0], 0, 0, DImode);
  517.   operands[3] = operand_subword (operands[1], 0, 0, DImode);
  518.   operands[4] = operand_subword (operands[0], 1, 0, DImode);
  519.   operands[5] = operand_subword (operands[1], 1, 0, DImode);
  520.  
  521.   if (operands[2] == 0 || operands[3] == 0
  522.       || operands[4] == 0 || operands[5] == 0)
  523.     FAIL;
  524. }")
  525.  
  526. ;; Define move insns for SF, and DF.
  527. ;;
  528. ;; For register-register copies or a copy of something to itself, emit a
  529. ;; single SET insn since it will likely be optimized away.
  530. ;;
  531. ;; Otherwise, emit a floating-point move operation unless both input and
  532. ;; output are either constant, memory, or a non-floating-point hard register.
  533. (define_expand "movdf"
  534.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  535.            (match_operand:DF 1 "general_operand" ""))
  536.           (clobber (reg:SI 0))
  537.           (clobber (reg:SI 15))])]
  538.   ""
  539.   "
  540. { rtx op0 = operands[0];
  541.   rtx op1 = operands[1];
  542.  
  543.   if (op0 == op1)
  544.     {
  545.       emit_insn (gen_rtx (SET, VOIDmode, op0, op1));
  546.       DONE;
  547.     }
  548.  
  549.   if ((GET_CODE (op0) == MEM
  550.        || (GET_CODE (op0) == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER
  551.        && ! FP_REGNO_P (REGNO (op0))))
  552.       && (GET_CODE (op1) == MEM
  553.       || GET_CODE (op1) == CONST_DOUBLE
  554.       || (GET_CODE (op1) == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER
  555.           && ! FP_REGNO_P (REGNO (op1)) && ! rtx_equal_p (op0, op1))))
  556.     {
  557.       rtx seq;
  558.  
  559.       if (GET_CODE (op1) == CONST_DOUBLE)
  560.     op1 = force_const_mem (DFmode, op1);
  561.  
  562.       start_sequence ();
  563.       emit_move_insn (operand_subword (op0, 0, 1, DFmode),
  564.               operand_subword_force (op1, 0, DFmode));
  565.       emit_move_insn (operand_subword (op0, 1, 1, DFmode),
  566.               operand_subword_force (op1, 1, DFmode));
  567.       seq = gen_sequence ();
  568.       end_sequence ();
  569.  
  570.       emit_no_conflict_block (seq, op0, op1, 0, op1);
  571.       DONE;
  572.     }
  573. }")
  574.  
  575. (define_expand "movsf"
  576.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  577.            (match_operand:SF 1 "general_operand" ""))
  578.           (clobber (reg:SI 0))
  579.           (clobber (reg:SI 15))])]
  580.   ""
  581.   "
  582. { rtx op0 = operands[0];
  583.   rtx op1 = operands[1];
  584.   
  585.   if (op0 == op1)
  586.     {
  587.       emit_insn (gen_rtx (SET, VOIDmode, op0, op1));
  588.       DONE;
  589.     }
  590.  
  591.   if ((GET_CODE (op0) == MEM
  592.        || (GET_CODE (op0) == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER
  593.        && ! FP_REGNO_P (REGNO (op0))))
  594.        && (GET_CODE (op1) == MEM
  595.        || GET_CODE (op1) == CONST_DOUBLE
  596.        || (GET_CODE (op1) == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER
  597.            && ! FP_REGNO_P (REGNO (op1)))))
  598.     {
  599.       rtx last;
  600.  
  601.       if (GET_CODE (op1) == CONST_DOUBLE)
  602.     op1 = force_const_mem (SFmode, op1);
  603.  
  604.       last = emit_move_insn (operand_subword (op0, 0, 1, SFmode),
  605.                  operand_subword_force (op1, 0, SFmode));
  606.  
  607.       REG_NOTES (last) = gen_rtx (EXPR_LIST, REG_EQUAL, op1, REG_NOTES (last));
  608.       DONE;
  609.     }
  610. }")
  611.  
  612. ;; Define the move insns for SF and DF.  Check for all general regs
  613. ;; in the FP insns and make them non-FP if so.  Do the same if the input and
  614. ;; output are the same (the insn will be deleted in this case and we don't
  615. ;; want to think there are FP insns when there might not be).
  616. (define_insn ""
  617.   [(set (match_operand:SF 0 "general_operand" "=*frg")
  618.     (match_dup 0))]
  619.   ""
  620.   "nopr r0"
  621.   [(set_attr "type" "address")
  622.    (set_attr "length" "2")])
  623.  
  624. (define_insn ""
  625.   [(set (match_operand:SF 0 "general_operand" "=r,*fr,r,r,Q,m,frg")
  626.     (match_operand:SF 1 "general_operand" "r,0,Q,m,r,r,frg"))
  627.    (clobber (match_operand:SI 2 "reg_0_operand" "=&z,z,z,z,z,z,z"))
  628.    (clobber (match_operand:SI 3 "reg_15_operand" "=&t,t,t,t,t,t,t"))]
  629.   ""
  630.   "*
  631. { switch (which_alternative)
  632.     {
  633.     case 0:
  634.       return \"cas %0,%1,r0\";
  635.     case 1:
  636.       return \"nopr r0\";
  637.     case 2:
  638.       return \"l%M1 %0,%1\";
  639.     case 3:
  640.       return \"load %0,%1\";
  641.     case 4:
  642.       return \"st%M0 %1,%0\";
  643.     case 5:
  644.       return \"store %1,%0,%3\";
  645.     default:
  646.       return output_fpop (SET, operands[0], operands[1], 0, insn);
  647.     }
  648. }"
  649.   [(set_attr "type" "address,address,load,load,store,store,fp")
  650.    (set_attr "length" "2,2,*,*,*,*,*")])
  651.  
  652. (define_insn ""
  653.   [(set (match_operand:DF 0 "general_operand" "=*frg")
  654.     (match_dup 0))]
  655.   ""
  656.   "nopr r0"
  657.   [(set_attr "type" "address")
  658.    (set_attr "length" "2")])
  659.  
  660. (define_insn ""
  661.   [(set (match_operand:DF 0 "general_operand" "=r,*fr,r,r,Q,m,frg")
  662.     (match_operand:DF 1 "general_operand" "r,0,Q,m,r,r,*frg"))
  663.    (clobber (match_operand:SI 2 "reg_0_operand" "=&z,z,z,z,z,z,z"))
  664.    (clobber (match_operand:SI 3 "reg_15_operand" "=&t,t,t,t,t,t,t"))]
  665.   ""
  666.   "*
  667. { switch (which_alternative)
  668.     {
  669.     case 0:
  670.       return \"cas %0,%1,r0\;cas %O0,%O1,r0\";
  671.     case 1:
  672.       return \"nopr r0\";
  673.     case 2:
  674.       /* Here we must see which word to load first.  We default to the
  675.      low-order word unless it occurs in the address.  */
  676.       if (refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  677.                  operands[1], 0))
  678.     return \"l%M1 %O0,%O1\;l%M1 %0,%1\";
  679.       else
  680.     return \"l%M1 %0,%1\;l%M1 %O0,%O1\";
  681.     case 3:
  682.       return \"get %3,$%1\;ls %0,0(%3)\;ls %O0,4(%3)\";
  683.     case 4:
  684.       return \"st%M0 %1,%0\;st%M0 %O1,%O0\";
  685.     case 5:
  686.       return \"get %3,$%0\;sts %1,0(%3)\;sts %O1,4(%3)\";
  687.     default:
  688.       return output_fpop (SET, operands[0], operands[1], 0, insn);
  689.     }
  690. }"
  691.   [(set_attr "type" "address,multi,multi,multi,multi,multi,fp")
  692.    (set_attr "length" "2,4,*,*,*,*,*")])
  693.  
  694. ;; Split all the above cases that involve multiple insns and no floating-point
  695. ;; data block.
  696. (define_split
  697.   [(set (match_operand:DF 0 "register_operand" "")
  698.     (match_operand:DF 1 "symbolic_memory_operand" ""))
  699.    (clobber (reg:SI 0))
  700.    (clobber (reg:SI 15))]
  701.   "GET_CODE (operands[0]) == REG && REGNO (operands[0]) < 16"
  702.   [(set (reg:SI 15) (match_dup 2))
  703.    (set (match_dup 3) (match_dup 4))
  704.    (set (match_dup 5) (match_dup 6))]
  705.   "
  706. { operands[2] = XEXP (operands[1], 0);
  707.   operands[3] = operand_subword (operands[0], 0, 0, DFmode);
  708.   operands[4] = gen_rtx (MEM, SImode, gen_rtx (REG, SImode, 15));
  709.   operands[5] = operand_subword (operands[0], 0, 1, DFmode);
  710.   operands[6] = gen_rtx (MEM, SImode,
  711.              gen_rtx (PLUS, SImode, gen_rtx (REG, SImode, 15),
  712.                   gen_rtx (CONST_INT, VOIDmode, 4)));
  713.  
  714.   if (operands[3] == 0 || operands[5] == 0)
  715.     FAIL;
  716. }")
  717.  
  718. (define_split
  719.   [(set (match_operand:DF 0 "symbolic_memory_operand" "")
  720.     (match_operand:DF 1 "register_operand" ""))
  721.    (clobber (reg:SI 0))
  722.    (clobber (reg:SI 15))]
  723.   "GET_CODE (operands[1]) == REG && REGNO (operands[1]) < 16"
  724.   [(set (reg:SI 15) (match_dup 2))
  725.    (set (match_dup 3) (match_dup 4))
  726.    (set (match_dup 5) (match_dup 6))]
  727.   "
  728. { operands[2] = XEXP (operands[0], 0);
  729.   operands[3] = gen_rtx (MEM, SImode, gen_rtx (REG, SImode, 15));
  730.   operands[4] = operand_subword (operands[1], 0, 0, DFmode);
  731.   operands[5] = gen_rtx (MEM, SImode,
  732.              gen_rtx (PLUS, SImode, gen_rtx (REG, SImode, 15),
  733.                   gen_rtx (CONST_INT, VOIDmode, 4)));
  734.   operands[6] = operand_subword (operands[1], 1, 0, DFmode);
  735.  
  736.   if (operands[4] == 0 || operands[6] == 0)
  737.     FAIL;
  738. }")
  739.  
  740. ;; If the output is a register and the input is memory, we have to be careful
  741. ;; and see which word needs to be loaded first.  We also cannot to the
  742. ;; split if the input is a constant because it would result in invalid
  743. ;; insns.
  744. (define_split
  745.   [(set (match_operand:DF 0 "general_operand" "")
  746.     (match_operand:DF 1 "general_operand" ""))
  747.    (clobber (reg:SI 0))
  748.    (clobber (reg:SI 15))]
  749.   "! symbolic_memory_operand (operands[0], DFmode)
  750.    && ! symbolic_memory_operand (operands[1], DFmode)
  751.    && GET_CODE (operands[1]) != CONST_DOUBLE
  752.    && (GET_CODE (operands[0]) != REG || REGNO (operands[0]) < 15)
  753.    && (GET_CODE (operands[1]) != REG || REGNO (operands[1]) < 15)
  754.    && (GET_CODE (operands[0]) == REG || GET_CODE (operands[1]) == REG)"
  755.   [(set (match_dup 2) (match_dup 3))
  756.    (set (match_dup 4) (match_dup 5))]
  757.   "
  758. { if (GET_CODE (operands[0]) != REG
  759.       || ! refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
  760.                   operands[1], 0))
  761.     {
  762.       operands[2] = operand_subword (operands[0], 0, 0, DFmode);
  763.       operands[3] = operand_subword (operands[1], 0, 0, DFmode);
  764.       operands[4] = operand_subword (operands[0], 1, 0, DFmode);
  765.       operands[5] = operand_subword (operands[1], 1, 0, DFmode);
  766.     }
  767.   else
  768.     {
  769.       operands[2] = operand_subword (operands[0], 1, 0, DFmode);
  770.       operands[3] = operand_subword (operands[1], 1, 0, DFmode);
  771.       operands[4] = operand_subword (operands[0], 0, 0, DFmode);
  772.       operands[5] = operand_subword (operands[1], 0, 0, DFmode);
  773.     }
  774.  
  775.   if (operands[2] == 0 || operands[3] == 0
  776.       || operands[4] == 0 || operands[5] == 0)
  777.     FAIL;
  778. }")
  779.  
  780. ;; Conversions from one integer mode to another.
  781. ;; It is possible sometimes to sign- or zero-extend while fetching from memory.
  782. ;;
  783. ;; First, sign-extensions:
  784. (define_insn ""
  785.   [(set (match_operand:SI 0 "register_operand" "=b")
  786.     (sign_extend:SI (match_operand:HI 1 "symbolic_memory_operand" "m")))]
  787.   ""
  788.   "loadha %0,%1"
  789.   [(set_attr "type" "load")])
  790.  
  791. (define_insn "extendhisi2"
  792.   [(set (match_operand:SI 0 "register_operand" "=r,r,b")
  793.     (sign_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,Q,m")))]
  794.   ""
  795.   "@
  796.    exts %0,%1
  797.    lha%M1 %0,%1
  798.    loadha %0,%1"
  799.   [(set_attr "type" "arith,load,load")
  800.    (set_attr "length" "2,*,*")])
  801.  
  802. (define_expand "extendqisi2"
  803.   [(set (match_dup 2)
  804.     (ashift:SI (match_operand:QI 1 "register_operand" "")
  805.            (const_int 24)))
  806.    (set (match_operand:SI 0 "register_operand" "")
  807.     (ashiftrt:SI (match_dup 2)
  808.              (const_int 24)))]
  809.   ""
  810.   "
  811. { operands[1] = gen_lowpart (SImode, operands[1]);
  812.   operands[2] = gen_reg_rtx (SImode); }")
  813.  
  814. (define_expand "extendqihi2"
  815.   [(set (match_dup 2)
  816.     (ashift:SI (match_operand:QI 1 "register_operand" "")
  817.            (const_int 24)))
  818.    (set (match_operand:HI 0 "register_operand" "")
  819.     (ashiftrt:SI (match_dup 2)
  820.              (const_int 24)))]
  821.   ""
  822.   "
  823. { operands[0] = gen_lowpart (SImode, operands[0]);
  824.   operands[1] = gen_lowpart (SImode, operands[1]);
  825.   operands[2] = gen_reg_rtx (SImode); }")
  826.  
  827. ;; Define peepholes to eliminate an instruction when we are doing a sign
  828. ;; extension but cannot clobber the input.
  829. ;;
  830. ;; In this case we will shift left 24 bits, but need a copy first.  The shift
  831. ;; can be replaced by a "mc03" instruction, but this can only be done if
  832. ;; followed by the right shift of 24 or more bits.
  833. (define_peephole
  834.   [(set (match_operand:SI 0 "register_operand" "")
  835.     (subreg:SI (match_operand:QI 1 "register_operand" "") 0))
  836.    (set (match_dup 0)
  837.     (ashift:SI (match_dup 0)
  838.            (const_int 24)))
  839.    (set (match_dup 0)
  840.     (ashiftrt:SI (match_dup 0)
  841.              (match_operand:SI 2 "const_int_operand" "")))]
  842.   "INTVAL (operands[2]) >= 24"
  843.   "mc03 %0,%1\;sari16 %0,%S2"
  844.  [(set_attr "type" "multi")
  845.   (set_attr "length" "4")
  846.   (set_attr "cc" "sets")])
  847.  
  848. ;; Now zero extensions:
  849. (define_insn ""
  850.   [(set (match_operand:SI 0 "register_operand" "=b")
  851.     (zero_extend:SI (match_operand:HI 1 "symbolic_memory_operand" "m")))]
  852.   ""
  853.   "loadh %0,%1"
  854.   [(set_attr "type" "load")])
  855.  
  856. (define_insn "zero_extendhisi2"
  857.   [(set (match_operand:SI 0 "register_operand" "=r,r,b")
  858.     (zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,Q,m")))]
  859.   ""
  860.   "@
  861.    nilz %0,%1,65535
  862.    lh%N1 %0,%1
  863.    loadh %0,%1"
  864.   [(set_attr "type" "arith,loadz,load")])
  865.  
  866. (define_insn ""
  867.   [(set (match_operand:SI 0 "register_operand" "=b")
  868.     (zero_extend:SI (match_operand:QI 1 "symbolic_memory_operand" "m")))]
  869.   ""
  870.   "loadc %0,%1"
  871.   [(set_attr "type" "load")])
  872.  
  873. (define_insn "zero_extendqisi2"
  874.   [(set (match_operand:SI 0 "register_operand" "=r,r,b")
  875.     (zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "r,Q,m")))]
  876.   ""
  877.   "@
  878.    nilz %0,%1,255
  879.    lc%M1 %0,%1
  880.    loadc %0,%1"
  881.   [(set_attr "type" "arith,load,load")])
  882.  
  883. (define_insn ""
  884.   [(set (match_operand:HI 0 "register_operand" "=b")
  885.     (zero_extend:HI (match_operand:QI 1 "symbolic_memory_operand" "m")))]
  886.   ""
  887.   "loadc %0,%1"
  888.   [(set_attr "type" "load")])
  889.  
  890. (define_insn "zero_extendqihi2"
  891.   [(set (match_operand:HI 0 "register_operand" "=r,r,b")
  892.     (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "r,Q,m")))]
  893.   ""
  894.   "@
  895.    nilz %0,%1,255
  896.    lc%M1 %0,%1
  897.    loadc %0,%1"
  898.   [(set_attr "type" "arith,load,load")])
  899.  
  900. ;; Various extract and insertion operations.
  901. (define_expand "extzv"
  902.   [(set (match_operand:SI 0 "register_operand" "")
  903.     (zero_extract:SI (match_operand:SI 1 "register_operand" "")
  904.              (match_operand:SI 2 "const_int_operand" "")
  905.              (match_operand:SI 3 "const_int_operand" "")))]
  906.   ""
  907.   "
  908. {
  909.   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) != 8)
  910.     FAIL;
  911.  
  912.   if (GET_CODE (operands[3]) != CONST_INT)
  913.     FAIL;
  914.  
  915.   if (INTVAL (operands[3]) != 0 && INTVAL (operands[3]) != 8
  916.       && INTVAL (operands[3]) != 16 && INTVAL (operands[3]) != 24)
  917.     FAIL;
  918. }")
  919.  
  920. (define_insn ""
  921.   [(set (match_operand:SI 0 "register_operand" "=&r")
  922.     (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  923.              (const_int 8)
  924.              (match_operand:SI 2 "const_int_operand" "n")))]
  925.   "(INTVAL (operands[2]) & 7) == 0"
  926.   "lis %0,0\;mc3%B2 %0,%1"
  927.   [(set_attr "type" "multi")
  928.    (set_attr "cc" "change0")])
  929.  
  930. (define_split
  931.   [(set (match_operand:SI 0 "register_operand" "=&r")
  932.     (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  933.              (const_int 8)
  934.              (match_operand:SI 2 "const_int_operand" "n")))]
  935.   "(INTVAL (operands[2]) & 7) == 0"
  936.   [(set (match_dup 0) (const_int 0))
  937.    (set (zero_extract:SI (match_dup 0) (const_int 8) (const_int 24))
  938.     (zero_extract:SI (match_dup 1) (const_int 8) (match_dup 2)))]
  939.   "")
  940.  
  941. (define_insn ""
  942.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
  943.              (const_int 8)
  944.              (const_int 24))
  945.     (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
  946.              (const_int 8)
  947.              (match_operand:SI 2 "const_int_operand" "n")))]
  948.   "(INTVAL (operands[2]) & 7) == 0"
  949.   "mc3%B2 %0,%1"
  950.   [(set_attr "type" "address")
  951.    (set_attr "length" "2")])
  952.  
  953. (define_expand "insv"
  954.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "")
  955.              (match_operand:SI 1 "const_int_operand" "")
  956.              (match_operand:SI 2 "const_int_operand" ""))
  957.     (match_operand:SI 3 "register_operand" ""))]
  958.   ""
  959.   "
  960. {
  961.   if (GET_CODE (operands[2]) != CONST_INT)
  962.     FAIL;
  963.  
  964.   if (GET_CODE (operands[1]) != CONST_INT)
  965.     FAIL;
  966.  
  967.   if (INTVAL (operands[1]) == 1)
  968.     {
  969.       emit_insn (gen_bit_insv (operands[0], operands[1], operands[2],
  970.                    operands[3]));
  971.       DONE;
  972.     }
  973.   else if (INTVAL (operands[1]) == 8
  974.        && (INTVAL (operands[2]) % 8 == 0))
  975.     ;                /* Accept aligned byte-wide field. */
  976.   else
  977.     FAIL;
  978. }")
  979.  
  980. ;; For a single-bit insert, it is better to explicitly generate references
  981. ;; to the T bit.  We will call the T bit "CC0" because it can be clobbered
  982. ;; by some CC0 sets (single-bit tests).
  983.  
  984. (define_expand "bit_insv"
  985.   [(set (cc0)
  986.     (zero_extract:SI (match_operand:SI 3 "register_operand" "")
  987.              (const_int 1)
  988.              (const_int 31)))
  989.   (set (zero_extract:SI (match_operand:SI 0 "register_operand" "")
  990.             (match_operand:SI 1 "const_int_operand" "")
  991.             (match_operand:SI 2 "const_int_operand" ""))
  992.        (ne (cc0) (const_int 0)))]
  993.   ""
  994.   "")
  995.     
  996. (define_insn ""
  997.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
  998.              (const_int 8)
  999.              (match_operand:SI 1 "const_int_operand" "n"))
  1000.     (match_operand:SI 2 "register_operand" "r"))]
  1001.   "(INTVAL (operands[1]) & 7) == 0"
  1002.   "mc%B1%.3 %0,%2"
  1003.   [(set_attr "type" "address")
  1004.    (set_attr "length" "2")])
  1005.  
  1006. (define_insn ""
  1007.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
  1008.              (const_int 1)
  1009.              (match_operand:SI 1 "const_int_operand" "n"))
  1010.     (ne (cc0) (const_int 0)))]
  1011.   ""
  1012.   "mftbi%t1 %0,%S1"
  1013.   [(set_attr "cc" "none")
  1014.    (set_attr "length" "2")])
  1015.  
  1016. ;; Arithmetic instructions.  First, add and subtract.
  1017. ;;
  1018. ;; It may be that the second input is either large or small enough that
  1019. ;; the operation cannot be done in a single insn.  In that case, emit two.
  1020. (define_expand "addsi3"
  1021.   [(set (match_operand:SI 0 "register_operand" "")
  1022.     (plus:SI (match_operand:SI 1 "register_operand" "")
  1023.          (match_operand:SI 2 "nonmemory_operand" "")))]
  1024.   ""
  1025.   "
  1026. {
  1027.   if (GET_CODE (operands[2]) == CONST_INT
  1028.       && (unsigned) (INTVAL (operands[2]) + 0x8000) >= 0x10000
  1029.       && (INTVAL (operands[2]) & 0xffff) != 0)
  1030.     {
  1031.       int low = INTVAL (operands[2]) & 0xffff;
  1032.       int high = (unsigned) INTVAL (operands[2]) >> 16;
  1033.  
  1034.       if (low & 0x8000)
  1035.     high++, low |= 0xffff0000;
  1036.  
  1037.       emit_insn (gen_addsi3 (operands[0], operands[1],
  1038.                  gen_rtx (CONST_INT, VOIDmode, high << 16)));
  1039.       operands[1] = operands[0];
  1040.       operands[2] = gen_rtx (CONST_INT, VOIDmode, low);
  1041.     }
  1042. }")
  1043.  
  1044. ;; Put the insn to add a symbolic constant to a register separately to
  1045. ;; improve register allocation since it has different register requirements.
  1046. (define_insn ""
  1047.   [(set (match_operand:SI 0 "register_operand" "=b")
  1048.     (plus:SI (match_operand:SI 1 "register_operand" "%b")
  1049.          (match_operand:SI 2 "symbolic_operand" "s")))]
  1050.    ""
  1051.    "get %0,$%2(%1)"
  1052.    [(set_attr "type" "address")
  1053.     (set_attr "length" "8")])
  1054.  
  1055. (define_insn ""
  1056.   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,r,r,b")
  1057.     (plus:SI (match_operand:SI 1 "reg_or_add_operand" "%0,0,r,b,0,r,b")
  1058.          (match_operand:SI 2 "reg_or_add_operand" "I,J,K,M,r,b,s")))]
  1059.   "register_operand (operands[1], SImode)
  1060.    || register_operand (operands[2], SImode)"
  1061.   "@
  1062.    ais %0,%2
  1063.    sis %0,%n2
  1064.    ail %0,%1,%2
  1065.    cau %0,%H2(%1)
  1066.    a %0,%2
  1067.    cas %0,%1,%2
  1068.    get %0,$%2(%1)"
  1069.   [(set_attr "type" "arith,arith,arith,address,arith,address,misc")
  1070.    (set_attr "length" "2,2,4,4,2,2,8")])
  1071.  
  1072. ;; Now subtract.
  1073. ;;
  1074. ;; 1.    If third operand is constant integer, convert it to add of the negative
  1075. ;;    of that integer.
  1076. ;; 2.    If the second operand is not a valid constant integer, force it into a
  1077. ;;    register.
  1078. (define_expand "subsi3"
  1079.   [(set (match_operand:SI 0 "register_operand" "")
  1080.     (minus:SI (match_operand:SI 1 "reg_or_any_cint_operand" "")
  1081.           (match_operand:SI 2 "reg_or_any_cint_operand" "")))]
  1082.   ""
  1083.   "
  1084. {
  1085.   if (GET_CODE (operands [2]) == CONST_INT)
  1086.     {
  1087.       emit_insn (gen_addsi3 (operands[0], operands[1], 
  1088.                  gen_rtx (CONST_INT,
  1089.                       VOIDmode, - INTVAL (operands[2]))));
  1090.       DONE;
  1091.     }
  1092.   else
  1093.     operands[2] = force_reg (SImode, operands[2]);
  1094.  
  1095.   if (GET_CODE (operands[1]) != CONST_INT
  1096.       || (unsigned) (INTVAL (operands[1]) + 0x8000) >= 0x10000)
  1097.     operands[1] = force_reg (SImode, operands[1]);
  1098. }")
  1099.  
  1100. (define_insn ""
  1101.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  1102.     (minus:SI (match_operand:SI 1 "reg_or_D_operand" "K,0,r")
  1103.           (match_operand:SI 2 "register_operand" "r,r,0")))]
  1104.   ""
  1105.   "@
  1106.    sfi %0,%2,%1
  1107.    s %0,%2
  1108.    sf %0,%1"
  1109.   [(set_attr "length" "4,2,2")])
  1110.  
  1111. ;; Multiply either calls a special RT routine or is done in-line, depending
  1112. ;; on the value of a -m flag.
  1113. ;;
  1114. ;; First define the way we call the subroutine.
  1115. (define_expand "mulsi3_subr"
  1116.   [(set (reg:SI 2) (match_operand:SI 1 "register_operand" ""))
  1117.    (set (reg:SI 3) (match_operand:SI 2 "register_operand" ""))
  1118.    (parallel [(set (reg:SI 2) (mult:SI (reg:SI 2) (reg:SI 3)))
  1119.           (clobber (reg:SI 0))
  1120.           (clobber (reg:SI 15))])
  1121.    (set (match_operand:SI 0 "register_operand" "")
  1122.     (reg:SI 2))]
  1123.   ""
  1124.   "")
  1125.  
  1126. (define_expand "mulsi3"
  1127.   [(set (match_operand:SI 0 "register_operand" "")
  1128.     (mult:SI (match_operand:SI 1 "register_operand" "")
  1129.          (match_operand:SI 2 "register_operand" "")))]
  1130.   ""
  1131.   "
  1132. {
  1133.   if (! TARGET_IN_LINE_MUL)
  1134.     {
  1135.       emit_insn (gen_mulsi3_subr (operands[0], operands[1], operands[2]));
  1136.       DONE;
  1137.     }
  1138. }")
  1139.  
  1140. ;; Define the patterns to match.
  1141. ;; We would like to provide a delay slot for the insns that call internal
  1142. ;; routines, but doing so is risky since reorg will think that the use of
  1143. ;; r2 and r3 is completed in the insn needing the delay slot.  Also, it
  1144. ;; won't know that the cc will be clobbered.  So take the safe approach
  1145. ;; and don't give them delay slots.
  1146. (define_insn ""
  1147.   [(set (reg:SI 2)
  1148.     (mult:SI (reg:SI 2) (reg:SI 3)))
  1149.    (clobber (reg:SI 0))
  1150.    (clobber (reg:SI 15))]
  1151.   "! TARGET_IN_LINE_MUL"
  1152.   "bali%# r15,lmul$$"
  1153.   [(set_attr "type" "misc")
  1154.    (set_attr "in_delay_slot" "no")])
  1155.  
  1156. (define_insn ""
  1157.   [(set (match_operand:SI 0 "register_operand" "=&r")
  1158.     (mult:SI (match_operand:SI 1 "register_operand" "%r")
  1159.          (match_operand:SI 2 "register_operand" "r")))]
  1160.   "TARGET_IN_LINE_MUL"
  1161.   "*
  1162. { return output_in_line_mul (); }"
  1163.   [(set_attr "length" "38")
  1164.    (set_attr "type" "multi")])
  1165.  
  1166. ;; Handle divide and modulus.  The same function returns both values,
  1167. ;; so use divmodsi4.  This divides arg 1 by arg 2 with quotient to go
  1168. ;; into arg 0 and remainder in arg 3.
  1169. ;;
  1170. ;; We want to put REG_EQUAL notes for the two outputs.  So we need a
  1171. ;; function to do everything else.
  1172. (define_expand "divmodsi4_doit"
  1173.   [(set (reg:SI 2)
  1174.     (match_operand:SI 0 "register_operand" ""))
  1175.    (set (reg:SI 3)
  1176.     (match_operand:SI 1 "register_operand" ""))
  1177.    (parallel [(set (reg:SI 2) (div:SI (reg:SI 2) (reg:SI 3)))
  1178.           (set (reg:SI 3) (mod:SI (reg:SI 2) (reg:SI 3)))
  1179.           (clobber (reg:SI 0))
  1180.           (clobber (reg:SI 15))])]
  1181.   ""
  1182.   "")
  1183.  
  1184. (define_expand "divmodsi4"
  1185.   [(parallel [(set (match_operand:SI 0 "register_operand" "")
  1186.            (div:SI (match_operand:SI 1 "register_operand" "")
  1187.                (match_operand:SI 2 "register_operand" "")))
  1188.           (set (match_operand:SI 3 "register_operand" "")
  1189.            (mod:SI (match_dup 1) (match_dup 2)))])]
  1190.   ""
  1191.   "
  1192. {
  1193.   rtx insn;
  1194.  
  1195.   emit_insn (gen_divmodsi4_doit (operands[1], operands[2]));
  1196.   insn = emit_move_insn (operands[0], gen_rtx (REG, SImode, 2));
  1197.   REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
  1198.                   gen_rtx (DIV, SImode, operands[1],
  1199.                        operands[2]),
  1200.                   REG_NOTES (insn));
  1201.   insn = emit_move_insn (operands[3], gen_rtx (REG, SImode, 3));
  1202.   REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
  1203.                   gen_rtx (MOD, SImode, operands[1],
  1204.                        operands[2]),
  1205.                   REG_NOTES (insn));
  1206.   DONE;
  1207. }")
  1208.  
  1209. (define_insn ""
  1210.   [(set (reg:SI 2)
  1211.     (div:SI (reg:SI 2) (reg:SI 3)))
  1212.    (set (reg:SI 3)
  1213.     (mod:SI (reg:SI 2) (reg:SI 3)))
  1214.    (clobber (reg:SI 0))
  1215.    (clobber (reg:SI 15))]
  1216.   ""
  1217.   "bali%# r15,ldiv$$"
  1218.   [(set_attr "type" "misc")
  1219.    (set_attr "in_delay_slot" "no")])
  1220.  
  1221. ;; Similarly for unsigned divide.
  1222. (define_expand "udivmodsi4_doit"
  1223.   [(set (reg:SI 2)
  1224.     (match_operand:SI 0 "register_operand" ""))
  1225.    (set (reg:SI 3)
  1226.     (match_operand:SI 1 "register_operand" ""))
  1227.    (parallel [(set (reg:SI 2) (udiv:SI (reg:SI 2) (reg:SI 3)))
  1228.           (set (reg:SI 3) (umod:SI (reg:SI 2) (reg:SI 3)))
  1229.           (clobber (reg:SI 0))
  1230.           (clobber (reg:SI 15))])]
  1231.   ""
  1232.   "")
  1233.  
  1234. (define_expand "udivmodsi4"
  1235.   [(parallel [(set (match_operand:SI 0 "register_operand" "")
  1236.            (udiv:SI (match_operand:SI 1 "register_operand" "")
  1237.                 (match_operand:SI 2 "register_operand" "")))
  1238.           (set (match_operand:SI 3 "register_operand" "")
  1239.            (umod:SI (match_dup 1) (match_dup 2)))])]
  1240.   ""
  1241.   "
  1242. {
  1243.   rtx insn;
  1244.  
  1245.   emit_insn (gen_udivmodsi4_doit (operands[1], operands[2]));
  1246.   insn = emit_move_insn (operands[0], gen_rtx (REG, SImode, 2));
  1247.   REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
  1248.                   gen_rtx (UDIV, SImode, operands[1],
  1249.                        operands[2]),
  1250.                   REG_NOTES (insn));
  1251.   insn = emit_move_insn (operands[3], gen_rtx (REG, SImode, 3));
  1252.   REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
  1253.                   gen_rtx (UMOD, SImode, operands[1],
  1254.                        operands[2]),
  1255.                   REG_NOTES (insn));
  1256.   DONE;
  1257. }")
  1258.  
  1259. (define_insn ""
  1260.   [(set (reg:SI 2)
  1261.     (udiv:SI (reg:SI 2) (reg:SI 3)))
  1262.    (set (reg:SI 3)
  1263.     (umod:SI (reg:SI 2) (reg:SI 3)))
  1264.    (clobber (reg:SI 0))
  1265.    (clobber (reg:SI 15))]
  1266.   ""
  1267.   "bali%# r15,uldiv$$"
  1268.   [(set_attr "type" "misc")
  1269.    (set_attr "in_delay_slot" "no")])
  1270.  
  1271. ;; Define DImode arithmetic operations.
  1272. ;;
  1273. ;; It is possible to do certain adds and subtracts with constants in a single
  1274. ;; insn, but it doesn't seem worth the trouble.
  1275. ;;
  1276. ;; Don't use DEFINE_SPLIT on these because the dependency on CC can't be
  1277. ;; easily tracked in that case!
  1278. (define_insn "adddi3"
  1279.   [(set (match_operand:DI 0 "register_operand" "=r")
  1280.     (plus:DI (match_operand:DI 1 "register_operand" "%0")
  1281.          (match_operand:DI 2 "register_operand" "r")))]
  1282.   ""
  1283.   "a %O0,%O2\;ae %0,%2"
  1284.   [(set_attr "type" "multi")])
  1285.  
  1286. (define_insn "subdi3"
  1287.   [(set (match_operand:DI 0 "register_operand" "=r")
  1288.     (minus:DI (match_operand:DI 1 "register_operand" "0")
  1289.           (match_operand:DI 2 "register_operand" "r")))]
  1290.   ""
  1291.   "s %O0,%O2\;se %0,%2"
  1292.   [(set_attr "type" "multi")])
  1293.  
  1294. (define_insn "negdi2"
  1295.   [(set (match_operand:DI 0 "register_operand" "=r,&r")
  1296.     (neg:DI (match_operand:DI 1 "register_operand" "0,r")))]
  1297.   ""
  1298.   "twoc %O0,%O1\;onec %0,%1\;aei %0,%0,0"
  1299.   [(set_attr "type" "multi")
  1300.    (set_attr "length" "8")])
  1301.  
  1302. ;; Unary arithmetic operations.
  1303. (define_insn "abssi2"
  1304.   [(set (match_operand:SI 0 "register_operand" "=r")
  1305.     (abs:SI (match_operand:SI 1 "register_operand" "r")))]
  1306.   ""
  1307.   "abs %0,%1"
  1308.   [(set_attr "length" "2")])
  1309.  
  1310. (define_insn "negsi2"
  1311.   [(set (match_operand:SI 0 "register_operand" "=r")
  1312.     (neg:SI (match_operand:SI 1 "register_operand" "r")))]
  1313.   ""
  1314.   "twoc %0,%1"
  1315.   [(set_attr "length" "2")])
  1316.  
  1317. (define_insn "one_cmplsi2"
  1318.   [(set (match_operand:SI 0 "register_operand" "=r")
  1319.     (not:SI (match_operand:SI 1 "register_operand" "r")))]
  1320.   ""
  1321.   "onec %0,%1"
  1322.   [(set_attr "length" "2")])
  1323.  
  1324.  
  1325. ;; Logical insns: AND, IOR, and XOR
  1326. ;;
  1327. ;; If the operation is being performed on a 32-bit constant such that
  1328. ;; it cannot be done in one insn, do it in two.  We may lose a bit on
  1329. ;; CSE in pathological cases, but it seems better doing it this way.
  1330. (define_expand "andsi3"
  1331.   [(set (match_operand:SI 0 "register_operand" "")
  1332.     (and:SI (match_operand:SI 1 "register_operand" "")
  1333.         (match_operand:SI 2 "reg_or_any_cint_operand" "")))]
  1334.   ""
  1335.   "
  1336. {
  1337.   if (GET_CODE (operands[2]) == CONST_INT)
  1338.     {
  1339.       int top = (unsigned) INTVAL (operands[2]) >> 16;
  1340.       int bottom = INTVAL (operands[2]) & 0xffff;
  1341.  
  1342.       if (top != 0 && top != 0xffff && bottom != 0 && bottom != 0xffff)
  1343.     {
  1344.       emit_insn (gen_andsi3 (operands[0], operands[1],
  1345.                  gen_rtx (CONST_INT, VOIDmode,
  1346.                       (top << 16) | 0xffff)));
  1347.       operands[1] = operands[0];
  1348.       operands[2] = gen_rtx (CONST_INT, VOIDmode, 0xffff0000 | bottom);
  1349.     }
  1350.     }
  1351. }");
  1352.  
  1353. (define_insn ""
  1354.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  1355.     (and:SI (match_operand:SI 1 "reg_or_and_operand" "%0,r,0")
  1356.         (match_operand:SI 2 "reg_or_and_operand" "P,LMO,r")))]
  1357.   "register_operand (operands[1], SImode)
  1358.    || register_operand (operands[2], SImode)"
  1359.   "@
  1360.    clrb%k2 %0,%b2
  1361.    ni%z2 %0,%1,%Z2
  1362.    n %0,%2"
  1363.   [(set_attr "length" "2,4,2")])
  1364.  
  1365. ;; logical OR (IOR)
  1366. (define_expand "iorsi3"
  1367.   [(set (match_operand:SI 0 "register_operand" "")
  1368.     (ior:SI (match_operand:SI 1 "register_operand" "")
  1369.         (match_operand:SI 2 "reg_or_any_cint_operand" "")))]
  1370.   ""
  1371.   "
  1372. {
  1373.   if (GET_CODE (operands[2]) == CONST_INT)
  1374.     {
  1375.       int top = (unsigned) INTVAL (operands[2]) >> 16;
  1376.       int bottom = INTVAL (operands[2]) & 0xffff;
  1377.  
  1378.       if (top != 0 && bottom != 0)
  1379.     {
  1380.       emit_insn (gen_iorsi3 (operands[0], operands[1],
  1381.                  gen_rtx (CONST_INT, VOIDmode, (top << 16))));
  1382.       operands[1] = operands[0];
  1383.       operands[2] = gen_rtx (CONST_INT, VOIDmode, bottom);
  1384.     }
  1385.     }
  1386. }");
  1387.  
  1388. (define_insn ""
  1389.   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
  1390.     (ior:SI (match_operand:SI 1 "reg_or_cint_operand" "%0,r,0")
  1391.         (match_operand:SI 2 "reg_or_cint_operand" "N,LM,r")))]
  1392.   "register_operand (operands[1], SImode)
  1393.    || register_operand (operands[2], SImode)"
  1394.   "@
  1395.    setb%h2 %0,%b2
  1396.    oi%h2 %0,%1,%H2
  1397.    o %0,%2"
  1398.   [(set_attr "length" "2,4,2")])
  1399.  
  1400. ;; exclusive-or (XOR)
  1401. (define_expand "xorsi3"
  1402.   [(set (match_operand:SI 0 "register_operand" "")
  1403.     (xor:SI (match_operand:SI 1 "register_operand" "")
  1404.         (match_operand:SI 2 "reg_or_any_cint_operand" "")))]
  1405.   ""
  1406.   "
  1407. {
  1408.   if (GET_CODE (operands[2]) == CONST_INT)
  1409.     {
  1410.       int top = (unsigned) INTVAL (operands[2]) >> 16;
  1411.       int bottom = INTVAL (operands[2]) & 0xffff;
  1412.  
  1413.       if (top == 0xffff && bottom == 0xffff)
  1414.     {
  1415.       emit_insn (gen_one_cmplsi2 (operands[0], operands[1]));
  1416.       DONE;
  1417.     }
  1418.       else if (top != 0 && bottom != 0)
  1419.     {
  1420.       emit_insn (gen_xorsi3 (operands[0], operands[1],
  1421.                  gen_rtx (CONST_INT, VOIDmode, (top << 16))));
  1422.       operands[1] = operands[0];
  1423.       operands[2] = gen_rtx (CONST_INT, VOIDmode, bottom);
  1424.     }
  1425.     }
  1426. }");
  1427.  
  1428. (define_insn ""
  1429.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  1430.     (xor:SI (match_operand:SI 1 "reg_or_cint_operand" "%r,0")
  1431.         (match_operand:SI 2 "reg_or_cint_operand" "LM,r")))]
  1432.   "register_operand (operands[1], SImode)
  1433.    || register_operand (operands[2], SImode)"
  1434.   "@
  1435.    xi%h2 %0,%1,%H2
  1436.    x %0,%2"
  1437.   [(set_attr "length" "4,2")])
  1438.  
  1439. ;; Various shift insns
  1440. (define_insn "ashrsi3"
  1441.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  1442.     (ashiftrt:SI (match_operand:SI 1 "register_operand" "0,0")
  1443.              (match_operand:QI 2 "reg_or_cint_operand" "r,n")))]
  1444.   ""
  1445.   "@
  1446.    sar %0,%2
  1447.    sari%s2 %0,%S2"
  1448.   [(set_attr "length" "2")])
  1449.  
  1450. (define_insn "lshrsi3"
  1451.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  1452.     (lshiftrt:SI (match_operand:SI 1 "register_operand" "0,0")
  1453.              (match_operand:QI 2 "reg_or_cint_operand" "r,n")))]
  1454.   ""
  1455.   "@
  1456.    sr %0,%2
  1457.    sri%s2 %0,%S2"
  1458.   [(set_attr "length" "2")])
  1459.  
  1460. (define_insn ""
  1461.   [(set (match_operand:SI 0 "register_operand" "=r")
  1462.     (ashift:SI (match_operand:SI 1 "register_operand" "b")
  1463.            (const_int 1)))]
  1464.   ""
  1465.   "cas %0,%1,%1"
  1466.   [(set_attr "length" "2")
  1467.    (set_attr "type" "address")])
  1468.  
  1469. (define_insn "ashlsi3"
  1470.   [(set (match_operand:SI 0 "register_operand" "=r,r")
  1471.     (ashift:SI (match_operand:SI 1 "register_operand" "0,0")
  1472.            (match_operand:QI 2 "reg_or_cint_operand" "r,n")))]
  1473.   ""
  1474.   "@
  1475.    sl %0,%2
  1476.    sli%s2 %0,%S2"
  1477.   [(set_attr "length" "2")])
  1478.  
  1479. ;; Function call insns:
  1480. ;;
  1481. ;; On the ROMP, &fcn is actually a pointer to the data area, which is passed
  1482. ;; to the function in r0.  &.fcn is the actual starting address of the
  1483. ;; function.  Also, the word at &fcn contains &.fcn.
  1484. ;;
  1485. ;; For both functions that do and don't return values, there are two cases:
  1486. ;; where the function's address is a constant, and where it isn't.
  1487. ;;
  1488. ;; Operand 1 (2 for `call_value') is the number of arguments and is not used.
  1489. (define_expand "call"
  1490.   [(use (reg:SI 0))
  1491.    (parallel [(call (mem:SI (match_operand:SI 0 "address_operand" ""))
  1492.             (match_operand 1 "" ""))
  1493.           (clobber (reg:SI 15))])]
  1494.   ""
  1495.   "
  1496. {
  1497.   if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
  1498.     abort();
  1499.  
  1500.   operands[0] = XEXP (operands[0], 0);
  1501.   if (GET_CODE (operands[0]) == SYMBOL_REF)
  1502.     {
  1503.       extern rtx get_symref ();
  1504.       char *real_fcnname =
  1505.         (char *) alloca (strlen (XSTR (operands[0], 0)) + 2);
  1506.  
  1507.       /* Copy the data area address to r0.  */
  1508.       emit_move_insn (gen_rtx (REG, SImode, 0),
  1509.               force_reg (SImode, operands[0]));
  1510.       strcpy (real_fcnname, \".\");
  1511.       strcat (real_fcnname, XSTR (operands[0], 0));
  1512.       operands[0] = get_symref (real_fcnname);
  1513.     }
  1514.   else
  1515.     {
  1516.       rtx data_access;
  1517.  
  1518.       emit_move_insn (gen_rtx (REG, SImode, 0),
  1519.               force_reg (SImode, operands[0]));
  1520.       data_access = gen_rtx (MEM, SImode, operands[0]);
  1521.       RTX_UNCHANGING_P (data_access) = 1;
  1522.       operands[0] = copy_to_reg (data_access);
  1523.     }
  1524. }")
  1525.  
  1526. (define_insn ""
  1527.   [(call (mem:SI (match_operand:SI 0 "register_operand" "b"))
  1528.      (match_operand 1 "" "g"))
  1529.    (clobber (reg:SI 15))]
  1530.   ""
  1531.   "balr%# r15,%0"
  1532.   [(set_attr "type" "call")
  1533.    (set_attr "length" "2")])
  1534.  
  1535. (define_insn ""
  1536.   [(call (mem:SI (match_operand:SI 0 "symbolic_operand" "i"))
  1537.      (match_operand 1 "" "g"))
  1538.    (clobber (reg:SI 15))]
  1539.   "GET_CODE (operands[0]) == SYMBOL_REF"
  1540.   "bali%# r15,%0"
  1541.   [(set_attr "type" "call")])
  1542.  
  1543. ;; Call a function and return a value.
  1544. (define_expand "call_value"
  1545.   [(use (reg:SI 0))
  1546.    (parallel [(set (match_operand 0 "" "=fg")
  1547.            (call (mem:SI (match_operand:SI 1 "address_operand" ""))
  1548.              (match_operand 2 "" "")))
  1549.           (clobber (reg:SI 15))])]
  1550.   ""
  1551.   "
  1552. {
  1553.   if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
  1554.     abort();
  1555.  
  1556.   operands[1] = XEXP (operands[1], 0);
  1557.   if (GET_CODE (operands[1]) == SYMBOL_REF)
  1558.     {
  1559.       extern rtx get_symref ();
  1560.       char *real_fcnname =
  1561.         (char *) alloca (strlen (XSTR (operands[1], 0)) + 2);
  1562.  
  1563.       /* Copy the data area address to r0.  */
  1564.       emit_move_insn (gen_rtx (REG, SImode, 0),
  1565.               force_reg (SImode, operands[1]));
  1566.       strcpy (real_fcnname, \".\");
  1567.       strcat (real_fcnname, XSTR (operands[1], 0));
  1568.       operands[1] = get_symref (real_fcnname);
  1569.     }
  1570.   else
  1571.     {
  1572.       rtx data_access;
  1573.  
  1574.       emit_move_insn (gen_rtx (REG, SImode, 0),
  1575.               force_reg (SImode, operands[1]));
  1576.       data_access = gen_rtx (MEM, SImode, operands[1]);
  1577.       RTX_UNCHANGING_P (data_access) = 1;
  1578.       operands[1] = copy_to_reg (data_access);
  1579.     }
  1580. }")
  1581.  
  1582. (define_insn ""
  1583.   [(set (match_operand 0 "" "=fg")
  1584.     (call (mem:SI (match_operand:SI 1 "register_operand" "b"))
  1585.           (match_operand 2 "" "g")))
  1586.    (clobber (reg:SI 15))]
  1587.   ""
  1588.   "balr%# r15,%1"
  1589.   [(set_attr "length" "2")
  1590.    (set_attr "type" "call")])
  1591.  
  1592. (define_insn ""
  1593.   [(set (match_operand 0 "" "=fg")
  1594.     (call (mem:SI (match_operand:SI 1 "symbolic_operand" "i"))
  1595.           (match_operand 2 "" "g")))
  1596.    (clobber (reg:SI 15))]
  1597.   "GET_CODE (operands[1]) == SYMBOL_REF"
  1598.   "bali%# r15,%1"
  1599.   [(set_attr "type" "call")])
  1600.  
  1601. ;; No operation insn.
  1602. (define_insn "nop"
  1603.   [(const_int 0)]
  1604.   ""
  1605.   "nopr r0"
  1606.   [(set_attr "type" "address")
  1607.    (set_attr "length" "2")
  1608.    (set_attr "cc" "none")])
  1609.  
  1610. ;; Here are the floating-point operations.
  1611. ;;
  1612. ;; Start by providing DEFINE_EXPAND for each operation.
  1613. ;; The insns will be handled with MATCH_OPERATOR; the methodology will be
  1614. ;; discussed below.
  1615.  
  1616. ;; First the conversion operations.
  1617.  
  1618. (define_expand "truncdfsf2"
  1619.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1620.            (float_truncate:SF (match_operand:DF 1 "general_operand" "")))
  1621.           (clobber (reg:SI 0))
  1622.           (clobber (reg:SI 15))])]
  1623.   ""
  1624.   "")
  1625.  
  1626. (define_expand "extendsfdf2"
  1627.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1628.            (float_extend:DF (match_operand:SF 1 "general_operand" "")))
  1629.           (clobber (reg:SI 0))
  1630.           (clobber (reg:SI 15))])]
  1631.   ""
  1632.   "")
  1633.  
  1634. (define_expand "floatsisf2"
  1635.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1636.            (float:SF (match_operand:SI 1 "general_operand" "")))
  1637.           (clobber (reg:SI 0))
  1638.           (clobber (reg:SI 15))])]
  1639.   ""
  1640.   "")
  1641.  
  1642. (define_expand "floatsidf2"
  1643.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1644.            (float:DF (match_operand:SI 1 "general_operand" "")))
  1645.           (clobber (reg:SI 0))
  1646.           (clobber (reg:SI 15))])]
  1647.   ""
  1648.   "")
  1649.  
  1650. (define_expand "fix_truncsfsi2"
  1651.   [(parallel [(set (match_operand:SI 0 "general_operand" "")
  1652.            (fix:SI (match_operand:SF 1 "general_operand" "")))
  1653.           (clobber (reg:SI 0))
  1654.           (clobber (reg:SI 15))])]
  1655.   ""
  1656.   "")
  1657.  
  1658. (define_expand "fix_truncdfsi2"
  1659.   [(parallel [(set (match_operand:SI 0 "general_operand" "")
  1660.            (fix:SI (match_operand:DF 1 "general_operand" "")))
  1661.           (clobber (reg:SI 0))
  1662.           (clobber (reg:SI 15))])]
  1663.   ""
  1664.   "")
  1665.  
  1666. ;; Now the binary operations.
  1667.  
  1668. (define_expand "addsf3"
  1669.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1670.            (plus:SF (match_operand:SF 1 "general_operand" "")
  1671.                 (match_operand:SF 2 "general_operand" "")))
  1672.           (clobber (reg:SI 0))
  1673.           (clobber (reg:SI 15))])]
  1674.   ""
  1675.   "")
  1676.  
  1677. (define_expand "adddf3"
  1678.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1679.            (plus:DF (match_operand:DF 1 "general_operand" "")
  1680.                 (match_operand:DF 2 "general_operand" "")))
  1681.            (clobber (reg:SI 0))
  1682.            (clobber (reg:SI 15))])]
  1683.   ""
  1684.   "")
  1685.  
  1686. (define_expand "subsf3"
  1687.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1688.            (minus:SF (match_operand:SF 1 "general_operand" "")
  1689.                  (match_operand:SF 2 "general_operand" "")))
  1690.           (clobber (reg:SI 0))
  1691.           (clobber (reg:SI 15))])]
  1692.   ""
  1693.   "")
  1694.  
  1695. (define_expand "subdf3"
  1696.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1697.            (minus:DF (match_operand:DF 1 "general_operand" "")
  1698.                  (match_operand:DF 2 "general_operand" "")))
  1699.           (clobber (reg:SI 0))
  1700.           (clobber (reg:SI 15))])]
  1701.   ""
  1702.   "")
  1703.  
  1704. (define_expand "mulsf3"
  1705.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1706.            (mult:SF (match_operand:SF 1 "general_operand" "")
  1707.                 (match_operand:SF 2 "general_operand" "")))
  1708.           (clobber (reg:SI 0))
  1709.           (clobber (reg:SI 15))])]
  1710.   ""
  1711.   "")
  1712.  
  1713. (define_expand "muldf3"
  1714.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1715.            (mult:DF (match_operand:DF 1 "general_operand" "")
  1716.                 (match_operand:DF 2 "general_operand" "")))
  1717.           (clobber (reg:SI 0))
  1718.           (clobber (reg:SI 15))])]
  1719.   ""
  1720.   "")
  1721.  
  1722. (define_expand "divsf3"
  1723.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1724.            (div:SF (match_operand:SF 1 "general_operand" "")
  1725.                (match_operand:SF 2 "general_operand" "")))
  1726.           (clobber (reg:SI 0))
  1727.           (clobber (reg:SI 15))])]
  1728.   ""
  1729.   "")
  1730.  
  1731. (define_expand "divdf3"
  1732.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1733.            (div:DF (match_operand:DF 1 "general_operand" "")
  1734.                (match_operand:DF 2 "general_operand" "")))
  1735.           (clobber (reg:SI 0))
  1736.           (clobber (reg:SI 15))])]
  1737.   ""
  1738.   "")
  1739.  
  1740. ;; Unary floating-point operations.
  1741. ;;
  1742. ;; Negations can be done without floating-point, since this is IEEE.
  1743. ;; But we cannot do this if an operand is a hard FP register, since
  1744. ;; the SUBREG we create would not be valid.
  1745. (define_expand "negsf2"
  1746.   [(set (match_operand:SF 0 "register_operand" "")
  1747.     (neg:SF (match_operand:SF 1 "register_operand" "")))]
  1748.   ""
  1749.   "
  1750. {
  1751.   if (! (GET_CODE (operands[0]) == REG
  1752.      && REGNO (operands[0]) < FIRST_PSEUDO_REGISTER
  1753.      && FP_REGNO_P (REGNO (operands[0])))
  1754.       && ! (GET_CODE (operands[1]) == REG
  1755.         && REGNO (operands[1]) < FIRST_PSEUDO_REGISTER
  1756.         && FP_REGNO_P (REGNO (operands[1]))))
  1757.     {
  1758.       rtx result;
  1759.       rtx target = operand_subword (operands[0], 0, 1, SFmode);
  1760.  
  1761.       result = expand_binop (SImode, xor_optab,
  1762.                  operand_subword_force (operands[1], 0, SFmode),
  1763.                  gen_rtx (CONST_INT, VOIDmode, 0x80000000),
  1764.                  target, 0, OPTAB_WIDEN);
  1765.       if (result == 0)
  1766.     abort ();
  1767.  
  1768.       if (result != target)
  1769.     emit_move_insn (result, target);
  1770.  
  1771.       /* Make a place for REG_EQUAL.  */
  1772.       emit_move_insn (operands[0], operands[0]);
  1773.       DONE;
  1774.     }
  1775. }")
  1776.  
  1777. (define_expand "negdf2"
  1778.   [(set (match_operand:DF 0 "register_operand" "")
  1779.     (neg:DF (match_operand:DF 1 "register_operand" "")))]
  1780.   ""
  1781.   "
  1782. {
  1783.   if (! (GET_CODE (operands[0]) == REG
  1784.      && REGNO (operands[0]) < FIRST_PSEUDO_REGISTER
  1785.      && FP_REGNO_P (REGNO (operands[0])))
  1786.       && ! (GET_CODE (operands[1]) == REG
  1787.         && REGNO (operands[1]) < FIRST_PSEUDO_REGISTER
  1788.         && FP_REGNO_P (REGNO (operands[1]))))
  1789.     {
  1790.       rtx result;
  1791.       rtx target = operand_subword (operands[0], 0, 1, DFmode);
  1792.       rtx seq;
  1793.  
  1794.       start_sequence ();
  1795.       result = expand_binop (SImode, xor_optab,
  1796.                  operand_subword_force (operands[1], 0, DFmode),
  1797.                  gen_rtx (CONST_INT, VOIDmode, 0x80000000),
  1798.                  target, 0, OPTAB_WIDEN);
  1799.       if (result == 0)
  1800.     abort ();
  1801.  
  1802.       if (result != target)
  1803.     emit_move_insn (result, target);
  1804.   
  1805.       emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
  1806.               operand_subword_force (operands[1], 1, DFmode));
  1807.  
  1808.       seq = gen_sequence ();
  1809.       end_sequence ();
  1810.  
  1811.       emit_no_conflict_block (seq, operands[0], operands[1], 0, 0);
  1812.       DONE;
  1813.     }
  1814. }")
  1815.  
  1816. (define_expand "abssf2"
  1817.   [(parallel [(set (match_operand:SF 0 "general_operand" "")
  1818.            (abs:SF (match_operand:SF 1 "general_operand" "")))
  1819.           (clobber (reg:SI 0))
  1820.           (clobber (reg:SI 15))])]
  1821.   ""
  1822.   "")
  1823.  
  1824. (define_expand "absdf2"
  1825.   [(parallel [(set (match_operand:DF 0 "general_operand" "")
  1826.            (abs:DF (match_operand:DF 1 "general_operand" "")))
  1827.           (clobber (reg:SI 0))
  1828.           (clobber (reg:SI 15))])]
  1829.   ""
  1830.   "")
  1831.  
  1832. ;; Any floating-point operation can be either SFmode or DFmode, and each
  1833. ;; operand (including the output) can be either a normal operand or a
  1834. ;; conversion from a normal operand.
  1835. ;;
  1836. ;; We use MATCH_OPERATOR to match a floating-point binary or unary operator
  1837. ;; and input and output conversions.  So we need 2^N patterns for each type
  1838. ;; of operation, where N is the number of operands, including the output.
  1839. ;; There are thus a total of 14 patterns, 8 for binary operations, 4 for
  1840. ;; unary operations and two for conversion/move operations (only one
  1841. ;; operand can have a conversion for move operations).  In addition, we have
  1842. ;; to be careful that a floating-point reload register doesn't get allocated
  1843. ;; for an integer.  We take care of this for inputs with PREFERRED_RELOAD_CLASS
  1844. ;; but need to have two different constraints for outputs.  This means that
  1845. ;; we have to duplicate each pattern where the output could be an integer.
  1846. ;; This adds another 7 patterns, for a total of 21.
  1847.  
  1848. ;; Start with conversion operations (moves are done above).
  1849.  
  1850. (define_insn ""
  1851.   [(set (match_operand:SI 0 "general_operand" "=g")
  1852.     (match_operator 1 "float_conversion"
  1853.         [(match_operand 2 "general_operand" "frg")]))
  1854.    (clobber (match_operand:SI 3 "reg_0_operand" "=&z"))
  1855.    (clobber (match_operand:SI 4 "reg_15_operand" "=&t"))]
  1856.   ""
  1857.   "*
  1858. { return output_fpop (SET, operands[0], operands[2], 0, insn);
  1859. }"
  1860.   [(set_attr "type" "fp")])
  1861.  
  1862. (define_insn ""
  1863.   [(set (match_operand 0 "general_operand" "=frg")
  1864.     (match_operator 1 "float_conversion"
  1865.         [(match_operand 2 "general_operand" "frg")]))
  1866.    (clobber (match_operand:SI 3 "reg_0_operand" "=&z"))
  1867.    (clobber (match_operand:SI 4 "reg_15_operand" "=&t"))]
  1868.   ""
  1869.   "*
  1870. { return output_fpop (SET, operands[0], operands[2], 0, insn);
  1871. }"
  1872.   [(set_attr "type" "fp")])
  1873.  
  1874. ;; Next, binary floating-point operations.
  1875.  
  1876. (define_insn ""
  1877.   [(set (match_operand 0 "general_operand" "=frg")
  1878.     (match_operator 1 "float_binary"
  1879.         [(match_operand 2 "general_operand" "frg")
  1880.          (match_operand 3 "general_operand" "frg")]))
  1881.    (clobber (match_operand:SI 4 "reg_0_operand" "=&z"))
  1882.    (clobber (match_operand:SI 5 "reg_15_operand" "=&t"))]
  1883.   "check_precision (GET_MODE (operands[1]), operands[2], operands[3])"
  1884.   "*
  1885. { return output_fpop (GET_CODE (operands[1]), operands[0], 
  1886.               operands[2], operands[3], insn);
  1887. }"
  1888.   [(set_attr "type" "fp")])
  1889.  
  1890. (define_insn ""
  1891.   [(set (match_operand 0 "general_operand" "=frg")
  1892.     (match_operator 1 "float_binary"
  1893.         [(match_operand 2 "general_operand" "frg")
  1894.          (match_operator 3 "float_conversion"
  1895.             [(match_operand 4 "general_operand" "frg")])]))
  1896.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  1897.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  1898.   "check_precision (GET_MODE (operands[1]), operands[2], operands[4])"
  1899.   "*
  1900. { return output_fpop (GET_CODE (operands[1]), operands[0], 
  1901.               operands[2], operands[4], insn);
  1902. }"
  1903.   [(set_attr "type" "fp")])
  1904.  
  1905. (define_insn ""
  1906.   [(set (match_operand 0 "general_operand" "=frg")
  1907.     (match_operator 1 "float_binary"
  1908.         [(match_operator 2 "float_conversion"
  1909.             [(match_operand 3 "general_operand" "frg")])
  1910.          (match_operand 4 "general_operand" "frg")]))
  1911.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  1912.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  1913.   "check_precision (GET_MODE (operands[1]), operands[3], operands[4])"
  1914.   "*
  1915. { return output_fpop (GET_CODE (operands[1]), operands[0], 
  1916.               operands[3], operands[4], insn);
  1917. }"
  1918.   [(set_attr "type" "fp")])
  1919.  
  1920. (define_insn ""
  1921.   [(set (match_operand 0 "general_operand" "=frg")
  1922.     (match_operator 1 "float_binary"
  1923.         [(match_operator 2 "float_conversion"
  1924.             [(match_operand 3 "general_operand" "frg")])
  1925.          (match_operator 4 "float_conversion"
  1926.             [(match_operand 5 "general_operand" "frg")])]))
  1927.    (clobber (match_operand:SI 6 "reg_0_operand" "=&z"))
  1928.    (clobber (match_operand:SI 7 "reg_15_operand" "=&t"))]
  1929.   "check_precision (GET_MODE (operands[1]), operands[3], operands[5])"
  1930.   "*
  1931. { return output_fpop (GET_CODE (operands[1]), operands[0], 
  1932.               operands[3], operands[5], insn);
  1933. }"
  1934.   [(set_attr "type" "fp")])
  1935.  
  1936. (define_insn ""
  1937.   [(set (match_operand:SI 0 "general_operand" "=g")
  1938.     (match_operator 1 "float_conversion"
  1939.         [(match_operator 2 "float_binary"
  1940.             [(match_operand 3 "general_operand" "frg")
  1941.              (match_operand 4 "general_operand" "frg")])]))
  1942.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  1943.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  1944.   "check_precision (GET_MODE (operands[2]), operands[3], operands[4])"
  1945.   "*
  1946. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  1947.               operands[3], operands[4], insn);
  1948. }"
  1949.   [(set_attr "type" "fp")])
  1950.  
  1951. (define_insn ""
  1952.   [(set (match_operand 0 "general_operand" "=frg")
  1953.     (match_operator 1 "float_conversion"
  1954.         [(match_operator 2 "float_binary"
  1955.             [(match_operand 3 "general_operand" "frg")
  1956.              (match_operand 4 "general_operand" "frg")])]))
  1957.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  1958.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  1959.   "check_precision (GET_MODE (operands[2]), operands[3], operands[4])"
  1960.   "*
  1961. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  1962.               operands[3], operands[4], insn);
  1963. }"
  1964.   [(set_attr "type" "fp")])
  1965.  
  1966. (define_insn ""
  1967.   [(set (match_operand:SI 0 "general_operand" "=g")
  1968.     (match_operator 1 "float_conversion"
  1969.         [(match_operator 2 "float_binary"
  1970.             [(match_operand 3 "general_operand" "frg")
  1971.              (match_operator 4 "float_conversion"
  1972.                  [(match_operand 5 "general_operand" "frg")])])]))
  1973.    (clobber (match_operand:SI 6 "reg_0_operand" "=&z"))
  1974.    (clobber (match_operand:SI 7 "reg_15_operand" "=&t"))]
  1975.   "check_precision (GET_MODE (operands[2]), operands[3], operands[4])"
  1976.   "*
  1977. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  1978.               operands[3], operands[5], insn);
  1979. }"
  1980.   [(set_attr "type" "fp")])
  1981.  
  1982. (define_insn ""
  1983.   [(set (match_operand 0 "general_operand" "=frg")
  1984.     (match_operator 1 "float_conversion"
  1985.         [(match_operator 2 "float_binary"
  1986.             [(match_operand 3 "general_operand" "frg")
  1987.              (match_operator 4 "float_conversion"
  1988.                  [(match_operand 5 "general_operand" "frg")])])]))
  1989.    (clobber (match_operand:SI 6 "reg_0_operand" "=&z"))
  1990.    (clobber (match_operand:SI 7 "reg_15_operand" "=&t"))]
  1991.   "check_precision (GET_MODE (operands[2]), operands[3], operands[4])"
  1992.   "*
  1993. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  1994.               operands[3], operands[5], insn);
  1995. }"
  1996.   [(set_attr "type" "fp")])
  1997.  
  1998. (define_insn ""
  1999.   [(set (match_operand:SI 0 "general_operand" "=g")
  2000.     (match_operator 1 "float_conversion"
  2001.         [(match_operator 2 "float_binary"
  2002.             [(match_operator 3 "float_conversion"
  2003.                  [(match_operand 4 "general_operand" "frg")])
  2004.              (match_operand 5 "general_operand" "frg")])]))
  2005.    (clobber (match_operand:SI 6 "reg_0_operand" "=&z"))
  2006.    (clobber (match_operand:SI 7 "reg_15_operand" "=&t"))]
  2007.   "check_precision (GET_MODE (operands[2]), operands[4], operands[5])"
  2008.   "*
  2009. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  2010.               operands[4], operands[5], insn);
  2011. }"
  2012.   [(set_attr "type" "fp")])
  2013.  
  2014. (define_insn ""
  2015.   [(set (match_operand 0 "general_operand" "=frg")
  2016.     (match_operator 1 "float_conversion"
  2017.         [(match_operator 2 "float_binary"
  2018.             [(match_operator 3 "float_conversion"
  2019.                  [(match_operand 4 "general_operand" "frg")])
  2020.              (match_operand 5 "general_operand" "frg")])]))
  2021.    (clobber (match_operand:SI 6 "reg_0_operand" "=&z"))
  2022.    (clobber (match_operand:SI 7 "reg_15_operand" "=&t"))]
  2023.   "check_precision (GET_MODE (operands[2]), operands[4], operands[5])"
  2024.   "*
  2025. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  2026.               operands[4], operands[5], insn);
  2027. }"
  2028.   [(set_attr "type" "fp")])
  2029.  
  2030. (define_insn ""
  2031.   [(set (match_operand:SI 0 "general_operand" "=g")
  2032.     (match_operator 1 "float_conversion"
  2033.         [(match_operator 2 "float_binary"
  2034.             [(match_operator 3 "float_conversion"
  2035.                  [(match_operand 4 "general_operand" "frg")])
  2036.              (match_operator 5 "float_conversion"
  2037.                  [(match_operand 6 "general_operand" "frg")])])]))
  2038.    (clobber (match_operand:SI 7 "reg_0_operand" "=&z"))
  2039.    (clobber (match_operand:SI 8 "reg_15_operand" "=&t"))]
  2040.   "check_precision (GET_MODE (operands[2]), operands[4], operands[6])"
  2041.   "*
  2042. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  2043.               operands[4], operands[6], insn);
  2044. }"
  2045.   [(set_attr "type" "fp")])
  2046.  
  2047. (define_insn ""
  2048.   [(set (match_operand 0 "general_operand" "=frg")
  2049.     (match_operator 1 "float_conversion"
  2050.         [(match_operator 2 "float_binary"
  2051.             [(match_operator 3 "float_conversion"
  2052.                  [(match_operand 4 "general_operand" "frg")])
  2053.              (match_operator 5 "float_conversion"
  2054.                  [(match_operand 6 "general_operand" "frg")])])]))
  2055.    (clobber (match_operand:SI 7 "reg_0_operand" "=&z"))
  2056.    (clobber (match_operand:SI 8 "reg_15_operand" "=&t"))]
  2057.   "check_precision (GET_MODE (operands[2]), operands[4], operands[6])"
  2058.   "*
  2059. { return output_fpop (GET_CODE (operands[2]), operands[0], 
  2060.               operands[4], operands[6], insn);
  2061. }"
  2062.   [(set_attr "type" "fp")])
  2063.  
  2064. ;; Unary floating-point operations.
  2065.  
  2066. (define_insn ""
  2067.   [(set (match_operand 0 "general_operand" "=frg")
  2068.     (match_operator 1 "float_unary"
  2069.         [(match_operand 2 "general_operand" "frg")]))
  2070.    (clobber (match_operand:SI 3 "reg_0_operand" "=&z"))
  2071.    (clobber (match_operand:SI 4 "reg_15_operand" "=&t"))]
  2072.   "check_precision (GET_MODE (operands[1]), operands[2], 0)"
  2073.   "*
  2074. { return output_fpop (GET_CODE (operands[1]), operands[0], operands[2],
  2075.               0, insn);
  2076. }"
  2077.   [(set_attr "type" "fp")])
  2078.  
  2079. (define_insn ""
  2080.   [(set (match_operand 0 "general_operand" "=frg")
  2081.     (match_operator 1 "float_unary"
  2082.         [(match_operator 2 "float_conversion"
  2083.             [(match_operand 3 "general_operand" "frg")])]))
  2084.    (clobber (match_operand:SI 4 "reg_0_operand" "=&z"))
  2085.    (clobber (match_operand:SI 5 "reg_15_operand" "=&t"))]
  2086.   "check_precision (GET_MODE (operands[1]), operands[3], 0)"
  2087.   "*
  2088. { return output_fpop (GET_CODE (operands[1]), operands[0], operands[3],
  2089.               0, insn);
  2090. }"
  2091.   [(set_attr "type" "fp")])
  2092.  
  2093. (define_insn ""
  2094.   [(set (match_operand:SI 0 "general_operand" "=g")
  2095.     (match_operator 1 "float_conversion"
  2096.         [(match_operator 2 "float_unary"
  2097.             [(match_operand 3 "general_operand" "frg")])]))
  2098.    (clobber (match_operand:SI 4 "reg_0_operand" "=&z"))
  2099.    (clobber (match_operand:SI 5 "reg_15_operand" "=&t"))]
  2100.   "check_precision (GET_MODE (operands[2]), operands[3], 0)"
  2101.   "*
  2102. { return output_fpop (GET_CODE (operands[2]), operands[0], operands[3],
  2103.               0, insn);
  2104. }"
  2105.   [(set_attr "type" "fp")])
  2106.  
  2107. (define_insn ""
  2108.   [(set (match_operand 0 "general_operand" "=frg")
  2109.     (match_operator 1 "float_conversion"
  2110.         [(match_operator 2 "float_unary"
  2111.             [(match_operand 3 "general_operand" "frg")])]))
  2112.    (clobber (match_operand:SI 4 "reg_0_operand" "=&z"))
  2113.    (clobber (match_operand:SI 5 "reg_15_operand" "=&t"))]
  2114.   "check_precision (GET_MODE (operands[2]), operands[3], 0)"
  2115.   "*
  2116. { return output_fpop (GET_CODE (operands[2]), operands[0], operands[3],
  2117.               0, insn);
  2118. }"
  2119.   [(set_attr "type" "fp")])
  2120.  
  2121. (define_insn ""
  2122.   [(set (match_operand:SI 0 "general_operand" "=g")
  2123.     (match_operator 1 "float_conversion"
  2124.         [(match_operator 2 "float_unary"
  2125.             [(match_operator 3 "float_conversion"
  2126.                  [(match_operand 4 "general_operand" "frg")])])]))
  2127.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  2128.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  2129.   "check_precision (GET_MODE (operands[2]), operands[4], 0)"
  2130.   "*
  2131. { return output_fpop (GET_CODE (operands[2]), operands[0], operands[4],
  2132.               0, insn);
  2133. }"
  2134.   [(set_attr "type" "fp")])
  2135.  
  2136. (define_insn ""
  2137.   [(set (match_operand 0 "general_operand" "=frg")
  2138.     (match_operator 1 "float_conversion"
  2139.         [(match_operator 2 "float_unary"
  2140.             [(match_operator 3 "float_conversion"
  2141.                  [(match_operand 4 "general_operand" "frg")])])]))
  2142.    (clobber (match_operand:SI 5 "reg_0_operand" "=&z"))
  2143.    (clobber (match_operand:SI 6 "reg_15_operand" "=&t"))]
  2144.   "check_precision (GET_MODE (operands[2]), operands[4], 0)"
  2145.   "*
  2146. { return output_fpop (GET_CODE (operands[2]), operands[0], operands[4],
  2147.               0, insn);
  2148. }"
  2149.   [(set_attr "type" "fp")])
  2150.  
  2151. ;; Compare insns are next.  Note that the ROMP has two types of compares,
  2152. ;; signed & unsigned, and one type of branch.  Use the routine
  2153. ;; `next_insn_tests_no_unsigned' to see which type to use.
  2154. (define_expand "tstsi"
  2155.   [(set (cc0)
  2156.     (match_operand:SI 0 "register_operand" "r"))]
  2157.   ""
  2158.   "")
  2159.  
  2160. (define_expand "cmpsi"
  2161.   [(set (cc0)
  2162.         (compare (match_operand:SI 0 "register_operand" "")
  2163.            (match_operand:SI 1 "reg_or_cint_operand" "")))]
  2164.   ""
  2165.   "")
  2166.  
  2167. ;; Signed compare, `test' first.
  2168.  
  2169. (define_insn ""
  2170.   [(set (cc0)
  2171.     (match_operand:SI 0 "register_operand" "r"))]
  2172.   "next_insn_tests_no_unsigned (insn)"
  2173.   "cis %0,0"
  2174.   [(set_attr "length" "2")
  2175.    (set_attr "type" "compare")])
  2176.  
  2177. (define_insn ""
  2178.   [(set (cc0) (match_operand:SI 0 "register_operand" "r,r,r"))
  2179.    (set (match_operand:SI 1 "reg_or_nonsymb_mem_operand" "=0,r,Q")
  2180.     (match_dup 0))]
  2181.   "next_insn_tests_no_unsigned (insn)"
  2182.   "@
  2183.    cis %1,0
  2184.    nilo %1,%0,65535
  2185.    st%M1 %0,%1\;cis %0,0"
  2186.   [(set_attr "type" "compare,compare,store")
  2187.    (set_attr "length" "2,4,6")
  2188.    (set_attr "cc" "compare")])
  2189.  
  2190. (define_insn ""
  2191.   [(set (cc0)
  2192.         (compare (match_operand:SI 0 "register_operand" "r,r,r")
  2193.          (match_operand:SI 1 "reg_or_cint_operand" "I,K,r")))]
  2194.   "next_insn_tests_no_unsigned (insn)"
  2195.   "@
  2196.    cis %0,%1
  2197.    cil %0,%1
  2198.    c %0,%1"
  2199.   [(set_attr "length" "2,4,2")
  2200.    (set_attr "type" "compare")])
  2201.  
  2202. ;; Unsigned comparisons, `test' first, again.
  2203. (define_insn ""
  2204.   [(set (cc0)
  2205.     (match_operand:SI 0 "register_operand" "r"))]
  2206.   "! next_insn_tests_no_unsigned (insn)"
  2207.   "clil %0,0"
  2208.   [(set_attr "type" "compare")])
  2209.  
  2210. (define_insn ""
  2211.   [(set (cc0)
  2212.         (compare (match_operand:SI 0 "register_operand" "r,r")
  2213.          (match_operand:SI 1 "reg_or_cint_operand" "K,r")))]
  2214.   "! next_insn_tests_no_unsigned (insn)"
  2215.   "@
  2216.    clil %0,%1
  2217.    cl %0,%1"
  2218.   [(set_attr "length" "4,2")
  2219.    (set_attr "type" "compare")])
  2220.  
  2221. ;; Bit test insn.  Many cases are converted into this by combine.  This
  2222. ;; uses the ROMP test bit.
  2223.  
  2224. (define_insn ""
  2225.   [(set (cc0)
  2226.     (zero_extract (match_operand:SI 0 "register_operand" "r,r")
  2227.               (const_int 1)
  2228.               (match_operand:SI 1 "reg_or_any_cint_operand" "r,n")))]
  2229.   "next_insn_tests_no_inequality (insn)"
  2230.   "@
  2231.    mttb %0,%1
  2232.    mttbi%t1 %0,%S1"
  2233.   [(set_attr "length" "2")
  2234.    (set_attr "type" "compare")
  2235.    (set_attr "cc" "tbit")])
  2236.  
  2237. ;; Floating-point comparisons.  There are two, equality and order.
  2238. ;; The difference will be that a trap for NaN will be given on the orderr
  2239. ;; comparisons only.
  2240.  
  2241. (define_expand "cmpsf"
  2242.   [(parallel [(set (cc0) (compare (match_operand:SF 0 "general_operand" "")
  2243.                   (match_operand:SF 1 "general_operand" "")))
  2244.           (clobber (reg:SI 0))
  2245.           (clobber (reg:SI 15))])]
  2246.   ""
  2247.   "")
  2248.  
  2249. (define_expand "cmpdf"
  2250.   [(parallel [(set (cc0) (compare (match_operand:DF 0 "general_operand" "")
  2251.                   (match_operand:DF 1 "general_operand" "")))
  2252.           (clobber (reg:SI 0))
  2253.           (clobber (reg:SI 15))])]
  2254.   ""
  2255.   "")
  2256.  
  2257. (define_expand "tstsf"
  2258.   [(parallel [(set (cc0) (match_operand:SF 0 "general_operand" ""))
  2259.           (clobber (reg:SI 0))
  2260.           (clobber (reg:SI 15))])]
  2261.   ""
  2262.   "")
  2263.  
  2264. (define_expand "tstdf"
  2265.   [(parallel [(set (cc0) (match_operand:DF 0 "general_operand" ""))
  2266.           (clobber (reg:SI 0))
  2267.           (clobber (reg:SI 15))])]
  2268.   ""
  2269.   "")
  2270.  
  2271. ;; There are four cases for compare and two for test.  These correspond
  2272. ;; to each input having a floating-point conversion or not.
  2273.  
  2274. (define_insn ""
  2275.   [(set (cc0) (compare (match_operand 0 "general_operand" "frg")
  2276.                (match_operand 1 "general_operand" "frg")))
  2277.    (clobber (match_operand:SI 2 "reg_0_operand" "=&z"))
  2278.    (clobber (match_operand:SI 3 "reg_15_operand" "=&t"))]
  2279.   "GET_MODE (operands[1]) == SFmode || GET_MODE (operands[1]) == DFmode"
  2280.   "*
  2281. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2282.               operands[0], operands[1], 0, insn);
  2283. }"
  2284.   [(set_attr "type" "fp")
  2285.    (set_attr "cc" "compare")])
  2286.  
  2287. (define_insn ""
  2288.   [(set (cc0) (compare (match_operand 0 "general_operand" "frg")
  2289.                (match_operator 1 "float_conversion"
  2290.                   [(match_operand 2 "general_operand" "frg")])))
  2291.    (clobber (match_operand:SI 3 "reg_0_operand" "=&z"))
  2292.    (clobber (match_operand:SI 4 "reg_15_operand" "=&t"))]
  2293.   ""
  2294.   "*
  2295. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2296.               operands[0], operands[2], 0, insn);
  2297. }"
  2298.   [(set_attr "type" "fp")
  2299.    (set_attr "cc" "compare")])
  2300.  
  2301. (define_insn ""
  2302.   [(set (cc0) (compare (match_operator 0 "float_conversion"
  2303.                   [(match_operand 1 "general_operand" "frg")])
  2304.                (match_operand 2 "general_operand" "frg")))
  2305.    (clobber (match_operand:SI 3 "reg_0_operand" "=&z"))
  2306.    (clobber (match_operand:SI 4 "reg_15_operand" "=&t"))]
  2307.   ""
  2308.   "*
  2309. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2310.               operands[1], operands[2], 0, insn);
  2311. }"
  2312.   [(set_attr "type" "fp")
  2313.    (set_attr "cc" "compare")])
  2314.  
  2315. (define_insn ""
  2316.   [(set (cc0) (compare (match_operator 0 "float_conversion"
  2317.                   [(match_operand 1 "general_operand" "frg")])
  2318.                (match_operator 2 "float_conversion"
  2319.                   [(match_operand 3 "general_operand" "frg")])))
  2320.    (clobber (match_operand:SI 4 "reg_0_operand" "=&z"))
  2321.    (clobber (match_operand:SI 5 "reg_15_operand" "=&t"))]
  2322.   ""
  2323.   "*
  2324. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2325.               operands[1], operands[3], 0, insn);
  2326. }"
  2327.   [(set_attr "type" "fp")
  2328.    (set_attr "cc" "compare")])
  2329.  
  2330. (define_insn ""
  2331.   [(set (cc0) (match_operand 0 "general_operand" "frg"))
  2332.    (clobber (match_operand:SI 1 "reg_0_operand" "=&z"))
  2333.    (clobber (match_operand:SI 2 "reg_15_operand" "=&t"))]
  2334.   "GET_MODE (operands[0]) == SFmode || GET_MODE (operands[0]) == DFmode"
  2335.   "*
  2336. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2337.               operands[0], immed_real_const_1 (0, 0,
  2338.                                GET_MODE (operands[0])),
  2339.               0, insn);
  2340. }"
  2341.   [(set_attr "type" "fp")
  2342.    (set_attr "cc" "compare")])
  2343.  
  2344. (define_insn ""
  2345.   [(set (cc0) (match_operator 0 "float_conversion"
  2346.             [(match_operand 1 "general_operand" "frg")]))
  2347.    (clobber (match_operand:SI 2 "reg_0_operand" "=&z"))
  2348.    (clobber (match_operand:SI 3 "reg_15_operand" "=&t"))]
  2349.   ""
  2350.   "*
  2351. { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE,
  2352.               operands[1], immed_real_const_1 (0, 0,
  2353.                                GET_MODE (operands[1])),
  2354.               0, insn);
  2355. }"
  2356.   [(set_attr "type" "fp")
  2357.    (set_attr "cc" "compare")])
  2358.  
  2359. ;; Branch insns.  Unsigned vs. signed have already
  2360. ;; been taken care of.  The only insns that need to be concerned about the
  2361. ;; test bit are beq and bne because the rest are either always true,
  2362. ;; always false, or converted to EQ or NE.
  2363.  
  2364. ;; For conditional branches, we use `define_expand' and just have two patterns
  2365. ;; that match them.  Operand printing does most of the work.
  2366.  
  2367. (define_expand "beq"
  2368.   [(set (pc)
  2369.     (if_then_else (eq (cc0)
  2370.               (const_int 0))
  2371.               (label_ref (match_operand 0 "" ""))
  2372.               (pc)))]
  2373.   ""
  2374.   "")
  2375.  
  2376. (define_expand "bne"
  2377.   [(set (pc)
  2378.     (if_then_else (ne (cc0)
  2379.               (const_int 0))
  2380.               (label_ref (match_operand 0 "" ""))
  2381.               (pc)))]
  2382.   ""
  2383.   "")
  2384.  
  2385. (define_expand "bgt"
  2386.   [(set (pc)
  2387.     (if_then_else (gt (cc0)
  2388.               (const_int 0))
  2389.               (label_ref (match_operand 0 "" ""))
  2390.               (pc)))]
  2391.   ""
  2392.   "")
  2393.  
  2394. (define_expand "bgtu"
  2395.   [(set (pc)
  2396.     (if_then_else (gtu (cc0)
  2397.                (const_int 0))
  2398.               (label_ref (match_operand 0 "" ""))
  2399.               (pc)))]
  2400.   ""
  2401.   "")
  2402.  
  2403. (define_expand "blt"
  2404.   [(set (pc)
  2405.     (if_then_else (lt (cc0)
  2406.               (const_int 0))
  2407.               (label_ref (match_operand 0 "" ""))
  2408.               (pc)))]
  2409.   ""
  2410.   "")
  2411.  
  2412. (define_expand "bltu"
  2413.   [(set (pc)
  2414.     (if_then_else (ltu (cc0)
  2415.                (const_int 0))
  2416.               (label_ref (match_operand 0 "" ""))
  2417.               (pc)))]
  2418.   ""
  2419.   "")
  2420.  
  2421. (define_expand "bge"
  2422.   [(set (pc)
  2423.     (if_then_else (ge (cc0)
  2424.               (const_int 0))
  2425.               (label_ref (match_operand 0 "" ""))
  2426.               (pc)))]
  2427.   ""
  2428.   "")
  2429.  
  2430. (define_expand "bgeu"
  2431.   [(set (pc)
  2432.     (if_then_else (geu (cc0)
  2433.                (const_int 0))
  2434.               (label_ref (match_operand 0 "" ""))
  2435.               (pc)))]
  2436.   ""
  2437.   "")
  2438.  
  2439. (define_expand "ble"
  2440.   [(set (pc)
  2441.     (if_then_else (le (cc0)
  2442.               (const_int 0))
  2443.               (label_ref (match_operand 0 "" ""))
  2444.               (pc)))]
  2445.   ""
  2446.   "")
  2447.  
  2448. (define_expand "bleu"
  2449.   [(set (pc)
  2450.     (if_then_else (leu (cc0)
  2451.                (const_int 0))
  2452.               (label_ref (match_operand 0 "" ""))
  2453.               (pc)))]
  2454.   ""
  2455.   "")
  2456.  
  2457. ;; Define both directions of branch and return.
  2458.  
  2459. (define_insn ""
  2460.   [(set (pc)
  2461.     (if_then_else (match_operator 1 "comparison_operator"
  2462.                       [(cc0) (const_int 0)])
  2463.               (label_ref (match_operand 0 "" ""))
  2464.               (pc)))]
  2465.   ""
  2466.   "*
  2467. {
  2468.   if (restore_compare_p (operands[1]))
  2469.     return 0;
  2470.   else if (get_attr_length (insn) == 2)
  2471.     return \"j%j1 %l0\";
  2472.   else
  2473.     return \"b%j1%# %l0\";
  2474. }"
  2475.   [(set_attr "type" "branch")])
  2476.  
  2477. (define_insn ""
  2478.   [(set (pc)
  2479.     (if_then_else (match_operator 0 "comparison_operator"
  2480.                       [(cc0) (const_int 0)])
  2481.               (return)
  2482.               (pc)))]
  2483.   "null_epilogue ()"
  2484.   "*
  2485. {
  2486.   if (restore_compare_p (operands[0]))
  2487.     return 0;
  2488.   else
  2489.     return \"b%j0r%# r15\";
  2490. }"
  2491.   [(set_attr "type" "return")])
  2492.  
  2493. (define_insn ""
  2494.   [(set (pc)
  2495.     (if_then_else (match_operator 1 "comparison_operator"
  2496.                 [(cc0) (const_int 0)])
  2497.               (pc)
  2498.               (label_ref (match_operand 0 "" ""))))]
  2499.   ""
  2500.   "*
  2501. {
  2502.   if (restore_compare_p (operands[1]))
  2503.     return 0;
  2504.   else if (get_attr_length (insn) == 2)
  2505.     return \"j%J1 %l0\";
  2506.   else
  2507.     return \"b%J1%# %l0\";
  2508. }"
  2509.   [(set_attr "type" "branch")])
  2510.  
  2511. (define_insn ""
  2512.   [(set (pc)
  2513.     (if_then_else (match_operator 0 "comparison_operator"
  2514.                       [(cc0) (const_int 0)])
  2515.               (pc)
  2516.               (return)))]
  2517.   "null_epilogue ()"
  2518.   "*
  2519. {
  2520.   if (restore_compare_p (operands[0]))
  2521.     return 0;
  2522.   else
  2523.     return \"b%J0r%# r15\";
  2524. }"
  2525.   [(set_attr "type" "return")])
  2526.  
  2527. ;; Unconditional branch and return.
  2528.  
  2529. (define_insn "jump"
  2530.   [(set (pc)
  2531.     (label_ref (match_operand 0 "" "")))]
  2532.   ""
  2533.   "*
  2534. {
  2535.   if (get_attr_length (insn) == 2)
  2536.     return \"j %l0\";
  2537.   else
  2538.     return \"b%# %l0\";
  2539. }"
  2540.   [(set_attr "type" "branch")])
  2541.  
  2542. (define_insn "return"
  2543.   [(return)]
  2544.   "null_epilogue ()"
  2545.   "br%# r15"
  2546.   [(set_attr "type" "return")])
  2547.  
  2548. (define_insn "indirect_jump"
  2549.   [(set (pc) (match_operand:SI 0 "register_operand" "r"))]
  2550.   ""
  2551.   "br%# %0"
  2552.   [(set_attr "type" "branch")
  2553.    (set_attr "length" "2")])
  2554.  
  2555. ;; Table jump for switch statements:
  2556. (define_insn "tablejump"
  2557.   [(set (pc)
  2558.     (match_operand:SI 0 "register_operand" "r"))
  2559.    (use (label_ref (match_operand 1 "" "")))]
  2560.   ""
  2561.   "br%# %0"
  2562.   [(set_attr "type" "branch")
  2563.    (set_attr "length" "2")])
  2564.  
  2565. ;;- Local variables:
  2566. ;;- mode:emacs-lisp
  2567. ;;- comment-start: ";;- "
  2568. ;;- eval: (set-syntax-table (copy-sequence (syntax-table)))
  2569. ;;- eval: (modify-syntax-entry ?[ "(]")
  2570. ;;- eval: (modify-syntax-entry ?] ")[")
  2571. ;;- eval: (modify-syntax-entry ?{ "(}")
  2572. ;;- eval: (modify-syntax-entry ?} "){")
  2573. ;;- End:
  2574.