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/alpha32/alpha32CG.sml
ViewVC logotype

Diff of /sml/trunk/src/compiler/CodeGen/alpha32/alpha32CG.sml

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

revision 583, Thu Mar 23 21:52:30 2000 UTC revision 909, Fri Aug 24 17:48:53 2001 UTC
# Line 6  Line 6 
6    ( structure I          = Alpha32Instr    ( structure I          = Alpha32Instr
7      structure MachSpec   = Alpha32Spec      structure MachSpec   = Alpha32Spec
8      structure PseudoOps  = Alpha32PseudoOps      structure PseudoOps  = Alpha32PseudoOps
9        structure Ext        = SMLNJMLTreeExt(* generic extension *)
10      structure CpsRegs    = Alpha32CpsRegs      structure CpsRegs    = Alpha32CpsRegs
11      structure InsnProps  = Alpha32Props      structure InsnProps  = Alpha32Props
12      structure Asm        = Alpha32AsmEmitter      structure Asm        = Alpha32AsmEmitter
13      structure Shuffle    = Alpha32Shuffle      structure Shuffle    = Alpha32Shuffle
14    
15        structure CCalls     = DummyCCallsFn (Alpha32MLTree)
16        structure OmitFramePtr = struct
17          exception NotImplemented
18          structure CFG=Alpha32CFG
19          structure I=Alpha32Instr
20          val vfp = CpsRegs.vfp
21          fun omitframeptr _ = raise NotImplemented
22        end
23    
24    
25      structure MLTreeComp=      structure MLTreeComp=
26         Alpha(structure AlphaInstr = Alpha32Instr         Alpha(structure AlphaInstr = Alpha32Instr
27               structure AlphaMLTree = Alpha32MLTree               structure AlphaMLTree = Alpha32MLTree
# Line 18  Line 29 
29               structure ExtensionComp = SMLNJMLTreeExtComp               structure ExtensionComp = SMLNJMLTreeExtComp
30                 (structure I = Alpha32Instr                 (structure I = Alpha32Instr
31                  structure T = Alpha32MLTree                  structure T = Alpha32MLTree
32                    structure CFG = Alpha32CFG
33                 )                 )
34               val mode32bit = true (* simulate 32 bit mode *)               val mode32bit = true (* simulate 32 bit mode *)
35               val multCost = ref 8 (* just guessing *)               val multCost = ref 8 (* just guessing *)
# Line 26  Line 38 
38               val SMLNJfloatingPoint = true (* must be true for SML/NJ *)               val SMLNJfloatingPoint = true (* must be true for SML/NJ *)
39              )              )
40    
41      structure Alpha32Jumps =      structure Jumps =
42         AlphaJumps(structure Instr=Alpha32Instr         AlphaJumps(structure Instr=Alpha32Instr
43                    structure Shuffle=Alpha32Shuffle)                    structure Shuffle=Alpha32Shuffle)
44    
45      structure BackPatch =      structure BackPatch =
46         BBSched2(structure Flowgraph = Alpha32FlowGraph         BBSched2(structure CFG=Alpha32CFG
47                  structure Jumps = Alpha32Jumps                  structure Jumps = Jumps
48                    structure Placement = DefaultBlockPlacement(Alpha32CFG)
49                  structure Emitter = Alpha32MCEmitter)                  structure Emitter = Alpha32MCEmitter)
50    
51      structure RA =      structure RA =
52         RegAlloc         RISC_RA
53           (structure I         = Alpha32Instr           (structure I         = Alpha32Instr
54            structure MachSpec  = Alpha32Spec            structure Flowgraph = Alpha32CFG
           structure Flowgraph = Alpha32FlowGraph  
           structure CpsRegs   = Alpha32CpsRegs  
55            structure InsnProps = InsnProps            structure InsnProps = InsnProps
56            structure Rewrite   = AlphaRewrite(Alpha32Instr)            structure Rewrite   = AlphaRewrite(Alpha32Instr)
57            structure Asm       = Alpha32AsmEmitter            structure Asm       = Alpha32AsmEmitter
58              structure SpillHeur = ChaitinSpillHeur
59              structure Spill     = RASpill(structure InsnProps = InsnProps
60                                            structure Asm = Alpha32AsmEmitter)
61    
62            val sp = I.C.stackptrR            val sp = I.C.stackptrR
63            val spill = CPSRegions.spill            val spill = CPSRegions.spill
64    
65              structure SpillTable = SpillTable(Alpha32Spec)
66    
67              val architecture = Alpha32Spec.architecture
68    
69              val beginRA = SpillTable.spillInit
70    
71            fun pure _ = false            fun pure _ = false
72    
73            (* make copies *)            (* make copies *)
74            fun copyR((rds as [_], rss as [_]), _) =            structure Int =
75              struct
76                  val avail     = Alpha32CpsRegs.availR
77                  val dedicated = Alpha32CpsRegs.dedicatedR
78    
79                  fun copy((rds as [_], rss as [_]), _) =
80                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=NONE}                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=NONE}
81              | copyR((rds, rss), I.COPY{tmp, ...}) =                  | copy((rds, rss), I.COPY{tmp, ...}) =
82                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=tmp}                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=tmp}
           fun copyF((fds as [_], fss as [_]), _) =  
               I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=NONE}  
             | copyF((fds, fss), I.FCOPY{tmp, ...}) =  
               I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=tmp}  
