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

sml/branches/SMLNJ/src/compiler/CodeGen/alpha32/alpha32CG.sml revision 469, Wed Nov 10 22:42:52 1999 UTC sml/trunk/src/compiler/CodeGen/alpha32/alpha32CG.sml revision 823, Tue May 8 21:25:15 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  = AlphaProps(Alpha32Instr)      structure InsnProps  = Alpha32Props
12      structure Asm        = Alpha32AsmEmitter      structure Asm        = Alpha32AsmEmitter
13        structure Shuffle    = Alpha32Shuffle
14    
15        structure CCalls     = DummyCCallsFn (Alpha32MLTree)
16        structure OmitFramePtr = struct
17          exception NotImplemented
18          structure F=Alpha32FlowGraph
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
28               structure PseudoInstrs = Alpha32PseudoInstrs               structure PseudoInstrs = Alpha32PseudoInstrs
29                 structure ExtensionComp = SMLNJMLTreeExtComp
30                   (structure I = Alpha32Instr
31                    structure T = Alpha32MLTree
32                   )
33               val mode32bit = true (* simulate 32 bit mode *)               val mode32bit = true (* simulate 32 bit mode *)
34               val multCost = ref 8 (* just guessing *)               val multCost = ref 8 (* just guessing *)
35               val useMultByConst = ref false (* just guessing *)               val useMultByConst = ref false (* just guessing *)
36                 val byteWordLoadStores = ref false
37                 val SMLNJfloatingPoint = true (* must be true for SML/NJ *)
38              )              )
39    
40      structure Alpha32Jumps =      structure Jumps =
41         AlphaJumps(structure Instr=Alpha32Instr         AlphaJumps(structure Instr=Alpha32Instr
42                    structure Shuffle=Alpha32Shuffle)                    structure Shuffle=Alpha32Shuffle)
43    
44      structure BackPatch =      structure BackPatch =
45         BBSched2(structure Flowgraph = Alpha32FlowGraph         BBSched2(structure Flowgraph = Alpha32FlowGraph
46                  structure Jumps = Alpha32Jumps                  structure Jumps = Jumps
47                  structure Emitter = Alpha32MCEmitter)                  structure Emitter = Alpha32MCEmitter)
48    
49      structure RA =      structure RA =
50         RegAlloc2         RISC_RA
51           (structure I         = Alpha32Instr           (structure I         = Alpha32Instr
           structure MachSpec  = Alpha32Spec  
52            structure Flowgraph = Alpha32FlowGraph            structure Flowgraph = Alpha32FlowGraph
           structure CpsRegs   = Alpha32CpsRegs  
53            structure InsnProps = InsnProps            structure InsnProps = InsnProps
54            structure Rewrite   = AlphaRewrite(Alpha32Instr)            structure Rewrite   = AlphaRewrite(Alpha32Instr)
55            structure Asm       = Alpha32AsmEmitter            structure Asm       = Alpha32AsmEmitter
56              structure SpillHeur = ChaitinSpillHeur
57              structure Spill     = RASpill(structure InsnProps = InsnProps
58                                            structure Asm = Alpha32AsmEmitter)
59    
60            val sp = I.C.stackptrR            val sp = I.C.stackptrR
61            val stack = I.Region.stack            val spill = CPSRegions.spill
62    
63              structure SpillTable = SpillTable(Alpha32Spec)
64    
65              val architecture = Alpha32Spec.architecture
66    
67              val beginRA = SpillTable.spillInit
68    
69            fun pure _ = false            fun pure _ = false
70    
71            (* make copies *)            (* make copies *)
72            fun copyR((rds as [_], rss as [_]), _) =            structure Int =
73              struct
74                  val avail     = Alpha32CpsRegs.availR
75                  val dedicated = Alpha32CpsRegs.dedicatedR
76    
77                  fun copy((rds as [_], rss as [_]), _) =
78                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=NONE}                I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=NONE}
79              | copyR((rds, rss), I.COPY{tmp, ...}) =                  | copy((rds, rss), I.COPY{tmp, ...}) =
80                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}  
81    
82            (* spill copy temp *)            (* spill copy temp *)
83            fun spillCopyTmp(I.COPY{tmp,dst,src,impl},loc) =                fun spillCopyTmp(an, I.COPY{tmp,dst,src,impl},loc) =
84                I.COPY{tmp=SOME(I.Displace{base=sp, disp=loc}),                    I.COPY{tmp=SOME(I.Displace{base=sp,
85                       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}),  
86                        dst=dst,src=src,impl=impl}                        dst=dst,src=src,impl=impl}
87    
88            (* spill register *)            (* spill register *)
89            fun spillInstrR(r,offset) =                fun spillInstr{src,spilledCell,spillLoc,an} =
90                [I.STORE{stOp=I.STL, b=sp, d=I.IMMop offset, r=r, mem=stack}]                    [I.STORE{stOp=I.STL, b=sp,
91            fun spillInstrF(r,offset) =                             d=I.IMMop(SpillTable.getRegLoc spillLoc),
92                [I.FSTORE{stOp=I.STT, b=sp, d=I.IMMop offset, r=r, mem=stack}]                             r=src, mem=spill}]
93    
94            (* reload register *)            (* reload register *)
95            fun reloadInstrR(r,offset,rest) =                fun reloadInstr{dst,spilledCell,spillLoc,an} =
96                I.LOAD{ldOp=I.LDL, b=sp, d=I.IMMop offset, r=r, mem=stack}::rest                    [I.LOAD{ldOp=I.LDL, b=sp,
97            fun reloadInstrF(r,offset,rest) =                            d=I.IMMop(SpillTable.getRegLoc spillLoc),
98                I.FLOAD{ldOp=I.LDT, b=sp, d=I.IMMop offset, r=r, mem=stack}::rest                            r=dst, mem=spill}]
99    
100                  val mode = RACore.NO_OPTIMIZATION
101              end
102    
103              structure Float =
104              struct
105                  val avail     = Alpha32CpsRegs.availF
106                  val dedicated = Alpha32CpsRegs.dedicatedF
107    
108                  fun copy((fds as [_], fss as [_]), _) =
109                      I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=NONE}
110                    | copy((fds, fss), I.FCOPY{tmp, ...}) =
111                      I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=tmp}
112    
113                  fun spillCopyTmp(an, I.FCOPY{tmp,dst,src,impl},loc) =
114                      I.FCOPY{tmp=SOME(I.Displace{base=sp,
115                                              disp=SpillTable.getFregLoc loc}),
116                              dst=dst,src=src,impl=impl}
117    
118                  fun spillInstr(_, r,loc) =
119                      [I.FSTORE{stOp=I.STT, b=sp,
120                                d=I.IMMop(SpillTable.getFregLoc loc),
121                                r=r, mem=spill}]
122    
123                  fun reloadInstr(_, r,loc) =
124                      [I.FLOAD{ldOp=I.LDT, b=sp,
125                               d=I.IMMop(SpillTable.getFregLoc loc),
126                               r=r, mem=spill}]
127    
128                  val mode = RACore.NO_OPTIMIZATION
129              end
130           )           )
131    )    )

Legend:
Removed from v.469  
changed lines
  Added in v.823

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