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/OldCGen/mips/mips.sml
ViewVC logotype

Diff of /sml/trunk/src/compiler/OldCGen/mips/mips.sml

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

revision 93, Tue May 12 21:56:22 1998 UTC revision 100, Thu May 14 04:56:46 1998 UTC
# Line 18  Line 18 
18    open M    open M
19    type EA = C.label M.EA    type EA = C.label M.EA
20    
21    val error = ErrorMsg.impossible    fun bug s = ErrorMsg.impossible ("mips/mips.sml: " ^ s)
22    
23    val wtoi = Word.toIntX    val wtoi = Word.toIntX
24    
# Line 34  Line 34 
34    val emit              = C.emit    val emit              = C.emit
35    
36    fun emitlab(k,ImmedLab lab) = C.emitLabel(lab,k)    fun emitlab(k,ImmedLab lab) = C.emitLabel(lab,k)
37      | emitlab _ = error "MipsCM.emitlab"      | emitlab _ = bug "MipsCM.emitlab"
38    
39    fun define(ImmedLab lab) = C.define lab    fun define(ImmedLab lab) = C.define lab
40      | define _ = error "MipsCM.define"      | define _ = bug "MipsCM.define"
41    
42    
43    (* Register Map    (* Register Map
# Line 193  Line 193 
193    fun move(Direct a, Direct b) =    fun move(Direct a, Direct b) =
194          (case (reg_rep a, reg_rep b)          (case (reg_rep a, reg_rep b)
195            of (Freg' _, Freg' _) => emit(M.MOV_DOUBLE(b,a))            of (Freg' _, Freg' _) => emit(M.MOV_DOUBLE(b,a))
196             | (Freg' _, _) => error "MipsCM.move: destination not a float reg"             | (Freg' _, _) => bug "MipsCM.move: destination not a float reg"
197             | (_, Freg' _) => error "MipsCM.move: source not a float reg"             | (_, Freg' _) => bug "MipsCM.move: source not a float reg"
198             | (Reg' a', Reg' b') => if a'=b' then ()             | (Reg' a', Reg' b') => if a'=b' then ()
199                                     else emit(M.ADD(b,a,RegOp0)))                                     else emit(M.ADD(b,a,RegOp0)))
200      | move(ImmedLab lab, Direct dst) = emitSDI(LOADADDR(dst,lab,0))      | move(ImmedLab lab, Direct dst) = emitSDI(LOADADDR(dst,lab,0))
201      | move(Immed n, Direct dst) = load_immed(n,dst)      | move(Immed n, Direct dst) = load_immed(n,dst)
202      | move(Immed32 w, rd as Direct dst) = load_immed32(w,dst)      | move(Immed32 w, rd as Direct dst) = load_immed32(w,dst)
203      | move _ = error "MipsCM.move"      | move _ = bug "MipsCM.move"
204    
205    fun jmp (Direct r)     = emit(M.JUMP r)    fun jmp (Direct r)     = emit(M.JUMP r)
206      | jmp (ImmedLab lab) = emitBRANCH(true,Reg0,Reg0,lab)      | jmp (ImmedLab lab) = emitBRANCH(true,Reg0,Reg0,lab)
207      | jmp _              = error "MipsCM.jmp: bad target"      | jmp _              = bug "MipsCM.jmp: bad target"
208    
209    (* stackptr' is the stack pointer; pregs_offset is the stack offset    (* stackptr' is the stack pointer; pregs_offset is the stack offset
210     * of pseudo registers, it should be consistent with the offset in     * of pseudo registers, it should be consistent with the offset in
# Line 221  Line 221 
221              emit(M.LW(x,tmpR,Immed16Off (pregs_offset-2)));              emit(M.LW(x,tmpR,Immed16Off (pregs_offset-2)));
222              freeTmpReg tmpR              freeTmpReg tmpR
223          end          end
224      | loadpseudo _ = error "[loadpseudo]"      | loadpseudo _ = bug "[loadpseudo]"
225    
226    fun storepseudo(Direct x,Immed i) =    fun storepseudo(Direct x,Immed i) =
227          do_immed_mem(M.SW,x,stackptr',2*(i-1)+pregs_offset)          do_immed_mem(M.SW,x,stackptr',2*(i-1)+pregs_offset)
# Line 232  Line 232 
232              emit (M.SW(x,tmpR,Immed16Off (pregs_offset-2)));              emit (M.SW(x,tmpR,Immed16Off (pregs_offset-2)));
233              freeTmpReg tmpR              freeTmpReg tmpR
234          end          end
235      | storepseudo _ = error "[storepseudo]"      | storepseudo _ = bug "[storepseudo]"
236    
237    
238   (*   (*
# Line 246  Line 246 
246          emit(M.JUMP tmpR);          emit(M.JUMP tmpR);
247          freeTmpReg tmpR          freeTmpReg tmpR
248        end        end
249      | jmpindexb _ = error "MipsCM.jmpindexb"      | jmpindexb _ = bug "MipsCM.jmpindexb"
250    
251    
252   (* should be rewritten to use all the temp registers *)   (* should be rewritten to use all the temp registers *)
# Line 262  Line 262 
262                 (*  simple store, last first  *)                 (*  simple store, last first  *)
263                  (emit(M.SW(r,dataptr',Immed16Off(i*4)));  f(t,i-1,rest))                  (emit(M.SW(r,dataptr',Immed16Off(i*4)));  f(t,i-1,rest))
264            | f((t1,t2),i,(Direct r, OFFp j)::rest) =            | f((t1,t2),i,(Direct r, OFFp j)::rest) =
265                   bug "unexpected non-zero OFFp record fields"
266    (*
267              | f((t1,t2),i,(Direct r, OFFp j)::rest) =
268                  (emit(M.ADD(t1,r,Immed16Op(4*j)));                  (emit(M.ADD(t1,r,Immed16Op(4*j)));
269                   f((t2,t1),i,(Direct t1,OFFp 0)::rest))                   f((t2,t1),i,(Direct t1,OFFp 0)::rest))
270    *)
271            | f((t1,t2),i,(ea,p)::rest) =            | f((t1,t2),i,(ea,p)::rest) =
272                 (* convert to register-based  *)                 (* convert to register-based  *)
273                  (move(ea,Direct t1);  f((t2,t1),i,(Direct t1,p)::rest))                  (move(ea,Direct t1);  f((t2,t1),i,(Direct t1,p)::rest))
# Line 277  Line 281 
281          emit (M.ADD(z,dataptr',Immed16Op 4));          emit (M.ADD(z,dataptr',Immed16Op 4));
282          do_immed_arith(M.ADD,dataptr',dataptr',4*len)          do_immed_arith(M.ADD,dataptr',dataptr',4*len)
283        end        end
284      | record _ = error "MipsCM.record: result not a register"      | record _ = bug "MipsCM.record: result not a register"
285    
286    
287   (* should be rewritten to use all the temp registers *)   (* should be rewritten to use all the temp registers *)
# Line 285  Line 289 
289          open CPS          open CPS
290          val len = List.length vl          val len = List.length vl
291          val _ = if (len > n)          val _ = if (len > n)
292                  then error "continuation records is larger than framesize"                  then bug "continuation records is larger than framesize"
293                  else ()                  else ()
294          fun f(_,i,nil) = ()          fun f(_,i,nil) = ()
295            | f((t1,t2),i,(Direct r, SELp(j,p))::rest) =            | f((t1,t2),i,(Direct r, SELp(j,p))::rest) =
# Line 311  Line 315 
315          emit (M.ADD(z,dataptr',Immed16Op 4));          emit (M.ADD(z,dataptr',Immed16Op 4));
316          do_immed_arith(M.ADD,dataptr',dataptr',4*n)          do_immed_arith(M.ADD,dataptr',dataptr',4*n)
317        end        end
318      | recordcont _ = error "MipsCM.record: result not a register"      | recordcont _ = bug "MipsCM.record: result not a register"
319    
320    
321    (* recordStore(x, y, alwaysBoxed) records a store operation into mem[x+2*(y-1)].    (* recordStore(x, y, alwaysBoxed) records a store operation into mem[x+2*(y-1)].
# Line 380  Line 384 
384    
385      fun select(i,Direct v',Direct w) = do_immed_mem(M.LW,w,v',i*4)      fun select(i,Direct v',Direct w) = do_immed_mem(M.LW,w,v',i*4)
386        | select(i,ImmedLab lab,Direct w) = emitSDI(LOAD(w,lab,i*4))        | select(i,ImmedLab lab,Direct w) = emitSDI(LOAD(w,lab,i*4))
387        | select _ = error "MipsCM.select: bad dst"        | select _ = bug "MipsCM.select: bad dst"
388    
389    
390    fun offset(i,v,Direct w) =    fun offset(i,v,Direct w) =
# Line 392  Line 396 
396                                  do_immed_arith(M.ADD,w,tmpR,i*4);                                  do_immed_arith(M.ADD,w,tmpR,i*4);
397                                  freeTmpReg tmpR                                  freeTmpReg tmpR
398                              end                              end
399            | _          => error "MipsCM.offset: bad src")            | _          => bug "MipsCM.offset: bad src")
400      | offset _ = error "MipsCM.offset: bad dst"      | offset _ = bug "MipsCM.offset: bad dst"
401    
402    
403   (* fetchindexb(x,y,z) fetches a byte: y <- mem[x+z],   (* fetchindexb(x,y,z) fetches a byte: y <- mem[x+z],
# Line 407  Line 411 
411            emit (M.LBU(y,tmpR,Immed16Off 0));            emit (M.LBU(y,tmpR,Immed16Off 0));
412            freeTmpReg tmpR            freeTmpReg tmpR
413        end        end
414      | fetchindexb _ = error "MipsCM.fetchindexb"      | fetchindexb _ = bug "MipsCM.fetchindexb"
415    
416    
417   (*   (*
# Line 428  Line 432 
432            freeTmpReg tmpR            freeTmpReg tmpR
433        end        end
434      | storeindexb(Direct x,Direct y,Immed indx) = do_immed_mem(M.SB,x,y,indx)      | storeindexb(Direct x,Direct y,Immed indx) = do_immed_mem(M.SB,x,y,indx)
435      | storeindexb _ = error "MipsCM.storeindexb"      | storeindexb _ = bug "MipsCM.storeindexb"
436    
437    
438   (*   (*
# Line 457  Line 461 
461           of Direct x'    => do_immed_mem(M.LW,y,x',2*(z'-1))           of Direct x'    => do_immed_mem(M.LW,y,x',2*(z'-1))
462            | Immed n      => do_immed_mem(M.LW,y,Reg0,n+2*(z'-1))            | Immed n      => do_immed_mem(M.LW,y,Reg0,n+2*(z'-1))
463            | ImmedLab lab => emitSDI(LOAD(y,lab,2*(z'-1))))            | ImmedLab lab => emitSDI(LOAD(y,lab,2*(z'-1))))
464      | fetchindexl _ = error "MipsCM.fetchindexl"      | fetchindexl _ = bug "MipsCM.fetchindexl"
465    
466    
467   (*   (*
# Line 484  Line 488 
488                                            storeindexl(Direct tmpR,y,z);                                            storeindexl(Direct tmpR,y,z);
489                                            freeTmpReg tmpR                                            freeTmpReg tmpR
490                                        end                                        end
491      | storeindexl _ = error "MipsCM.storeindexl: bad args"      | storeindexl _ = bug "MipsCM.storeindexl: bad args"
492    
493    
494   (*   (*
# Line 520  Line 524 
524          three f (do_immed,x,Direct tmpR,z);          three f (do_immed,x,Direct tmpR,z);
525          freeTmpReg tmpR          freeTmpReg tmpR
526        end        end
527      | three _ _ = error "MipsCM.three: bad args"      | three _ _ = bug "MipsCM.three: bad args"
528    
529    fun add(x,y,z)        = three M.ADDU (do_immed_arith,z,x,y)    fun add(x,y,z)        = three M.ADDU (do_immed_arith,z,x,y)
530    fun orb(x,y,z)        = three M.OR  (do_immed_logical,z,x,y)    fun orb(x,y,z)        = three M.OR  (do_immed_logical,z,x,y)
# Line 557  Line 561 
561                                   sub(x, Direct tmpR, z);                                   sub(x, Direct tmpR, z);
562                                   freeTmpReg tmpR                                   freeTmpReg tmpR
563                                end                                end
564      | sub  _ = error "MipsCM.sub: mismatched args"      | sub  _ = bug "MipsCM.sub: mismatched args"
565    
566    fun notb(a,b)         = sub (a, Immed ~1, b)    fun notb(a,b)         = sub (a, Immed ~1, b)
567    
# Line 593  Line 597 
597                                              freeTmpReg tmpR                                              freeTmpReg tmpR
598                                           end                                           end
599    
600      | subt  _ = error "MipsCM.subt: mismatched args"      | subt  _ = bug "MipsCM.subt: mismatched args"
601    
602   (* The Mips multiplies two 32-bit quantities to get a 64-bit result.   (* The Mips multiplies two 32-bit quantities to get a 64-bit result.
603    * That result fits in 32 bits if and only if the high-order word is zero    * That result fits in 32 bits if and only if the high-order word is zero
# Line 622  Line 626 
626                     emit (M.ADD(tmpR,tmpR,RegOp tmpR));                     emit (M.ADD(tmpR,tmpR,RegOp tmpR));
627                     C.define ok                     C.define ok
628                 end                 end
629              | _ => error "MipsCM.mult");              | _ => bug "MipsCM.mult");
630            freeTmpReg tmpR            freeTmpReg tmpR
631        end        end
632      | mult _ = error "MipsCM.mult: result not a register"      | mult _ = bug "MipsCM.mult: result not a register"
633    
634    fun mulu(Direct x,Direct y) =    fun mulu(Direct x,Direct y) =
635        (emit(M.MULTU(x,y)); emit(M.MFLO y))        (emit(M.MULTU(x,y)); emit(M.MFLO y))
# Line 635  Line 639 
639          mulu(Direct tmpR,y);          mulu(Direct tmpR,y);
640          freeTmpReg tmpR          freeTmpReg tmpR
641        end        end
642      | mulu _ = error "mulu"      | mulu _ = bug "mulu"
643    
644    
645   (*   (*
# Line 665  Line 669 
669          divt(Direct tmpR, y);          divt(Direct tmpR, y);
670          freeTmpReg tmpR          freeTmpReg tmpR
671        end        end
672      | divt _ = error "MipsCM.divt: mismatched args"      | divt _ = bug "MipsCM.divt: mismatched args"
673    
674    fun divtu(Direct x',Direct y') = let    fun divtu(Direct x',Direct y') = let
675          val oklabel = C.newLabel()          val oklabel = C.newLabel()
# Line 690  Line 694 
694             of Direct rs => emit(M.SRAV(rd,rt,rs))             of Direct rs => emit(M.SRAV(rd,rt,rs))
695              | Immed n      =>              | Immed n      =>
696                 if n >= 32 orelse n < 0 then                 if n >= 32 orelse n < 0 then
697                     error "MipsCM.ashr: Too large a shift distance"                     bug "MipsCM.ashr: Too large a shift distance"
698                 else                 else
699                     emit(M.SRA(rd,rt,Int5 n))                     emit(M.SRA(rd,rt,Int5 n))
700              | _ => error "MipsCM.ashr")              | _ => bug "MipsCM.ashr")
701      | ashr(shamt,Immed n,dst) = let val tmpR = getTmpReg()      | ashr(shamt,Immed n,dst) = let val tmpR = getTmpReg()
702                                  in                                  in
703                                      load_immed(n,tmpR);                                      load_immed(n,tmpR);
# Line 705  Line 709 
709                                         ashr(shamt, Direct tmpR, dst);                                         ashr(shamt, Direct tmpR, dst);
710                                         freeTmpReg tmpR                                         freeTmpReg tmpR
711                                      end                                      end
712      | ashr _ = error "MipsCM.ashr: bad args"      | ashr _ = bug "MipsCM.ashr: bad args"
713    
714    fun lshr(shamt,Direct rt,Direct rd) =    fun lshr(shamt,Direct rt,Direct rd) =
715        (case shamt        (case shamt
716         of Direct rs => emit(M.SRLV(rd,rt,rs))         of Direct rs => emit(M.SRLV(rd,rt,rs))
717          | Immed n =>          | Immed n =>
718              if n >= 32 orelse n < 0 then              if n >= 32 orelse n < 0 then
719                  error "MipsCM.lshr: bad shift distance"                  bug "MipsCM.lshr: bad shift distance"
720              else              else
721                  emit(M.SRL(rd,rt,Int5 n))                  emit(M.SRL(rd,rt,Int5 n))
722          | _ => error "MipsCM.ashr")          | _ => bug "MipsCM.ashr")
723      | lshr(shamt,Immed n,dst) = let val tmpR = getTmpReg()      | lshr(shamt,Immed n,dst) = let val tmpR = getTmpReg()
724        in        in
725            load_immed(n,tmpR);            load_immed(n,tmpR);
# Line 729  Line 733 
733            freeTmpReg tmpR            freeTmpReg tmpR
734        end        end
735    
736      | lshr _ = error "MipsCM.ashr: bad args"      | lshr _ = bug "MipsCM.ashr: bad args"
737    
738    fun ashl(shamt,Direct rt,Direct rd) =    fun ashl(shamt,Direct rt,Direct rd) =
739        (case shamt        (case shamt
740             of Direct rs => emit(M.SLLV(rd,rt,rs))             of Direct rs => emit(M.SLLV(rd,rt,rs))
741           | Immed n      =>           | Immed n      =>
742                 if n >= 32 orelse n < 0 then                 if n >= 32 orelse n < 0 then
743                     error "MipsCM.ashl: Too large a shift distance"                     bug "MipsCM.ashl: Too large a shift distance"
744                 else                 else
745                     emit(M.SLL(rd,rt,Int5 n))                     emit(M.SLL(rd,rt,Int5 n))
746           | _ => error "MipsCM.ashl")           | _ => bug "MipsCM.ashl")
747      | ashl(shamt,Immed n,dst) = let val tmpR = getTmpReg()      | ashl(shamt,Immed n,dst) = let val tmpR = getTmpReg()
748                                  in                                  in
749                                      load_immed(n,tmpR);                                      load_immed(n,tmpR);
# Line 752  Line 756 
756                                      ashl(shamt,Direct tmpR,dst);                                      ashl(shamt,Direct tmpR,dst);
757                                      freeTmpReg tmpR                                      freeTmpReg tmpR
758                                    end                                    end
759      | ashl _ = error "MipsCM.ashl: bad args"      | ashl _ = bug "MipsCM.ashl: bad args"
760    
761    datatype condition = NEQ | EQL | LEQ | GEQ | LSS | GTR    datatype condition = NEQ | EQL | LEQ | GEQ | LSS | GTR
762                       | GEU | GTU | LTU | LEU                       | GEU | GTU | LTU | LEU
# Line 842  Line 846 
846          (*esac*);          (*esac*);
847          freeTmpReg tmpR          freeTmpReg tmpR
848        end        end
849      | ibranch _ = error "MipsCM.ibranch: bad args"      | ibranch _ = bug "MipsCM.ibranch: bad args"
850    
851   (*   (*
852    * bbs - branch on bit set.    * bbs - branch on bit set.
# Line 855  Line 859 
859            emitBRANCH(false,tmpR,Reg0,label);            emitBRANCH(false,tmpR,Reg0,label);
860            freeTmpReg tmpR            freeTmpReg tmpR
861        end        end
862      | bbs _ = error "MipsCM.bbs: bad args"      | bbs _ = bug "MipsCM.bbs: bad args"
863    
864    
865    fun floatreg (Direct fpr) =    fun floatreg (Direct fpr) =
866           (case reg_rep fpr           (case reg_rep fpr
867             of Freg' _ => fpr             of Freg' _ => fpr
868              | _ => error "MipsCM.floatreg: expected floatreg")              | _ => bug "MipsCM.floatreg: expected floatreg")
869      | floatreg _ = error "MipsCM.floatreg: expected floatreg"      | floatreg _ = bug "MipsCM.floatreg: expected floatreg"
870    
871    local    local
872      val real_tag = dtoi D.desc_reald      val real_tag = dtoi D.desc_reald
# Line 872  Line 876 
876            case (reg_rep n', dst)            case (reg_rep n', dst)
877             of (Freg' n, Direct dst') =>             of (Freg' n, Direct dst') =>
878                 if n mod 2 <> 0 then                 if n mod 2 <> 0 then
879                      error "MipsCM.store_float: bad float reg"                      bug "MipsCM.store_float: bad float reg"
880                 else (do_immed_mem (M.SWC1,Freg(n+1-lowOff),dst',offset+4);                 else (do_immed_mem (M.SWC1,Freg(n+1-lowOff),dst',offset+4);
881                       do_immed_mem (M.SWC1,Freg(n+lowOff),dst',offset))                       do_immed_mem (M.SWC1,Freg(n+lowOff),dst',offset))
882              | _ => error "MipsCM.store_float: bad args"              | _ => bug "MipsCM.store_float: bad args"
883    
884      fun load_float(dest',src,offset) =      fun load_float(dest',src,offset) =
885            case reg_rep dest'            case reg_rep dest'
886             of Freg' dest =>             of Freg' dest =>
887                 if dest mod 2 <> 0 then error "MipsCM.load_float.1"                 if dest mod 2 <> 0 then bug "MipsCM.load_float.1"
888                 else                 else
889                  (case src                  (case src
890                    of Direct src' =>                    of Direct src' =>
# Line 891  Line 895 
895                         in emitSDI(LOADF(Freg dest,lab,offset,tmpR));                         in emitSDI(LOADF(Freg dest,lab,offset,tmpR));
896                            freeTmpReg tmpR                            freeTmpReg tmpR
897                        end                        end
898                     | _ => error "MipsCM.load_float.3")                     | _ => bug "MipsCM.load_float.3")
899              | _ => error "MipsCM.load_float.2"              | _ => bug "MipsCM.load_float.2"
900    
901    in    in
902      fun storefloat(src,Direct dst) =      fun storefloat(src,Direct dst) =
# Line 907  Line 911 
911                       emit (M.ADD(dataptr',dataptr',Immed16Op 12));                       emit (M.ADD(dataptr',dataptr',Immed16Op 12));
912                      freeTmpReg tmpR                      freeTmpReg tmpR
913                  end)                  end)
914               | _ => error "MipsCM.storefloat: bad args")               | _ => bug "MipsCM.storefloat: bad args")
915        | storefloat _ = error "MipsCM.storefloat: bad args.2"        | storefloat _ = bug "MipsCM.storefloat: bad args.2"
916    
917      fun loadfloat(src, dst) = load_float(floatreg dst,src,0)      fun loadfloat(src, dst) = load_float(floatreg dst,src,0)
918                                            (* y <- mem[x+4*(z-1)] *)                                            (* y <- mem[x+4*(z-1)] *)
# Line 922  Line 926 
926                                  load_float(floatreg y, Direct tmpR, ~4);                                  load_float(floatreg y, Direct tmpR, ~4);
927                                  freeTmpReg tmpR                                  freeTmpReg tmpR
928                              end                              end
929               | _ => error "MipsCM.fetchindexd")               | _ => bug "MipsCM.fetchindexd")
930        | fetchindexd _ = error "MipsCM.fetchindexd"        | fetchindexd _ = bug "MipsCM.fetchindexd"
931    
932                                            (* mem[y+4*(z-1)] <- x *)                                            (* mem[y+4*(z-1)] <- x *)
933      fun storeindexd(x, Direct y, z) =      fun storeindexd(x, Direct y, z) =
# Line 936  Line 940 
940                                  store_float(floatreg x,Direct tmpR,~4);                                  store_float(floatreg x,Direct tmpR,~4);
941                                  freeTmpReg tmpR                                  freeTmpReg tmpR
942                              end                              end
943               | _ => error "MipsCM.storeindexd")               | _ => bug "MipsCM.storeindexd")
944        | storeindexd _ = error "MipsCM.storeindexd"        | storeindexd _ = bug "MipsCM.storeindexd"
945    
946    fun fprecord(tag, vl, Direct z) =    fun fprecord(tag, vl, Direct z) =
947          let open CPS          let open CPS
# Line 949  Line 953 
953                         (do_immed_mem(M.LWC1,Freg(dest+lowOff),r,j*8);                         (do_immed_mem(M.LWC1,Freg(dest+lowOff),r,j*8);
954                          do_immed_mem(M.LWC1,Freg(dest+1-lowOff),r,j*8+4);                          do_immed_mem(M.LWC1,Freg(dest+1-lowOff),r,j*8+4);
955                          f(t1,t2,f1,i,(Direct f1, OFFp 0)::rest))                          f(t1,t2,f1,i,(Direct f1, OFFp 0)::rest))
956                       | _ => error "wrong register assignment1 in mips.sml")                       | _ => bug "wrong register assignment1 in mips.sml")
957                | f(t1,t2,f1,i,(Direct r, SELp(j,p))::rest) =                | f(t1,t2,f1,i,(Direct r, SELp(j,p))::rest) =
958                     (case reg_rep r                     (case reg_rep r
959                       of (Reg' src) =>                       of (Reg' src) =>
960                          (do_immed_mem(M.LW,t1,r,j*4);                          (do_immed_mem(M.LW,t1,r,j*4);
961                           f(t2,t1,f1,i,(Direct t1,p)::rest))                           f(t2,t1,f1,i,(Direct t1,p)::rest))
962                        | _ => error "wrong register assignment3 in mips.sml")                        | _ => bug "wrong register assignment3 in mips.sml")
963                | f(t1,t2,f1,i,(Direct r, OFFp 0)::rest) =                | f(t1,t2,f1,i,(Direct r, OFFp 0)::rest) =
964                    (case reg_rep r                    (case reg_rep r
965                      of (Freg' n) =>                      of (Freg' n) =>
966                         (do_immed_mem(M.SWC1,Freg(n+1-lowOff),dataptr',i+4);                         (do_immed_mem(M.SWC1,Freg(n+1-lowOff),dataptr',i+4);
967                          do_immed_mem(M.SWC1,Freg(n+lowOff),dataptr',i);                          do_immed_mem(M.SWC1,Freg(n+lowOff),dataptr',i);
968                          f(t1,t2,f1,i-8,rest))                          f(t1,t2,f1,i-8,rest))
969                       | _ => error "wrong register assignment2 in mips.sml")                       | _ => bug "wrong register assignment2 in mips.sml")
970                | f(t1,t2,f1,i,(Direct r, OFFp j)::rest) =                | f(t1,t2,f1,i,(Direct r, OFFp j)::rest) =
971                    error "non-zero offset elements in fprecord in mips.sml"                    bug "non-zero offset elements in fprecord in mips.sml"
972                | f(t1,t2,f1,i,(ea, p)::rest) =                | f(t1,t2,f1,i,(ea, p)::rest) =
973                    (move(ea,Direct t1); f(t2,t1,f1,i,(Direct t1,p)::rest))                    (move(ea,Direct t1); f(t2,t1,f1,i,(Direct t1,p)::rest))
974    
# Line 981  Line 985 
985              emit (M.ADD(z,dataptr',Immed16Op 4));              emit (M.ADD(z,dataptr',Immed16Op 4));
986              do_immed_arith(M.ADD,dataptr',dataptr',len)              do_immed_arith(M.ADD,dataptr',dataptr',len)
987          end          end
988      | fprecord _ = error "MipsCM.fprecord: result not a register"      | fprecord _ = bug "MipsCM.fprecord: result not a register"
989    
990    end    end
991    
# Line 1026  Line 1030 
1030                                       do_immed_mem(M.SWC1,Freg(n+lowOff),                                       do_immed_mem(M.SWC1,Freg(n+lowOff),
1031                                                    dataptr',i);                                                    dataptr',i);
1032                                       deposit(r, i+8))                                       deposit(r, i+8))
1033                                  | _ => error "wrong register checkLimit")                                  | _ => bug "wrong register checkLimit")
1034    
1035                         fun restore(s, [], _) = ()                         fun restore(s, [], _) = ()
1036                           | restore(s, (Direct x)::r, i) =                           | restore(s, (Direct x)::r, i) =
# Line 1037  Line 1041 
1041                                       do_immed_mem(M.LWC1,Freg(n+lowOff),                                       do_immed_mem(M.LWC1,Freg(n+lowOff),
1042                                                    s,i);                                                    s,i);
1043                                       restore(s, r, i+8))                                       restore(s, r, i+8))
1044                                  | _ => error "wrong register checkLimit")                                  | _ => bug "wrong register checkLimit")
1045    
1046                      in deposit(fregs,4);                      in deposit(fregs,4);
1047                         move(immed desc, Direct M.heapExhaustedReg);                         move(immed desc, Direct M.heapExhaustedReg);
# Line 1098  Line 1102 
1102              emit(M.FCMP(cmp, floatreg op1, floatreg op2));              emit(M.FCMP(cmp, floatreg op1, floatreg op2));
1103              emitBRANCH_COP1(test, label)              emitBRANCH_COP1(test, label)
1104            end            end
1105          | fbranchd _ = error "MipsCM.fbranchd: insane target"          | fbranchd _ = bug "MipsCM.fbranchd: insane target"
1106    end    end
1107    
1108    

Legend:
Removed from v.93  
changed lines
  Added in v.100

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