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

SCM Repository

[smlnj] View of /sml/trunk/src/MLRISC/x86/instructions/x86Peephole.peep
ViewVC logotype

View of /sml/trunk/src/MLRISC/x86/instructions/x86Peephole.peep

Parent Directory Parent Directory | Revision Log Revision Log


Revision 752 - (download) (annotate)
Fri Dec 8 23:32:37 2000 UTC (18 years, 8 months ago) by leunga
File size: 3685 byte(s)

    Slight improvements to a code generator tool.
(* 
 * Note, this file contains conditional pattern matching rules.
 * You'll have to run it thru the tool wheregen 
 * (source for this is in the directory Tools/WhereGen) 
 * to generate the output.
 * 
 * -- Allen
 *)

local
 
 
   include "x86Instr.sml" (* import instruction definitions *)

in

functor X86Peephole(X86Instr : X86INSTR) : PEEPHOLE =
struct
   structure I = X86Instr
   structure C = I.C

   (* IMPORTANT: instructions are given in forward order *)
   fun peephole instrs =
   let fun isStackPtr(I.Direct r) = C.sameColor(r, C.esp)
         | isStackPtr _ = false

       fun isZero(I.Immed n) = n = 0
         | isZero(I.ImmedLabel le) = I.LabelExp.valueOf le = 0
         | isZero _ = false

       fun isZeroOpt NONE = true
         | isZeroOpt (SOME opn) = isZero opn

       fun loop(code, instrs) = 
           (case code of
             [] => instrs

              (* x <- x +/- 0; 
               *)
           | I.BINARY{binOp=(I.ADDL | I.SUBL), src=I.ImmedLabel le, ...}::rest 
               where I.LabelExp.valueOf le = 0 => loop(rest, instrs)

              (* remove lea 0(r), r *)
           | I.LEA{r32, addr=I.Displace{base, disp=I.ImmedLabel le,...}}::rest
                where I.LabelExp.valueOf le = 0 andalso 
                      C.sameColor(r32,base) => loop(rest, instrs)

             (*   addl n, %esp; subl m, %esp
              * => addl (n-m), %esp     ;; when m < n
              * => -                    ;; when m = n
              * => subl (m-n), %esp     ;; when m > n
              *)
           | I.BINARY{binOp=I.ADDL, src=I.Immed n, dst=I.Direct d_i}::
             I.BINARY{binOp=I.SUBL, src=I.Immed m, dst=I.Direct d_j}::
             rest
                where C.sameColor(d_i, C.esp) andalso
                      C.sameColor(d_j, C.esp) =>
                  if (m = n) then loop (rest, instrs)
                  else if (m < n) then 
                    loop(rest,
                         I.BINARY{binOp=I.ADDL, src=I.Immed(n-m), 
                                  dst=I.Direct(C.esp)}::instrs)
                  else 
                    loop(rest,
                         I.BINARY{binOp=I.SUBL, src=I.Immed(m-n), 
                                  dst=I.Direct(C.esp)}::instrs)

             (* push folding:
              *   subl 4, %esp
              *   movl src, 0(%esp)  (where src <> %esp !!! )
              * => 
              *   pushl src
              *)
           | I.BINARY{binOp=I.SUBL, src=I.Immed 4, dst=I.Direct dst_i}:: 
             I.MOVE{mvOp=I.MOVL,src,dst=I.Displace{base,disp=I.Immed 0,...}}
             ::rest 
               where C.sameColor(base, C.esp) andalso
                     C.sameColor(dst_i, C.esp) andalso
                     not(isStackPtr src) =>
               loop(rest, I.PUSHL src::instrs)
               
             (* pop folding: 
              *   movl 0(%esp), dst   (where dst <> %esp!!!!)
              *   addl 4, %esp
              * => 
              *   popl dst
              *)
           | I.MOVE{mvOp=I.MOVL, 
                    src=I.Displace{base, disp=I.Immed 0, ...}, dst}::
             I.BINARY{binOp=I.ADDL, src=I.Immed 4, dst=I.Direct dst_i}:: 
             rest 
               where C.sameColor(base, C.esp) andalso
                     C.sameColor(dst_i,C.esp) andalso
                     not(isStackPtr dst) =>
               loop(rest, I.POP dst::instrs)

           | I.MOVE{mvOp=I.MOVL, src, dst as I.Direct _}::rest 
              where isZero src => 
                loop(rest, I.BINARY{binOp=I.XORL, src=dst, dst=dst}::instrs)

           | i::rest => loop(rest, i::instrs)
           )
   in  loop(instrs, [])
   end
end 

end

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