home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / sml_nj / 93src.lha / src / m68 / m68mcode.sml < prev   
Encoding:
Text File  |  1993-02-07  |  16.1 KB  |  511 lines
  1. (* Copyright 1989 by AT&T Bell Laboratories *)
  2. structure M68MCode : M68MCODER = struct
  3.  
  4. (* DEBUG
  5. fun diag (s : string) f x =
  6.     f x handle e =>
  7.         (print "?exception "; print (System.exn_name e);
  8.          print " in basicm68."; print s; print "\n";
  9.          raise e)
  10. *)
  11.  
  12. structure Jumps = struct
  13.     datatype JumpKind = Jcc of int | LEA of int | FJcc of int | LABPTR of int
  14.             | MODE
  15.   datatype Size = Byte | Word | Long
  16.   
  17.   fun sizeint i =
  18.       if i < 128 andalso i > ~129 then Byte
  19.       else if i < 32768 andalso i > ~32769 then Word
  20.       else Long
  21.   
  22.   exception TooBig (* pc relative addressing only has 16-bit displacement *)
  23.   
  24.   fun sizejump (LEA _, _,s,d) = (* pc relative addressing *)
  25.       (case sizeint (d - s - 2) of
  26.             Byte => 4
  27.           | Word => 4
  28.           | Long => 8)
  29.     | sizejump (LABPTR _, _, _, _) = 4
  30.     | sizejump (Jcc _, _, s, d) =
  31.       (case sizeint (d - s - 2) of
  32.             Byte => 2
  33.           | Word => 4
  34.           | Long => 6)
  35.     | sizejump (FJcc _, _, s, d) =
  36.       (case sizeint (d - s - 2) of
  37.             Byte => 4
  38.           | Word => 4
  39.           | Long => 6)
  40.     | sizejump (MODE,_,_,_) = 2
  41.   
  42.   (* DEBUG val sizejump = diag "sizejump" sizejump *)
  43.  
  44. fun eword i = chr(Bits.andb(Bits.rshift(i,8),255)) ^ chr(Bits.andb(i,255))
  45.  
  46. fun elong i = eword(Bits.rshift(i,16)) ^ eword(Bits.andb(i,65535))
  47.  
  48. val emitlong = elong
  49.  
  50. fun signedbyte i = if i < 0 then signedbyte (256 + i) else i
  51.   
  52.   exception Illegal
  53.   
  54.   fun emitjump (Jcc(opcode),2,s,d) =
  55.       (case (d-s-2) of
  56.              0 => eword(20081) (* nop *)
  57.            | _ => eword(opcode + signedbyte (d - s - 2)))
  58.     | emitjump (Jcc(opcode),4,s,d) = eword(opcode) ^ eword(d-s-2)
  59.     | emitjump(Jcc(opcode),6,s,d) = eword(opcode+255) ^ elong(d-s-2)
  60.     | emitjump(LABPTR i, _,s,d) = elong(d-s+i)
  61.     | emitjump (LEA(opcode),4,s,d) = (* pc relative *)
  62.       eword(opcode+58) ^ eword (d-s-2)
  63.     | emitjump (LEA(opcode),8,s,d) = (* pc relative *)
  64.       eword(opcode+59) ^ eword 368 ^ elong (d-s-2)
  65.     | emitjump (FJcc(cond),4,s,d) =
  66.       eword(62080+cond) ^ eword(d-s-2)
  67.     | emitjump (FJcc(cond),6,s,d) =
  68.       eword(62144+cond) ^ elong(d-s-2)
  69.     | emitjump (MODE,2,s,d) =
  70.       let val x = Integer.-(d,s)
  71.        in if x < 32768 andalso ~32768 <= x
  72.          then eword(d-s) 
  73.          else raise Illegal
  74.       end
  75.  
  76.   (* DEBUG val emitjump = diag "emitjump" emitjump *)
  77. end (* structure Jumps *)
  78.  
  79. structure Emitter : BACKPATCH = Backpatch(Jumps)
  80.  
  81. structure Coder : M68CODER = struct
  82.  
  83. open Emitter
  84. open Jumps
  85.  
  86. val emitword = fn i => emitstring(eword i)
  87. val emitlong = fn i => emitstring(elong i)
  88.  
  89. datatype Register = DataReg of int
  90.           | AddrReg of int
  91.           | FloatReg of int
  92.           | PC
  93.  
  94. datatype EA = Direct of Register
  95.         | PostInc of Register
  96.         | PreDec of Register
  97.         | Displace of Register * int
  98.         | Index of Register * int * Register * Size
  99.         | Immedlab of Label
  100.         | Immed of int
  101.         | Abs of int
  102.         | Address of Label
  103.  
  104. val d0 = DataReg 0
  105. and d1 = DataReg 1
  106. and d2 = DataReg 2
  107. and d3 = DataReg 3
  108. and d4 = DataReg 4
  109. and d5 = DataReg 5
  110. and d6 = DataReg 6
  111. and d7 = DataReg 7
  112. and a0 = AddrReg 0
  113. and a1 = AddrReg 1
  114. and a2 = AddrReg 2
  115. and a3 = AddrReg 3
  116. and a4 = AddrReg 4
  117. and a5 = AddrReg 5
  118. and a6 = AddrReg 6
  119. and sp = AddrReg 7
  120. and fp0 = FloatReg 0
  121. and fp1 = FloatReg 1
  122. and fp2 = FloatReg 2
  123. and fp3 = FloatReg 3
  124. and fp4 = FloatReg 4
  125. and fp5 = FloatReg 5
  126. and fp6 = FloatReg 6
  127. and fp7 = FloatReg 7
  128.  
  129. exception BadLabelUse
  130.  
  131. (* DEBUG
  132. fun diag (s : string) f x =
  133.     f x handle e =>
  134.         (print "?exception "; print (System.exn_name e);
  135.          print " in m68mcode."; print s; print "\n";
  136.          raise e)
  137. *)
  138.  
  139. fun reg (Direct(DataReg d)) = d
  140.   | reg (Direct(AddrReg a)) = a
  141.   | reg (PostInc(AddrReg a)) = a
  142.   | reg (PreDec(AddrReg a)) = a
  143.   | reg (Displace(AddrReg a,_)) = a
  144.   | reg (Displace(DataReg a,_)) = 0
  145.   | reg (Index(PC,_,_,_)) = 3
  146.   | reg (Index(AddrReg a,_,_,_)) = a
  147.   | reg (Abs i) = (case sizeint i of
  148.               Byte => 0
  149.             | Word => 0
  150.             | Long => 1)
  151.   | reg (Immed _) = 4
  152.   | reg (Address _) = 2
  153.  
  154. (* DEBUG val reg = diag "reg" reg *)
  155.  
  156. fun mode (Direct(DataReg _)) = 0
  157.   | mode (Direct(AddrReg _)) = 1
  158.   | mode (Displace(AddrReg _, 0)) = 2
  159.   | mode (PostInc(AddrReg _)) = 3
  160.   | mode (PreDec(AddrReg _)) = 4
  161.   | mode (Displace(AddrReg _,_)) = 5
  162.   | mode (Displace(DataReg _,_)) = 6
  163.   | mode (Index(PC,_,_,_)) = 7
  164.   | mode (Index(AddrReg _,_,_,_)) = 6
  165.   | mode (Abs _) = 7
  166.   | mode (Immed _) = 7
  167.   | mode (Address _) = 7
  168.  
  169. (* DEBUG val mode = diag "mode" mode *)
  170.  
  171. exception BadReal = IEEEReal.BadReal
  172. fun realconst s = emitstring(IEEEReal.realconst s)
  173.  
  174. fun scale Byte = 0
  175.   | scale Word = 512
  176.   | scale Long = 1024
  177.  
  178. fun emitext (Immed i) = emitlong i
  179.   | emitext (Abs i) =
  180.     (case sizeint i of
  181.           Byte => emitword i
  182.         | Word => emitword i
  183.         | Long => emitlong i)
  184.   | emitext (Direct _) = ()
  185.   | emitext (PostInc _) = ()
  186.   | emitext (PreDec _) = ()
  187.   | emitext (Displace(AddrReg _, 0)) = ()
  188.   | emitext (Displace (AddrReg _, i)) = emitword i
  189.   | emitext (Displace (DataReg d, 0)) = emitword(d*4096+2448)
  190.   | emitext (Displace (DataReg d, i)) = (emitword(d*4096+2464); emitword i)
  191.   | emitext (Index (_,disp,DataReg d,s)) =
  192.     emitword(d * 4096 + 2048 + scale s + signedbyte disp)
  193.   | emitext (Index (_,disp,AddrReg d,s)) =
  194.     emitword(32768 + d * 4096 + 2048 + scale s + signedbyte disp)
  195.   | emitext (Address lab) = jump(MODE,lab)
  196.  
  197. (* DEBUG val emitext = diag "emitext" emitext *)
  198.  
  199. fun emitF (opcode, Direct(FloatReg a), Direct(FloatReg b)) =
  200.     (emitword(61952); emitword(opcode+128*b+1024*a))
  201.   | emitF (opcode, src, Direct(FloatReg f)) =
  202.     (emitword(61952 + 8 * mode src + reg src);
  203.      emitword(opcode+21504+128*f);
  204.      emitext src)
  205.   | emitF (opcode, Direct(FloatReg f), dest) =
  206.     (emitword(61952 + 8 * mode dest + reg dest);
  207.      emitword(opcode+21504+128*f);
  208.      emitext dest)
  209.  
  210. (* DEBUG val emitF = diag "emitF" emitF *)
  211.  
  212. fun rts() = emitword 20085
  213.  
  214. fun exg (Direct(AddrReg a),Direct(AddrReg b)) =
  215.     if a = b then () else emitword(49480 + 512 * a + b)
  216.   | exg (Direct(DataReg a),Direct(DataReg b)) =
  217.     if a = b then () else emitword(49472 + 512 * a + b)
  218.   | exg (Direct(AddrReg b),Direct(DataReg a)) =
  219.     emitword(49544 + 512 * a + b)
  220.   | exg (Direct(DataReg a),Direct(AddrReg b)) =
  221.     emitword(49544 + 512 * a + b)
  222.  
  223. (* DEBUG val exg = diag "exg" exg *)
  224.  
  225. fun pea (Direct _) = raise Illegal
  226.   | pea (PreDec _) = raise Illegal
  227.   | pea (PostInc _) = raise Illegal
  228.   | pea (Immed _) = raise Illegal
  229.   | pea (Address lab) = (jump(LEA(18496),lab))
  230.   | pea src = (emitword(18496 + 8 * mode src + reg src); emitext src)
  231.  
  232. (* DEBUG val pea = diag "pea" pea *)
  233.  
  234. fun movl (_,Immed _) = raise Illegal
  235.   (* labels not implemented *)
  236.   (* MOVEA *)
  237.   | movl (Address lab,Direct(AddrReg a)) = jump(LEA(8256+512*a),lab)
  238.   | movl (src,Direct(AddrReg a)) =
  239.     (emitword(8256 + a * 512 + mode src * 8 + reg src); emitext src)
  240.   (* CLR *)
  241.   | movl(Immed 0,dest) =
  242.     (emitword(17024 + reg dest + 8 * mode dest); emitext dest)
  243.   (* MOVEQ/MOVE *)
  244.   | movl (src as (Immed i),dest as (Direct(DataReg d))) =
  245.     (case sizeint i of
  246.        Byte => emitword(28672 + 512 * d + signedbyte i)
  247.      | _ => (emitword(8192+512*reg dest+64*mode dest+8*mode src+reg src);
  248.          emitext src))
  249.   (* general MOVE *)
  250.   | movl (src,dest) =
  251.     (emitword(8192 + 512 * reg dest + 64 * mode dest + 8 * mode src + reg src);
  252.      emitext src;
  253.      emitext dest)
  254.  
  255. fun exg (Direct (DataReg a), Direct(DataReg b)) = emitword(49472+a*512+b)
  256.   | exg (Direct (AddrReg a), Direct(AddrReg b)) = emitword(49480+a*512+b)
  257.   | exg (Direct (DataReg a), Direct(AddrReg b)) = emitword(49544+a*512+b)
  258.   | exg (Direct (AddrReg a), Direct(DataReg b)) = emitword(49544+b*512+a)
  259.  
  260. (* DEBUG val movl = diag "movl" movl *)
  261.  
  262. fun addl (_,Immed _) = raise Illegal
  263.   (* ADDQ/ADDA *)
  264.   | addl (src as (Immed i),dest as (Direct(AddrReg a))) =
  265.     if i <= 8 andalso i >= 1
  266.     then emitword(20608 + 512 * (i mod 8) + 8 * mode dest + reg dest)
  267.     else (emitword(53696 + 512 * a + 8 * mode src + reg src); emitext src)
  268.   | addl (src,Direct(AddrReg a)) =
  269.     (emitword(53696 + 512 * a + 8 * mode src + reg src); emitext src)
  270.   (* ADDQ/ADDI *)
  271.   | addl (src as (Immed i),dest) =
  272.     if i <= 8 andalso i >= 1
  273.     then (emitword(20608+512*(i mod 8)+8*mode dest+reg dest); emitext dest)
  274.     else (emitword(1664 + 8 * mode dest + reg dest); emitext src; emitext dest)
  275.   (* general ADD *)
  276.   | addl (src,Direct(DataReg d)) = 
  277.     (emitword(53376 + 512 * d + reg src + 8 * mode src); emitext src)
  278.   | addl (Direct(DataReg d),dest) =
  279.     (emitword(53632 + 512 * d  + reg dest + 8 * mode dest); emitext dest)
  280.  
  281. (* DEBUG val addl = diag "addl" addl *)
  282.  
  283. fun lea (Direct _,_) = raise Illegal
  284.   | lea (PreDec _,_) = raise Illegal
  285.   | lea (PostInc _,_) = raise Illegal
  286.   | lea (Immed _,_) = raise Illegal
  287.   | lea (Address lab,Direct(AddrReg a)) = jump(LEA(16832+512*a),lab)
  288.   | lea (src,Direct(AddrReg a)) =
  289.         (emitword(16832 + 512 * a + 8 * mode src + reg src); emitext src)
  290.   | lea (Displace(a, i), dest as (Direct(DataReg _))) =
  291.     (movl(Immed(i), dest); addl(Direct(a), dest))
  292.   | lea _ = raise Illegal
  293.  
  294. (* DEBUG val lea = diag "lea" lea *)
  295.  
  296. fun subl (_,Immed _) = raise Illegal
  297.   (* SUBQ/SUBA *)
  298.   | subl (src  as (Immed i),dest as (Direct(AddrReg a))) =
  299.     if i <= 8 andalso i >= 1
  300.     then emitword(20864 + 512 * (i mod 8) + 8 * mode dest + reg dest)
  301.     else (emitword(37312 + 512 * a + 8 * mode src + reg src); emitext src)
  302.   (* SUBA *)
  303.   | subl (src,Direct(AddrReg a)) =
  304.     (emitword(37312 + 512 * a + 8 * mode src + reg src); emitext src)
  305.   (* SUBQ/SUBI *)
  306.   | subl (src as (Immed i),dest) =
  307.     if i <= 8 andalso i >= 1
  308.     then (emitword(20864+512*(i mod 8)+8 * mode dest + reg dest); emitext dest)
  309.     else (emitword(1152 + reg dest + 8 * mode dest); emitext src; emitext dest)
  310.   (* general SUB *)
  311.   | subl (src,Direct(DataReg d)) = 
  312.     (emitword(36992 + 512 * d + reg src + 8 * mode src); emitext src)
  313.   | subl (Direct(DataReg d),dest) = 
  314.     (emitword(37248 + 512 * d + reg dest + 8 * mode dest); emitext dest)
  315.  
  316. (* DEBUG val subl = diag "subl" subl *)
  317.  
  318. fun eorl (_, Direct(AddrReg _)) = raise Illegal
  319.   | eorl (Immed i, dest) =
  320.     if i<65536
  321.     then (emitword(2624 + reg dest + 8*mode dest); emitword i)
  322.     else raise Match
  323.   | eorl (Direct(DataReg d), dest) =
  324.     (emitword(45440 + 512*d + 8*mode dest + reg dest); emitext dest)
  325.   | eorl _ = raise Illegal
  326.  
  327. (* DEBUG val eorl = diag "eorl" eorl *)
  328.  
  329. fun orl (_, Direct(AddrReg _)) = raise Illegal
  330.   | orl (Immed i, dest) =
  331.     if i<65536
  332.     then (emitword(64 + reg dest + 8*mode dest); emitword i)
  333.     else raise Match
  334.   | orl (src, Direct(DataReg d)) =
  335.     (emitword(32896 + 512*d + 8*mode src + reg src); emitext src)
  336.   | orl (Direct(DataReg d), dest) =
  337.     (emitword(33152 + 512*d + 8*mode dest + reg dest); emitext dest)
  338.   | orl _ = raise Illegal
  339.  
  340. (* DEBUG val orl = diag "orl" orl *)
  341.  
  342. fun andl (_, Direct(AddrReg _)) = raise Illegal
  343.   | andl (Immed i, dest) =
  344.     if i<65536
  345.     then (emitword(576 + reg dest + 8*mode dest); emitword i)
  346.     else raise Match
  347.   | andl (src, Direct(DataReg d)) =
  348.     (emitword(49280 + 512*d + 8*mode src + reg src); emitext src)
  349.   | andl (Direct(DataReg d), dest) =
  350.     (emitword(49536 + 512*d + 8*mode dest + reg dest); emitext dest)
  351.   | andl _ = raise Illegal
  352.  
  353. (* DEBUG val andl = diag "andl" andl *)
  354.  
  355. fun mull (src,Direct(DataReg d)) =
  356.     (emitword(19456 + reg src + 8 * mode src);
  357.      emitword(2048+4096*d);
  358.      emitext src)
  359.  
  360. (* DEBUG val mull = diag "mull" mull *)
  361.  
  362. fun divl (src,Direct(DataReg d)) =
  363.     (emitword(19520 + reg src + 8 * mode src);
  364.          emitword(2048 + 4097 (*yes, 4097!*) * d);
  365.      emitext src)
  366.  
  367. (* DEBUG val divl = diag "divl" divl *)
  368.  
  369. fun movb (_,Immed _) = raise Illegal
  370.   (* labels not implemented *)
  371.   | movb (Address _,_) = raise Illegal
  372.   | movb (_,Address _) = raise Illegal
  373.   (* CLR *)
  374.   | movb (Immed 0, dest) =
  375.     (emitword(16896 + reg dest + 8 * mode dest); emitext dest)
  376.   (* general MOVE *)
  377.   | movb (src,dest) = let
  378.       (* for this very crude hack see lg *)
  379.       fun emitSrcExt (Immed n) = emitword n
  380.     | emitSrcExt src = emitext src
  381.     in
  382.     emitword(4096 + 512 * reg dest + 64 * mode dest + 
  383.          8 * mode src + reg src);
  384.     emitSrcExt src;
  385.     emitext dest
  386.     end
  387.  
  388. (* DEBUG val movb = diag "movb" movb *)
  389.  
  390. fun shift dir =
  391.  let val dr = dir * 256
  392.      fun f (Immed 0, _) = ()
  393.        | f (Immed 8, Direct(DataReg d)) = emitword(57472+dr+d)
  394.        | f (Immed i, Direct(DataReg d)) =
  395.      if  i<1 orelse i>7 then raise Illegal else emitword(57472+dr + 512*i + d)
  396.        | f (Immed 1, Direct _) = raise Illegal
  397.        | f (Immed 1, dest) =
  398.        (emitword(57536 + dr + 8*mode dest + reg dest); emitext dest)
  399.        | f (Direct(DataReg s), Direct(DataReg d)) = (emitword(57504+dr + 512*s + d))
  400.        | f _ = raise Illegal
  401.  in f
  402.  end
  403.  
  404. val asll = shift 1
  405. val asrl = shift 0
  406.  
  407. fun cmpl (_,Immed _) = raise Illegal
  408.   (* CMP *)
  409.   | cmpl (src,Direct(DataReg d)) =
  410.     (emitword(45184 + 512 * d + 8 * mode src + reg src); emitext src)
  411.   (* CMPA *)
  412.   | cmpl (src,Direct(AddrReg a)) =
  413.     (emitword(45504 + 512 * a + 8 * mode src + reg src); emitext src)
  414.   (* CMPI *)
  415.   | cmpl (Immed i,dest) =
  416.     (emitword(3200 + 8 * mode dest + reg dest); emitext dest)
  417.   (* CMPM *)
  418.   | cmpl (PostInc(AddrReg y),PostInc(AddrReg x)) = emitword(45448 + 512 * x + y)
  419.  
  420. (* DEBUG val cmpl = diag "cmpl" cmpl *)
  421.  
  422. fun btst (_,Direct(AddrReg _)) = raise Illegal
  423.   | btst (_,Immed _) = raise Illegal
  424.   | btst (Direct(DataReg d),dest) =
  425.     (emitword(256 + 512 * d + 8 * mode dest + reg dest); emitext dest)
  426.   | btst (Immed i,dest) =
  427.     (emitword(2048 + 8 * mode dest + reg dest); emitword i; emitext dest)
  428.  
  429. (* DEBUG val btst = diag "btst" btst *)
  430.  
  431. fun emitlab (i,lab) = jump(LABPTR i, lab)
  432.  
  433. fun jne (Address lab) = jump (Jcc(26112),lab)
  434. fun jeq (Address lab) = jump (Jcc(26368),lab)
  435. fun jgt (Address lab) = jump (Jcc(28160),lab)
  436. fun jge (Address lab) = jump (Jcc(27648),lab)
  437. fun jlt (Address lab) = jump (Jcc(27904),lab)
  438. fun jle (Address lab) = jump (Jcc(28416),lab)
  439. fun jcc (Address lab) = jump (Jcc(25600),lab)
  440. fun jls (Address lab) = jump (Jcc(25344),lab)
  441.  
  442. fun jra (Address lab) = jump (Jcc(24576),lab)
  443.   | jra (arg as (Displace(AddrReg _,_))) = 
  444.         (emitword (20160 + 8 * mode arg + reg arg); emitext arg)
  445.   | jra (arg as Index _) =
  446.         (emitword (20160 + 8 * mode arg + reg arg); emitext arg)
  447.  
  448. fun jbsr (Address lab) = jump (Jcc(24832),lab)
  449.   | jbsr (dest as (Displace(AddrReg _,_))) =
  450.     (emitword(20096 + 8 * mode dest + reg dest); emitext dest)
  451.             (* doesn't handle >16bit displacement *)
  452.  
  453. (* 68881 float operations *)
  454. (* Some src/dest combinations are illegal, but not caught here. *)
  455. fun fjne (Address lab) = jump (FJcc(14),lab)
  456. fun fjeq (Address lab) = jump (FJcc(1),lab)
  457. fun fjgt (Address lab) = jump (FJcc(18),lab)
  458. fun fjge (Address lab) = jump (FJcc(19),lab)
  459. fun fjlt (Address lab) = jump (FJcc(20),lab)
  460. fun fjle (Address lab) = jump (FJcc(21),lab)
  461.  
  462. (**** The following are not used ****
  463. fun fcmpd (src,dest) = emitF(56,src,dest)
  464. fun faddd (src,dest) = emitF(34,src,dest)
  465. fun fsubd (src,dest) = emitF(40,src,dest)
  466. fun fmuld (src,dest) = emitF(35,src,dest)
  467. fun fdivd (src,dest) = emitF(32,src,dest)
  468. ****)
  469. fun fmoved (src,dest as Direct(FloatReg f)) = emitF(0,src,dest)
  470.   | fmoved (src as Direct(FloatReg f),dest) = emitF(8192,src,dest)
  471.  
  472. local
  473.     val badargs = "Bad arguments to floating point "
  474. in
  475. fun fcmpx (fp1 as Direct(FloatReg _),fp2 as Direct(FloatReg _))= emitF(56,fp1,fp2)
  476.   | fcmpx _ = ErrorMsg.impossible (badargs ^ "fcmpx")
  477. fun faddx (src as Direct(FloatReg _),dst as Direct(FloatReg _))= emitF(34,src,dst)
  478.   | faddx _ = ErrorMsg.impossible (badargs ^ "faddx")
  479. fun fsubx (src as Direct(FloatReg _),dst as Direct(FloatReg _))= emitF(40,src,dst)
  480.   | fsubx _ = ErrorMsg.impossible (badargs ^ "fsubx")
  481. fun fmulx (src as Direct(FloatReg _),dst as Direct(FloatReg _))= emitF(35,src,dst)
  482.   | fmulx _ = ErrorMsg.impossible (badargs ^ "fmulx")
  483. fun fdivx (src as Direct(FloatReg _),dst as Direct(FloatReg _))= emitF(32,src,dst)
  484.   | fdivx _ = ErrorMsg.impossible (badargs ^ "fdivx")
  485. fun fnegx (src,dest) = emitF(26,src,dest)
  486. fun fabsx (src,dest) = emitF(24,src,dest)
  487. fun fmovex (src as Direct(FloatReg _),dst as Direct(FloatReg _))= emitF(0,src,dst)
  488.   | fmovex _ = ErrorMsg.impossible (badargs ^ "fmovex")
  489. fun fmovel(src, Direct(FloatReg f))= 
  490.       (emitword(61952 + 8*mode src + reg src);
  491.        emitword(16384 + f * 128))
  492.   | fmovel _ = ErrorMsg.impossible (badargs ^ "fmovel")
  493. end
  494.        
  495. fun trapv() = emitword(20086)
  496. fun trapmi() = emitword 23548
  497.  
  498. fun push ea = movl(ea,PreDec sp)
  499.  
  500. fun pop ea = movl(PostInc sp,ea)
  501.  
  502. val pusha = pea
  503.  
  504. fun comment _ = ()
  505.  
  506. end (* Coder *)
  507.  
  508. val finish = Emitter.finish
  509.  
  510. end (* structure MCode *)
  511.