Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Diff of /sml/trunk/src/MLRISC/x86/mltree/x86.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/x86/mltree/x86.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 565, Sun Mar 5 04:10:18 2000 UTC revision 583, Thu Mar 23 21:52:30 2000 UTC
# Line 1  Line 1 
1  (* X86.sml -- pattern matching version of x86 instruction set generation.  (*
2   *   *
3   * COPYRIGHT (c) 1998 Bell Laboratories.   * COPYRIGHT (c) 1998 Bell Laboratories.
4   *   *
# Line 581  Line 581 
581    
582                   (* Generate setcc instruction:                   (* Generate setcc instruction:
583                    *  semantics:  MV(rd, COND(_, T.CMP(ty, cc, t1, t2), yes, no))                    *  semantics:  MV(rd, COND(_, T.CMP(ty, cc, t1, t2), yes, no))
584                      * Bug, if eax is either t1 or t2 then problem will occur!!!
585                      * Note that we have to use eax as the destination of the
586                      * setcc because it only works on the registers
587                      * %al, %bl, %cl, %dl and %[abcd]h.  The last four registers
588                      * are inaccessible in 32 bit mode.
589                    *)                    *)
590                fun setcc(ty, cc, t1, t2, yes, no) =                fun setcc(ty, cc, t1, t2, yes, no) =
591                let val tmpR = newReg()                let val (cc, yes, no) =
592                    val tmp = I.Direct tmpR                           if yes > no then (cc, yes, no)
593                    (* We create a temporary here just in                           else (T.Basis.negateCond cc, no, yes)
                    * case t1 or t2 contains a use of rd.  
                    *)  
594                in  (* Clear the destination first.                in  (* Clear the destination first.
595                     * This this because stupid SETcc                     * This this because stupid SETcc
596                     * only writes to the low order                     * only writes to the low order
597                     * byte.  That's Intel architecture, folks.                     * byte.  That's Intel architecture, folks.
598                     *)                     *)
599                    zero tmp;                    zero eax;
600                    case (yes, no) of                    case (yes, no) of
601                      (1, 0) => (* normal case *)                      (1, 0) => (* normal case *)
602                      let val cc = cmp(true, ty, cc, t1, t2, [])                      let val cc = cmp(true, ty, cc, t1, t2, [])
603                      in  mark(I.SET{cond=cond cc, opnd=tmp}, an) end                      in  mark(I.SET{cond=cond cc, opnd=eax}, an);
604                    | (0, 1) => (* flip *)                          move(eax, rdOpnd)
605                      let val cc = cmp(true, ty,                      end
                                      T.Basis.negateCond cc, t1, t2, [])  
                     in  mark(I.SET{cond=cond cc, opnd=tmp}, an) end  
606                    | (C1, C2)  =>                    | (C1, C2)  =>
607                      (* general case;                      (* general case;
608                       * from the Intel optimization guide p3-5 *)                       * from the Intel optimization guide p3-5
609                      let val C1 = toInt32 C1                       *)
610                          val C2 = toInt32 C2                      let val cc = cmp(true, ty, cc, t1, t2, [])
611                          val cc = cmp(true, ty, cc, t1, t2, [])                      in  case C1-C2 of
612                      in  emit(I.SET{cond=cond cc, opnd=tmp});                            D as (1 | 2 | 3 | 4 | 5 | 8 | 9) =>
613                          case Int32.abs(C1-C2)-1 of                            let val (base,scale) =
614                            D as (1 | 2 | 4 | 8) =>                                    case D of
615                            let val addr = I.Indexed{base=SOME tmpR,                                      1 => (NONE, 0)
616                                                     index=tmpR,                                    | 2 => (NONE, 1)
617                                                     scale=Int32.toInt D,                                    | 3 => (SOME C.eax, 1)
618                                                     disp=I.Immed(C1-C2),                                    | 4 => (NONE, 2)
619                                      | 5 => (SOME C.eax, 2)
620                                      | 8 => (NONE, 3)
621                                      | 9 => (SOME C.eax, 3)
622                                  val addr = I.Indexed{base=base,
623                                                       index=C.eax,
624                                                       scale=scale,
625                                                       disp=I.Immed C2,
626                                                     mem=readonly}                                                     mem=readonly}
627                            in  mark(I.LEA{r32=tmpR, addr=addr}, an) end                                val tmpR = newReg()
628                          | _ =>                                val tmp  = I.Direct tmpR
629                           (emit(I.UNARY{unOp=I.DECL, opnd=tmp});                            in  emit(I.SET{cond=cond cc, opnd=eax});
630                                  mark(I.LEA{r32=tmpR, addr=addr}, an);
631                                  move(tmp, rdOpnd)
632                              end
633                            | D =>
634                               (emit(I.SET{cond=cond(T.Basis.negateCond cc),
635                                           opnd=eax});
636                                emit(I.UNARY{unOp=I.DECL, opnd=eax});
637                            emit(I.BINARY{binOp=I.ANDL,                            emit(I.BINARY{binOp=I.ANDL,
638                                          src=I.Immed(C2-C1), dst=tmp});                                            src=I.Immed D, dst=eax});
639                            mark(I.BINARY{binOp=I.ADDL,                              if C2 = 0 then
640                                          src=I.Immed(Int32.min(C1,C2)),                                 move(eax, rdOpnd)
641                                          dst=tmp}, an)                              else
642                           )                                 let val tmpR = newReg()
643                      end;                                     val tmp  = I.Direct tmpR
644                                   in  mark(I.LEA{addr=
645                                             I.Displace{
646                                                 base=C.eax,
647                                                 disp=I.Immed C2,
648                                                 mem=readonly},
649                                                 r32=tmpR}, an);
650                    move(tmp, rdOpnd)                    move(tmp, rdOpnd)
651                                    end
652                               )
653                        end
654                end (* setcc *)                end (* setcc *)
655    
656                    (* Generate cmovcc instruction.                    (* Generate cmovcc instruction.
# Line 727  Line 751 
751               | T.CVTI2I(_,T.SIGN_EXTEND,_,T.LOAD(16,ea,mem)) => load16s(ea, mem)               | T.CVTI2I(_,T.SIGN_EXTEND,_,T.LOAD(16,ea,mem)) => load16s(ea, mem)
752    
753               | T.COND(32, T.CMP(ty, cc, t1, t2), T.LI yes, T.LI no) =>               | T.COND(32, T.CMP(ty, cc, t1, t2), T.LI yes, T.LI no) =>
754                   setcc(ty, cc, t1, t2, yes, no)                   setcc(ty, cc, t1, t2, toInt32 yes, toInt32 no)
755                 | T.COND(32, T.CMP(ty, cc, t1, t2), T.LI32 yes, T.LI32 no) =>
756                     setcc(ty, cc, t1, t2, Word32.toLargeIntX yes,
757                                           Word32.toLargeIntX no)
758               | T.COND(32, T.CMP(ty, cc, t1, t2), yes, no) =>               | T.COND(32, T.CMP(ty, cc, t1, t2), yes, no) =>
759                  (case !arch of (* PentiumPro and higher has CMOVcc *)                  (case !arch of (* PentiumPro and higher has CMOVcc *)
760                     Pentium => unknownExp exp                     Pentium => unknownExp exp

Legend:
Removed from v.565  
changed lines
  Added in v.583

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0