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

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

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