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/compiler/CodeGen/ppc/ppcCG.sml
ViewVC logotype

Diff of /sml/trunk/src/compiler/CodeGen/ppc/ppcCG.sml

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

sml/branches/SMLNJ/src/compiler/CodeGen/ppc/ppcCG.sml revision 247, Sat Apr 17 18:47:13 1999 UTC sml/trunk/src/compiler/CodeGen/ppc/ppcCG.sml revision 1124, Thu Mar 7 19:49:22 2002 UTC
# Line 1  Line 1 
1  functor PPCCG  (*
2    (structure Emitter : EMITTER_NEW   * PPC specific backend
3       where I = PPCInstr and P = PPCPseudoOps) : MACHINE_GEN =   *)
4  struct  structure PPCCG =
5    structure I = PPCInstr    MachineGen
6    structure C = PPCCells    ( structure MachSpec   = PPCSpec
7    structure R = PPCCpsRegs      structure T          = PPCMLTree
8    structure B = PPCMLTree.BNames      structure CB         = CellsBasis
9    structure F = PPCFlowGraph      structure ClientPseudoOps = PPCClientPseudoOps
10        structure PseudoOps  = PPCPseudoOps
11        structure Ext        = SMLNJMLTreeExt(* generic extension *)
12        structure CpsRegs    = PPCCpsRegs
13        structure InsnProps  = PPCProps
14    structure Asm      = PPCAsmEmitter    structure Asm      = PPCAsmEmitter
15    structure MLTree   = PPCMLTree      structure Shuffle    = PPCShuffle
16    structure MachSpec = PPCSpec  
17    structure Ctrl = Control.MLRISC      structure CCalls     = DummyCCallsFn (PPCMLTree)
18    
19    fun error msg = ErrorMsg.impossible ("PPCCG." ^ msg)      structure OmitFramePtr = struct
20          exception NotImplemented
21    val stack = PPCInstr.Region.stack        structure CFG=PPCCFG
22    structure PPCRewrite = PPCRewrite(PPCInstr)        structure I=PPCInstr
23          val vfp = PPCCpsRegs.vfp
24    (* properties of instruction set *)        fun omitframeptr _ = raise NotImplemented
25    structure P =      end
26      PPCProps(structure PPCInstr= I  
27                   structure Shuffle=PPCShuffle)      structure MLTreeComp=
28           PPC(structure PPCInstr = PPCInstr
29               structure PPCMLTree = PPCMLTree
30               structure PseudoInstrs=
31                   PPCPseudoInstr(structure Instr=PPCInstr)
32               structure ExtensionComp = SMLNJMLTreeExtComp
33                   (structure I = PPCInstr
34                    structure T = PPCMLTree
35                    structure CFG = PPCCFG
36                    structure TS = PPCMLTreeStream
37                   )
38               val bit64mode=false
39               val multCost=ref 6 (* an estimate *)
40             )
41    
   (* Label backpatching and basic block scheduling *)  
   structure BBSched =  
     BBSched2(structure Flowgraph = F  
42               structure Jumps =               structure Jumps =
43                 PPCJumps(structure Instr=PPCInstr                 PPCJumps(structure Instr=PPCInstr
44                    structure MLTreeEval=PPCMLTreeEval
45                              structure Shuffle=PPCShuffle)                              structure Shuffle=PPCShuffle)
              structure Emitter = Emitter)  
46    
47    (* flow graph pretty printing routine *)      structure BackPatch =
48    structure PrintFlowGraph =         BBSched2(structure CFG = PPCCFG
49       PrintFlowGraphFn (structure FlowGraph = F                  structure Jumps = Jumps
50                         structure Emitter   = Asm)                  structure Props = PPCProps
51                    structure Emitter = PPCMCEmitter)
52    val intSpillCnt = Ctrl.getInt "ra-int-spills"  
53    val floatSpillCnt = Ctrl.getInt "ra-float-spills"      structure RA =
54    val intReloadCnt = Ctrl.getInt "ra-int-reloads"         RISC_RA
55    val floatReloadCnt = Ctrl.getInt "ra-float-reloads"           (structure I         = PPCInstr
56              structure CFG       = PPCCFG
57    (* register allocation *)            structure CpsRegs   = PPCCpsRegs
58    structure RegAllocation :            structure InsnProps = InsnProps
59      sig            structure Rewrite   = PPCRewrite(PPCInstr)
60        val ra : F.cluster -> F.cluster            structure SpillInstr= PPCSpillInstr(PPCInstr)
61        val cp : F.cluster -> F.cluster            structure Asm       = PPCAsmEmitter
62      end =            structure SpillHeur = ChaitinSpillHeur
63    struct            structure Spill     = RASpill(structure InsnProps = InsnProps
64                                            structure Asm = PPCAsmEmitter)
65    
66     (* spill area management *)            structure SpillTable = SpillTable(PPCSpec)
     val initialSpillOffset = 144  
     val spillOffset = ref initialSpillOffset  
     fun newOffset n =  
         if n > 4096  
         then error "newOffset - spill area is too small"  
         else spillOffset := n  
     exception RegSpills and FregSpills  
   
     val regSpills : int Intmap.intmap ref = ref(Intmap.new(0, RegSpills))  
     val fregSpills : int Intmap.intmap ref = ref(Intmap.new(0, FregSpills))  
   
     (* get spill location for general registers *)  
     fun getRegLoc reg = Intmap.map (!regSpills) reg  
       handle RegSpills => let  
           val offset = !spillOffset  
         in  
           newOffset(offset+4);  
           Intmap.add (!regSpills) (reg, offset);  
           offset  
         end  
67    
68      (* get spill location for floating registers *)            val architecture = PPCSpec.architecture
     fun getFregLoc freg = Intmap.map (!fregSpills) freg  
       handle FregSpills => let  
           val offset = !spillOffset  
           val fromInt = Word.fromInt  
           val aligned = Word.toIntX(Word.andb(fromInt offset+0w7, fromInt ~8))  
         in  
           newOffset(aligned+8);  
           Intmap.add (!fregSpills) (freg, aligned);  
           aligned  
         end  
69    
70      fun spill {regmap,instr,reg,id:B.name} = let            datatype spillOperandKind = SPILL_LOC | CONST_VAL
71        val offset = I.ImmedOp (getRegLoc(reg))            type spill_info = unit
       fun spillInstr(src) =  
         [I.ST{sz=I.Word, rs=src, ra=C.stackptrR, d=offset, mem=stack}]  
     in  
       intSpillCnt := !intSpillCnt + 1;  
       case instr  
        of I.COPY{dst as [rd], src as [rs], tmp, impl} =>  
           if rd=reg then  
             {code=spillInstr(rs),  instr=NONE,   proh=[]:int list}  
           else (case tmp  
              of SOME(I.Direct r) => let  
                   val disp = I.ImmedOp(getRegLoc(r))  
                   val loc = I.Displace{base=C.stackptrR, disp=disp}  
                   val instr=I.COPY{dst=dst, src=src, tmp=SOME(loc), impl=impl}  
                 in {code=[], instr=SOME instr, proh=[]}  
                 end  
               | _ => error "spill: COPY"  
             (*esac*))  
        | _ => let  
             val newR = C.newReg()  
             val instr' = PPCRewrite.rewriteDef(regmap, instr, reg, newR)  
           in {code=spillInstr(newR),  instr=SOME instr',  proh=[newR]}  
           end  
     end  
72    
73      fun fspill {regmap,instr,reg,id:B.name} = let            fun beforeRA _ = SpillTable.spillInit()
       val offset = I.ImmedOp (getFregLoc(reg))  
       fun spillInstr(src) =  
         [I.ST{sz=I.Double, rs=src, ra=C.stackptrR, d=offset, mem=stack}]  
     in  
       floatSpillCnt := !floatSpillCnt + 1;  
       case instr  
       of I.FCOPY{dst as [fd], src as [fs], tmp, impl} =>         (* reg = fd *)  
           if reg=fd then  
             {code=spillInstr(fs),   instr=NONE,   proh=[]}  
           else (case tmp  
              of SOME(I.FDirect r) => let  
                   val disp=I.ImmedOp(getFregLoc(r))  
                   val loc = I.Displace{base=C.stackptrR, disp=disp}  
                   val instr=I.FCOPY{dst=dst, src=src, tmp=SOME(loc), impl=impl}  
                 in {code=[], instr=SOME instr, proh=[]}  
                 end  
               | _ => error "spill: COPY"  
             (*esac*))  
        | _ => let  
             val newR = C.newFreg()  
             val instr' = PPCRewrite.frewriteDef(regmap, instr, reg, newR)  
           in {code=spillInstr(newR),  instr=SOME instr',  proh=[newR]}  
           end  
     end  
   
     fun reload{regmap,instr,reg,id:B.name} = let  
       val offset = I.ImmedOp (getRegLoc(reg))  
       fun reloadInstr(dst, rest) =  
         I.L{sz=I.Word, rt=dst, ra=C.stackptrR, d=offset, mem=stack}::rest  
     in  
       intReloadCnt := !intReloadCnt + 1;  
       case instr  
       of I.COPY{dst=[rd], src=[rs], ...} =>     (* reg = rs *)  
            {code=reloadInstr(rd, []),   proh=[]:int list}  
        | _ => let  
              val newR = C.newReg()  
              val instr' = PPCRewrite.rewriteUse(regmap, instr, reg, newR)  
            in {code=reloadInstr(newR, [instr']), proh=[newR]}  
            end  
     end  
74    
75      fun freload {regmap, instr, reg, id:B.name} = let            val sp = I.C.stackptrR
76        val offset = I.ImmedOp (getFregLoc(reg))            val spill = CPSRegions.spill
       fun reloadInstr(dst, rest) =  
         I.L{sz=I.Double, rt=dst, ra=C.stackptrR, d=offset, mem=stack}::rest  
     in  
       floatReloadCnt := !floatReloadCnt + 1;  
       case instr  
       of I.FCOPY{dst=[fd], src=[fs], ...} =>    (* reg = fs *)  
            {code=reloadInstr(fd, []), proh=[]}  
        | _ => let  
              val newR = C.newFreg()  
              val instr' = PPCRewrite.frewriteUse(regmap, instr, reg, newR)  
            in {code=reloadInstr(newR, [instr']), proh=[newR]}  
            end  
     end  
77    
78      fun spillInit () =            fun pure _ = false
       (spillOffset := initialSpillOffset;  
        regSpills := Intmap.new(8, RegSpills);  
        fregSpills := Intmap.new(8, FregSpills))  
79    
80      structure GR = GetReg(val nRegs=32 val available=R.availR)            structure Int =
81      structure FR = GetReg(val nRegs=32 val available=R.availF)            struct
82                 val avail     = PPCCpsRegs.availR
83                 val dedicated = PPCCpsRegs.dedicatedR
84    
85      structure PPCRa =               fun mkDisp loc = T.LI(T.I.fromInt(32, SpillTable.getRegLoc loc))
        PPCRegAlloc(structure P = P  
                        structure I = PPCInstr  
                        structure F = F  
                        structure Asm = Asm)  
86    
87      (* register allocation for general purpose registers *)               fun spillLoc{info, an, cell, id} =
88      structure IntRa =                    {opnd=I.Displace{base=sp, disp=mkDisp(RAGraph.FRAME id), mem=spill},
89        PPCRa.IntRa                     kind=SPILL_LOC}
         (structure RaUser = struct  
            structure I = PPCInstr  
            structure B = B  
90    
91             val getreg = GR.getreg               val mode = RACore.NO_OPTIMIZATION
            val spill = spill  
            val reload = reload  
            val nFreeRegs = length R.availR  
            val dedicated = R.dedicatedR  
            fun copyInstr((rds, rss), I.COPY{tmp, ...}) =  
              I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=tmp}  
          end)  
   
     (* register allocation for floating point registers *)  
     structure FloatRa =  
       PPCRa.FloatRa  
         (structure RaUser = struct  
            structure I = PPCInstr  
            structure B = B  
   
            val getreg = FR.getreg  
            val spill = fspill  
            val reload = freload  
            val nFreeRegs = length R.availF  
            val dedicated = R.dedicatedF  
            fun copyInstr((fds, fss), I.FCOPY{tmp, ...}) =  
              I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=tmp}  
          end)  
   
     val iRegAlloc = IntRa.ra IntRa.REGISTER_ALLOCATION []  
     val fRegAlloc = FloatRa.ra FloatRa.REGISTER_ALLOCATION []  
     val iCopyProp = IntRa.ra IntRa.COPY_PROPAGATION []  
     val fCopyProp = FloatRa.ra FloatRa.COPY_PROPAGATION []  
   
     fun ra cluster = let  
       val pg = PrintFlowGraph.printCluster TextIO.stdOut  
       fun intRa cluster = (GR.reset(); iRegAlloc cluster)  
       fun floatRa cluster = (FR.reset(); fRegAlloc cluster)  
     in spillInit(); (floatRa o intRa) cluster  
92      end      end
93      val cp = fCopyProp o iCopyProp           structure Float =
94    end (* RegAllocation *)           struct
95                 val avail     = PPCCpsRegs.availF
96                 val dedicated = PPCCpsRegs.dedicatedF
97    
98    val optimizerHook : (F.cluster->F.cluster) option ref = ref NONE               fun mkDisp loc = T.LI(T.I.fromInt(32, SpillTable.getFregLoc loc))
99    
100   (* primitives for generation of DEC alpha instruction flowgraphs *)               fun spillLoc(S, an, loc) =
101    structure FlowGraphGen =                  I.Displace{base=sp, disp=mkDisp(RAGraph.FRAME loc), mem=spill}
      FlowGraphGen(structure Flowgraph = F  
                   structure InsnProps = P  
                   structure MLTree = MLTree  
                   val optimize = optimizerHook  
                   val output = BBSched.bbsched o RegAllocation.ra)  
   
   (* compilation of CPS to MLRISC *)  
   structure MLTreeGen =  
      MLRiscGen(structure MachineSpec=PPCSpec  
                structure MLTreeComp=  
                   PPC(structure Flowgen=FlowGraphGen  
                       structure PPCInstr=PPCInstr  
                       structure PPCMLTree=PPCMLTree  
                       structure PseudoInstrs=  
                         PPCPseudoInstr(structure Instr=PPCInstr)  
                       val rs6000flag=false)  
                structure Cells=PPCCells  
                structure C=PPCCpsRegs  
                structure PseudoOp=PPCPseudoOps)  
   
   val copyProp = RegAllocation.cp  
   val codegen = MLTreeGen.codegen  
   val finish = BBSched.finish  
 end  
102    
103                 val mode = RACore.NO_OPTIMIZATION
104             end
105            )
106      )

Legend:
Removed from v.247  
changed lines
  Added in v.1124

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