83    
84            (* spill copy temp *)            (* spill copy temp *)
85            fun spillCopyTmp(I.COPY{tmp,dst,src,impl},loc) =                fun spillCopyTmp(an, I.COPY{tmp,dst,src,impl},loc) =
86                I.COPY{tmp=SOME(I.Displace{base=sp, disp=loc}),                    I.COPY{tmp=SOME(I.Displace{base=sp,
87                       dst=dst,src=src,impl=impl}                                               disp=SpillTable.getRegLoc loc}),
           fun spillFcopyTmp(I.FCOPY{tmp,dst,src,impl},loc) =  
               I.FCOPY{tmp=SOME(I.Displace{base=sp, disp=loc}),  
88                        dst=dst,src=src,impl=impl}                        dst=dst,src=src,impl=impl}
89    
90            (* spill register *)            (* spill register *)
91            fun spillInstrR(r,offset) =                fun spillInstr{src,spilledCell,spillLoc,an} =
92                [I.STORE{stOp=I.STL, b=sp, d=I.IMMop offset, r=r, mem=spill}]                    [I.STORE{stOp=I.STL, b=sp,
93            fun spillInstrF(r,offset) =                             d=I.IMMop(SpillTable.getRegLoc spillLoc),
94                [I.FSTORE{stOp=I.STT, b=sp, d=I.IMMop offset, r=r, mem=spill}]                             r=src, mem=spill}]
95    
96            (* reload register *)            (* reload register *)
97            fun reloadInstrR(r,offset,rest) =                fun reloadInstr{dst,spilledCell,spillLoc,an} =
98                I.LOAD{ldOp=I.LDL, b=sp, d=I.IMMop offset, r=r, mem=spill}::rest                    [I.LOAD{ldOp=I.LDL, b=sp,
99            fun reloadInstrF(r,offset,rest) =                            d=I.IMMop(SpillTable.getRegLoc spillLoc),
100                I.FLOAD{ldOp=I.LDT, b=sp, d=I.IMMop offset, r=r, mem=spill}::rest                            r=dst, mem=spill}]
101    
102                  val mode = RACore.NO_OPTIMIZATION
103              end
104    
105              structure Float =
106              struct
107                  val avail     = Alpha32CpsRegs.availF
108                  val dedicated = Alpha32CpsRegs.dedicatedF
109    
110                  fun copy((fds as [_], fss as [_]), _) =
111                      I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=NONE}
112                    | copy((fds, fss), I.FCOPY{tmp, ...}) =
113                      I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=tmp}
114    
115                  fun spillCopyTmp(an, I.FCOPY{tmp,dst,src,impl},loc) =
116                      I.FCOPY{tmp=SOME(I.Displace{base=sp,
117                                              disp=SpillTable.getFregLoc loc}),
118                              dst=dst,src=src,impl=impl}
119    
120                  fun spillInstr(_, r,loc) =
121                      [I.FSTORE{stOp=I.STT, b=sp,
122                                d=I.IMMop(SpillTable.getFregLoc loc),
123                                r=r, mem=spill}]
124    
125                  fun reloadInstr(_, r,loc) =
126                      [I.FLOAD{ldOp=I.LDT, b=sp,
127                               d=I.IMMop(SpillTable.getFregLoc loc),
128                               r=r, mem=spill}]
129    
130                  val mode = RACore.NO_OPTIMIZATION
131              end
132           )           )
133    )    )

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

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