CVS: sml-dist/src/compiler/FLINT/trans primopmap.sml, 1.1.2.2, 1.1.2.3
George Kuan <[email protected]> Thu, 13 Jul 2006 14:10:46 -0700
| Newsgroups | gmane.comp.lang.sml.smlnj.commits |
|---|---|
| Message-ID | <[email protected]> |
Update of /cvsroot/smlnj/sml-dist/src/compiler/FLINT/trans
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv23408/src/compiler/FLINT/trans
Modified Files:
Tag: primop-branch-2
primopmap.sml
Log Message:
primOpTypeMap addition now compiles...makeml still does not work
Index: primopmap.sml
===================================================================
RCS file: /cvsroot/smlnj/sml-dist/src/compiler/FLINT/trans/Attic/primopmap.sml,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.3
diff -C2 -d -r1.1.2.2 -r1.1.2.3
*** primopmap.sml 11 Jul 2006 23:00:41 -0000 1.1.2.2
--- primopmap.sml 13 Jul 2006 21:10:44 -0000 1.1.2.3
***************
*** 14,18 ****
signature PRIMOP_MAP =
sig
! val primopMap : string -> (PrimOp.primop * Types.ty) option
end (* signature PRIMOP_MAP *)
--- 14,18 ----
signature PRIMOP_MAP =
sig
! val primopMap : string -> PrimOp.primop option
end (* signature PRIMOP_MAP *)
***************
*** 247,285 ****
val primops =
empty :-:
! ("callcc", (P.CALLCC, p1(ar(ar(cnt(v1),v1),v1)))) :-:
! ("throw", (P.THROW, p2(ar(cnt(v1),ar(v1,v2))))) :-:
! ("capture", (P.CAPTURE, p1(ar(ar(ccnt(v1),v1),v1)))) :-:
! ("isolate", (P.ISOLATE, p1(ar(ar(v1,u),cnt(v1))))) :-:
! ("cthrow", (P.THROW, p2(ar(ccnt(v1),ar(v1,v2))))) :-:
! ("!", (P.DEREF, p1(ar(rf(v1),v1)))) :-:
! (":=", (P.ASSIGN, p1(ar(tu[rf(v1),v1],u)))) :-:
! ("makeref", (P.MAKEREF, p1(ar(v1,rf(v1))))) :-:
! ("boxed", (P.BOXED, p1(ar(v1,bo)))) :-:
! ("unboxed", (P.UNBOXED, p1(ar(v1,bo)))) :-:
! ("cast", (P.CAST, p2(ar(v1,v2)))) :-:
! ("=", (P.POLYEQL, ep1(ar(tu[v1,v1],bo)))) :-:
! ("<>", (P.POLYNEQ, ep1(ar(tu[v1,v1],bo)))) :-:
! ("ptreql", (P.PTREQL, p1(ar(tu[v1,v1],bo)))) :-:
! ("ptrneq", (P.PTRNEQ, p1(ar(tu[v1,v1],bo)))) :-:
! ("getvar", (P.GETVAR, p1(ar(u,v1)))) :-:
! ("setvar", (P.SETVAR, p1(ar(v1,u)))) :-:
! ("setpseudo", (P.SETPSEUDO, p1(ar(tu[v1,i],u)))) :-:
! ("getpseudo", (P.GETPSEUDO, p1(ar(i,v1)))) :-:
! ("mkspecial", (P.MKSPECIAL, p2(ar(tu[i,v1],v2)))) :-:
! ("getspecial", (P.GETSPECIAL, p1(ar(v1,i)))) :-:
! ("setspecial", (P.SETSPECIAL, p1(ar(tu[v1,i],u)))) :-:
! ("gethdlr", (P.GETHDLR, p1(ar(u,cnt(v1))))) :-:
! ("sethdlr", (P.SETHDLR, p1(ar(cnt(v1),u)))) :-:
! ("gettag", (P.GETTAG, p1(ar(v1,i)))) :-:
! ("setmark", (P.SETMARK, p1(ar(v1,u)))) :-:
! ("dispose", (P.DISPOSE, p1(ar(v1,u)))) :-:
! ("compose", (P.INLCOMPOSE, p3(ar(tu[ar(v2,v3),ar(v1,v2)],ar(v1,v3))))) :-:
! ("before", (P.INLBEFORE, p2(ar(tu[v1,v2],v1)))) :-:
! ("ignore", (P.INLIGNORE, p1(ar(v1,u)))) :-:
! ("identity", (P.INLIDENTITY,p1(ar(v1,v1)))) :-:
! ("length", (P.LENGTH, p1(ar(v1,i)))) :-:
! ("objlength", (P.OBJLENGTH, p1(ar(v1,i)))) :-:
(*
--- 247,285 ----
val primops =
empty :-:
! ("callcc", (P.CALLCC)) :-:
! ("throw", (P.THROW)) :-:
! ("capture", (P.CAPTURE)) :-:
! ("isolate", (P.ISOLATE)) :-:
! ("cthrow", (P.THROW)) :-:
! ("!", (P.DEREF)) :-:
! (":=", (P.ASSIGN)) :-:
! ("makeref", (P.MAKEREF)) :-:
! ("boxed", (P.BOXED)) :-:
! ("unboxed", (P.UNBOXED)) :-:
! ("cast", (P.CAST)) :-:
! ("=", (P.POLYEQL)) :-:
! ("<>", (P.POLYNEQ)) :-:
! ("ptreql", (P.PTREQL)) :-:
! ("ptrneq", (P.PTRNEQ)) :-:
! ("getvar", (P.GETVAR)) :-:
! ("setvar", (P.SETVAR)) :-:
! ("setpseudo", (P.SETPSEUDO)) :-:
! ("getpseudo", (P.GETPSEUDO)) :-:
! ("mkspecial", (P.MKSPECIAL)) :-:
! ("getspecial", (P.GETSPECIAL)) :-:
! ("setspecial", (P.SETSPECIAL)) :-:
! ("gethdlr", (P.GETHDLR)) :-:
! ("sethdlr", (P.SETHDLR)) :-:
! ("gettag", (P.GETTAG)) :-:
! ("setmark", (P.SETMARK)) :-:
! ("dispose", (P.DISPOSE)) :-:
! ("compose", (P.INLCOMPOSE)) :-:
! ("before", (P.INLBEFORE)) :-:
! ("ignore", (P.INLIGNORE)) :-:
! ("identity", (P.INLIDENTITY)) :-:
! ("length", (P.LENGTH)) :-:
! ("objlength", (P.OBJLENGTH)) :-:
(*
***************
*** 296,341 ****
(* I put this one back in so tprof can find it in _Core
* instead of having to construct it ... (Matthias) *)
! ("unboxedupdate", (P.UNBOXEDUPDATE, p1(ar(tu[ay(v1),i,v1],u)))) :-:
! ("inlnot", (P.INLNOT, b_b)) :-:
("floor", (P.ROUND{floor=true,
fromkind=P.FLOAT 64,
! tokind=P.INT 31}, f64_i)) :-:
("round", (P.ROUND{floor=false,
fromkind=P.FLOAT 64,
! tokind=P.INT 31}, f64_i)) :-:
("real", (P.REAL{fromkind=P.INT 31,
! tokind=P.FLOAT 64}, i_f64)) :-:
("real32", (P.REAL{fromkind=P.INT 32,
! tokind=P.FLOAT 64}, i32_f64)) :-:
("ordof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=false,
! immutable=true}, numSubTy)) :-:
("store", (P.NUMUPDATE{kind=P.INT 8,
! checked=false}, numUpdTy)) :-:
("inlbyteof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=true,
! immutable=false}, numSubTy)) :-:
("inlstore", (P.NUMUPDATE{kind=P.INT 8,
! checked=true}, numUpdTy)) :-:
("inlordof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=true,
! immutable=true}, numSubTy)) :-:
(*** polymorphic array and vector ***)
! ("mkarray", (P.INLMKARRAY, p1(ar(tu[i,v1],ay(v1))))) :-:
! ("arrSub", (P.SUBSCRIPT, p1(ar(tu[ay(v1),i],v1)))) :-:
! ("arrChkSub", (P.INLSUBSCRIPT, p1(ar(tu[ay(v1),i],v1)))) :-:
! ("vecSub", (P.SUBSCRIPTV, p1(ar(tu[vct(v1),i],v1)))) :-:
! ("vecChkSub", (P.INLSUBSCRIPTV, p1(ar(tu[vct(v1),i],v1)))) :-:
! ("arrUpdate", (P.UPDATE, p1(ar(tu[ay(v1),i,v1],u)))) :-:
! ("arrChkUpdate", (P.INLUPDATE, p1(ar(tu[ay(v1),i,v1],u)))) :-:
(* new array representations *)
! ("newArray0", (P.NEW_ARRAY0, p1(ar(u,v1)))) :-:
! ("getSeqData", (P.GET_SEQ_DATA, p2(ar(v1, v2)))) :-:
! ("recordSub", (P.SUBSCRIPT_REC, p2(ar(tu[v1,i],v2)))) :-:
! ("raw64Sub", (P.SUBSCRIPT_RAW64, p1(ar(tu[v1,i],f64)))) :-:
(* *** conversion primops ***
--- 296,341 ----
(* I put this one back in so tprof can find it in _Core
* instead of having to construct it ... (Matthias) *)
! ("unboxedupdate", (P.UNBOXEDUPDATE)) :-:
! ("inlnot", (P.INLNOT)) :-:
("floor", (P.ROUND{floor=true,
fromkind=P.FLOAT 64,
! tokind=P.INT 31})) :-:
("round", (P.ROUND{floor=false,
fromkind=P.FLOAT 64,
! tokind=P.INT 31})) :-:
("real", (P.REAL{fromkind=P.INT 31,
! tokind=P.FLOAT 64})) :-:
("real32", (P.REAL{fromkind=P.INT 32,
! tokind=P.FLOAT 64})) :-:
("ordof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=false,
! immutable=true})) :-:
("store", (P.NUMUPDATE{kind=P.INT 8,
! checked=false})) :-:
("inlbyteof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=true,
! immutable=false})) :-:
("inlstore", (P.NUMUPDATE{kind=P.INT 8,
! checked=true})) :-:
("inlordof", (P.NUMSUBSCRIPT{kind=P.INT 8,
checked=true,
! immutable=true})) :-:
(*** polymorphic array and vector ***)
! ("mkarray", (P.INLMKARRAY)) :-:
! ("arrSub", (P.SUBSCRIPT)) :-:
! ("arrChkSub", (P.INLSUBSCRIPT)) :-:
! ("vecSub", (P.SUBSCRIPTV)) :-:
! ("vecChkSub", (P.INLSUBSCRIPTV)) :-:
! ("arrUpdate", (P.UPDATE)) :-:
! ("arrChkUpdate", (P.INLUPDATE)) :-:
(* new array representations *)
! ("newArray0", (P.NEW_ARRAY0)) :-:
! ("getSeqData", (P.GET_SEQ_DATA)) :-:
! ("recordSub", (P.SUBSCRIPT_REC)) :-:
! ("raw64Sub", (P.SUBSCRIPT_RAW64)) :-:
(* *** conversion primops ***
***************
*** 344,422 ****
* of the primop has been extended using a simple suffix
* scheme. *)
! ("test_32_31_w", (P.TEST(32,31), w32_i)) :-:
! ("test_32_31_i", (P.TEST(32,31), i32_i)) :-:
! ("testu_31_31", (P.TESTU(31,31), w_i)) :-:
! ("testu_32_31", (P.TESTU(32,31), w32_i)) :-:
! ("testu_32_32", (P.TESTU(32,32), w32_i32)) :-:
! ("copy_32_32_ii", (P.COPY(32,32), i32_i32)) :-:
! ("copy_32_32_wi", (P.COPY(32,32), w32_i32)) :-:
! ("copy_32_32_iw", (P.COPY(32,32), i32_w32)) :-:
! ("copy_32_32_ww", (P.COPY(32,32), w32_w32)) :-:
! ("copy_31_31_ii", (P.COPY(31,31), i_i)) :-:
! ("copy_31_31_wi", (P.COPY(31,31), w_i)) :-:
! ("copy_31_31_iw", (P.COPY(31,31), i_w)) :-:
! ("copy_31_32_i", (P.COPY(31,32), w_i32)) :-:
! ("copy_31_32_w", (P.COPY(31,32), w_w32)) :-:
! ("copy_8_32_i", (P.COPY(8,32), w8_i32)) :-:
! ("copy_8_32_w", (P.COPY(8,32), w8_w32)) :-:
! ("copy_8_31", (P.COPY(8,31), w8_i)) :-:
! ("extend_31_32_ii", (P.EXTEND(31,32), i_i32)) :-:
! ("extend_31_32_iw", (P.EXTEND(31,32), i_w32)) :-:
! ("extend_31_32_wi", (P.EXTEND(31,32), w_i32)) :-:
! ("extend_31_32_ww", (P.EXTEND(31,32), w_w32)) :-:
! ("extend_8_31", (P.EXTEND(8,31), w8_i)) :-:
! ("extend_8_32_i", (P.EXTEND(8,32), w8_i32)) :-:
! ("extend_8_32_w", (P.EXTEND(8,32), w8_w32)) :-:
! ("trunc_32_31_i", (P.TRUNC(32,31), i32_w)) :-:
! ("trunc_32_31_w", (P.TRUNC(32,31), w32_w)) :-:
! ("trunc_31_8", (P.TRUNC(31,8), i_w8)) :-:
! ("trunc_32_8_i", (P.TRUNC(32,8), i32_w8)) :-:
! ("trunc_32_8_w", (P.TRUNC(32,8), w32_w8)) :-:
(* conversion primops involving intinf *)
! ("test_inf_31", (P.TEST_INF 31, inf_i)) :-:
! ("test_inf_32", (P.TEST_INF 32, inf_i32)) :-:
! ("test_inf_64", (P.TEST_INF 64, inf_i64)) :-:
! ("copy_8_inf", (P.COPY_INF 8, w8_inf)) :-:
! ("copy_8_inf_w", (P.COPY_INF 8, w8_inf)) :-:
! ("copy_31_inf_w", (P.COPY_INF 31, w_inf)) :-:
! ("copy_32_inf_w", (P.COPY_INF 32, w32_inf)) :-:
! ("copy_64_inf_w", (P.COPY_INF 64, w64_inf)) :-:
! ("copy_31_inf_i", (P.COPY_INF 31, i_inf)) :-:
! ("copy_32_inf_i", (P.COPY_INF 32, i32_inf)) :-:
! ("copy_64_inf_i", (P.COPY_INF 64, i64_inf)) :-:
! ("extend_8_inf", (P.EXTEND_INF 8, w8_inf)) :-:
! ("extend_8_inf_w", (P.EXTEND_INF 8, w8_inf)) :-:
! ("extend_31_inf_w", (P.EXTEND_INF 31, w_inf)) :-:
! ("extend_32_inf_w", (P.EXTEND_INF 32, w32_inf)) :-:
! ("extend_64_inf_w", (P.EXTEND_INF 64, w64_inf)) :-:
! ("extend_31_inf_i", (P.EXTEND_INF 31, i_inf)) :-:
! ("extend_32_inf_i", (P.EXTEND_INF 32, i32_inf)) :-:
! ("extend_64_inf_i", (P.EXTEND_INF 64, i64_inf)) :-:
! ("trunc_inf_8", (P.TRUNC_INF 8, inf_w8)) :-:
! ("trunc_inf_31", (P.TRUNC_INF 31, inf_w)) :-:
! ("trunc_inf_32", (P.TRUNC_INF 32, inf_w32)) :-:
! ("trunc_inf_64", (P.TRUNC_INF 64, inf_w64)) :-:
(* primops to go between abstract and concrete representation of
* 64-bit ints and words *)
! ("w64p", (P.CVT64, w64_pw32)) :-:
! ("p64w", (P.CVT64, pw32_w64)) :-:
! ("i64p", (P.CVT64, i64_pw32)) :-:
! ("p64i", (P.CVT64, pw32_i64)) :-:
(* *** integer 31 primops ***
--- 344,422 ----
* of the primop has been extended using a simple suffix
* scheme. *)
! ("test_32_31_w", (P.TEST(32,31))) :-:
! ("test_32_31_i", (P.TEST(32,31))) :-:
! ("testu_31_31", (P.TESTU(31,31))) :-:
! ("testu_32_31", (P.TESTU(32,31))) :-:
! ("testu_32_32", (P.TESTU(32,32))) :-:
! ("copy_32_32_ii", (P.COPY(32,32))) :-:
! ("copy_32_32_wi", (P.COPY(32,32))) :-:
! ("copy_32_32_iw", (P.COPY(32,32))) :-:
! ("copy_32_32_ww", (P.COPY(32,32))) :-:
! ("copy_31_31_ii", (P.COPY(31,31))) :-:
! ("copy_31_31_wi", (P.COPY(31,31))) :-:
! ("copy_31_31_iw", (P.COPY(31,31))) :-:
! ("copy_31_32_i", (P.COPY(31,32))) :-:
! ("copy_31_32_w", (P.COPY(31,32))) :-:
! ("copy_8_32_i", (P.COPY(8,32))) :-:
! ("copy_8_32_w", (P.COPY(8,32))) :-:
! ("copy_8_31", (P.COPY(8,31))) :-:
! ("extend_31_32_ii", (P.EXTEND(31,32))) :-:
! ("extend_31_32_iw", (P.EXTEND(31,32))) :-:
! ("extend_31_32_wi", (P.EXTEND(31,32))) :-:
! ("extend_31_32_ww", (P.EXTEND(31,32))) :-:
! ("extend_8_31", (P.EXTEND(8,31))) :-:
! ("extend_8_32_i", (P.EXTEND(8,32))) :-:
! ("extend_8_32_w", (P.EXTEND(8,32))) :-:
! ("trunc_32_31_i", (P.TRUNC(32,31))) :-:
! ("trunc_32_31_w", (P.TRUNC(32,31))) :-:
! ("trunc_31_8", (P.TRUNC(31,8))) :-:
! ("trunc_32_8_i", (P.TRUNC(32,8))) :-:
! ("trunc_32_8_w", (P.TRUNC(32,8))) :-:
(* conversion primops involving intinf *)
! ("test_inf_31", (P.TEST_INF 31)) :-:
! ("test_inf_32", (P.TEST_INF 32)) :-:
! ("test_inf_64", (P.TEST_INF 64)) :-:
! ("copy_8_inf", (P.COPY_INF 8)) :-:
! ("copy_8_inf_w", (P.COPY_INF 8)) :-:
! ("copy_31_inf_w", (P.COPY_INF 31)) :-:
! ("copy_32_inf_w", (P.COPY_INF 32)) :-:
! ("copy_64_inf_w", (P.COPY_INF 64)) :-:
! ("copy_31_inf_i", (P.COPY_INF 31)) :-:
! ("copy_32_inf_i", (P.COPY_INF 32)) :-:
! ("copy_64_inf_i", (P.COPY_INF 64)) :-:
! ("extend_8_inf", (P.EXTEND_INF 8)) :-:
! ("extend_8_inf_w", (P.EXTEND_INF 8)) :-:
! ("extend_31_inf_w", (P.EXTEND_INF 31)) :-:
! ("extend_32_inf_w", (P.EXTEND_INF 32)) :-:
! ("extend_64_inf_w", (P.EXTEND_INF 64)) :-:
! ("extend_31_inf_i", (P.EXTEND_INF 31)) :-:
! ("extend_32_inf_i", (P.EXTEND_INF 32)) :-:
! ("extend_64_inf_i", (P.EXTEND_INF 64)) :-:
! ("trunc_inf_8", (P.TRUNC_INF 8)) :-:
! ("trunc_inf_31", (P.TRUNC_INF 31)) :-:
! ("trunc_inf_32", (P.TRUNC_INF 32)) :-:
! ("trunc_inf_64", (P.TRUNC_INF 64)) :-:
(* primops to go between abstract and concrete representation of
* 64-bit ints and words *)
! ("w64p", (P.CVT64)) :-:
! ("p64w", (P.CVT64)) :-:
! ("i64p", (P.CVT64)) :-:
! ("p64i", (P.CVT64)) :-:
(* *** integer 31 primops ***
***************
*** 425,548 ****
* there are suffixed alternative versions of the primop
* (i.e., same primop, different type). *)
! ("i31add", (int31 P.+, ii_i)) :-:
! ("i31add_8", (int31 P.+, w8w8_w8)) :-:
! ("i31sub", (int31 P.-, ii_i)) :-:
! ("i31sub_8", (int31 P.-, w8w8_w8)) :-:
! ("i31mul", (int31 P.*, ii_i)) :-:
! ("i31mul_8", (int31 P.*, w8w8_w8)) :-:
! ("i31div", (int31 P.DIV, ii_i)) :-:
! ("i31div_8", (int31 P.DIV, w8w8_w8)) :-:
! ("i31mod", (int31 P.MOD, ii_i)) :-:
! ("i31mod_8", (int31 P.MOD, w8w8_w8)) :-:
! ("i31quot", (int31 P./, ii_i)) :-:
! ("i31rem", (int31 P.REM, ii_i)) :-:
! ("i31orb", (bits31 P.ORB, ii_i)) :-:
! ("i31orb_8", (bits31 P.ORB, w8w8_w8)) :-:
! ("i31andb", (bits31 P.ANDB, ii_i)) :-:
! ("i31andb_8", (bits31 P.ANDB, w8w8_w8)) :-:
! ("i31xorb", (bits31 P.XORB, ii_i)) :-:
! ("i31xorb_8", (bits31 P.XORB, w8w8_w8)) :-:
! ("i31notb", (bits31 P.NOTB, i_i)) :-:
! ("i31notb_8", (bits31 P.NOTB, w8_w8)) :-:
! ("i31neg", (int31 P.~, i_i)) :-:
! ("i31neg_8", (int31 P.~, w8_w8)) :-:
! ("i31lshift", (bits31 P.LSHIFT, ii_i)) :-:
! ("i31lshift_8", (bits31 P.LSHIFT, w8w_w8)) :-:
! ("i31rshift", (bits31 P.RSHIFT, ii_i)) :-:
! ("i31rshift_8", (bits31 P.RSHIFT, w8w_w8)) :-:
! ("i31lt", (int31cmp P.<, ii_b)) :-:
! ("i31lt_8", (int31cmp P.<, w8w8_b)) :-:
! ("i31lt_c", (int31cmp P.<, cc_b)) :-:
! ("i31le", (int31cmp P.<=, ii_b)) :-:
! ("i31le_8", (int31cmp P.<=, w8w8_b)) :-:
! ("i31le_c", (int31cmp P.<=, cc_b)) :-:
! ("i31gt", (int31cmp P.>, ii_b)) :-:
! ("i31gt_8", (int31cmp P.>, w8w8_b)) :-:
! ("i31gt_c", (int31cmp P.>, cc_b)) :-:
! ("i31ge", (int31cmp P.>=, ii_b)) :-:
! ("i31ge_8", (int31cmp P.>=, w8w8_b)) :-:
! ("i31ge_c", (int31cmp P.>=, cc_b)) :-:
! ("i31ltu", (word31cmp P.LTU, ii_b)) :-:
! ("i31geu", (word31cmp P.GEU, ii_b)) :-:
! ("i31eq", (int31cmp P.EQL, ii_b)) :-:
! ("i31ne", (int31cmp P.NEQ, ii_b)) :-:
! ("i31min", (P.INLMIN (P.INT 31), ii_i)) :-:
! ("i31min_8", (P.INLMIN (P.INT 31), w8w8_w8)) :-:
! ("i31max", (P.INLMAX (P.INT 31), ii_i)) :-:
! ("i31max_8", (P.INLMAX (P.INT 31), w8w8_w8)) :-:
! ("i31abs", (P.INLABS (P.INT 31), i_i)) :-:
(*** integer 32 primops ***)
! ("i32mul", (int32 P.*, i32i32_i32)) :-:
! ("i32div", (int32 P.DIV, i32i32_i32)) :-:
! ("i32mod", (int32 P.MOD, i32i32_i32)) :-:
! ("i32quot", (int32 P./, i32i32_i32)) :-:
! ("i32rem", (int32 P.REM, i32i32_i32)) :-:
! ("i32add", (int32 P.+, i32i32_i32)) :-:
! ("i32sub", (int32 P.-, i32i32_i32)) :-:
! ("i32orb", (bits32 P.ORB, i32i32_i32)) :-:
! ("i32andb", (bits32 P.ANDB, i32i32_i32)) :-:
! ("i32xorb", (bits32 P.XORB, i32i32_i32)) :-:
! ("i32lshift", (bits32 P.LSHIFT, i32i32_i32)) :-:
! ("i32rshift", (bits32 P.RSHIFT, i32i32_i32)) :-:
! ("i32neg", (int32 P.~, i32_i32)) :-:
! ("i32lt", (int32cmp P.<, i32i32_b)) :-:
! ("i32le", (int32cmp P.<=, i32i32_b)) :-:
! ("i32gt", (int32cmp P.>, i32i32_b)) :-:
! ("i32ge", (int32cmp P.>=, i32i32_b)) :-:
! ("i32eq", (int32cmp P.EQL, i32i32_b)) :-:
! ("i32ne", (int32cmp P.NEQ, i32i32_b)) :-:
! ("i32min", (P.INLMIN (P.INT 32), i32i32_i32)) :-:
! ("i32max", (P.INLMAX (P.INT 32), i32i32_i32)) :-:
! ("i32abs", (P.INLABS (P.INT 32), i32_i32)) :-:
(*** float 64 primops ***)
! ("f64add", (purefloat64 (P.+), f64f64_f64)) :-:
! ("f64sub", (purefloat64 (P.-), f64f64_f64)) :-:
! ("f64div", (purefloat64 (P./), f64f64_f64)) :-:
! ("f64mul", (purefloat64 (P.* ), f64f64_f64)) :-:
! ("f64neg", (purefloat64 P.~, f64_f64)) :-:
! ("f64ge", (float64cmp (P.>=), f64f64_b)) :-:
! ("f64gt", (float64cmp (P.>), f64f64_b)) :-:
! ("f64le", (float64cmp (P.<=), f64f64_b)) :-:
! ("f64lt", (float64cmp (P.<), f64f64_b)) :-:
! ("f64eq", (float64cmp P.EQL, f64f64_b)) :-:
! ("f64ne", (float64cmp P.NEQ, f64f64_b)) :-:
! ("f64abs", (purefloat64 P.ABS, f64_f64)) :-:
! ("f64sin", (purefloat64 P.FSIN, f64_f64)) :-:
! ("f64cos", (purefloat64 P.FCOS, f64_f64)) :-:
! ("f64tan", (purefloat64 P.FTAN, f64_f64)) :-:
! ("f64sqrt", (purefloat64 P.FSQRT, f64_f64)) :-:
! ("f64min", (P.INLMIN (P.FLOAT 64), f64f64_f64)) :-:
! ("f64max", (P.INLMAX (P.FLOAT 64), f64f64_f64)) :-:
(*** float64 array ***)
! ("f64Sub", (sub (P.FLOAT 64), numSubTy)) :-:
! ("f64chkSub", (chkSub (P.FLOAT 64), numSubTy)) :-:
! ("f64Update", (update (P.FLOAT 64), numUpdTy)) :-:
! ("f64chkUpdate", (chkUpdate (P.FLOAT 64), numUpdTy)) :-:
(*** word8 primops ***)
--- 425,548 ----
* there are suffixed alternative versions of the primop
* (i.e., same primop, different type). *)
! ("i31add", (int31 P.+)) :-:
! ("i31add_8", (int31 P.+)) :-:
! ("i31sub", (int31 P.-)) :-:
! ("i31sub_8", (int31 P.-)) :-:
! ("i31mul", (int31 P.* )) :-:
! ("i31mul_8", (int31 P.* )) :-:
! ("i31div", (int31 P.DIV)) :-:
! ("i31div_8", (int31 P.DIV)) :-:
! ("i31mod", (int31 P.MOD)) :-:
! ("i31mod_8", (int31 P.MOD)) :-:
! ("i31quot", (int31 P./)) :-:
! ("i31rem", (int31 P.REM)) :-:
! ("i31orb", (bits31 P.ORB)) :-:
! ("i31orb_8", (bits31 P.ORB)) :-:
! ("i31andb", (bits31 P.ANDB)) :-:
! ("i31andb_8", (bits31 P.ANDB)) :-:
! ("i31xorb", (bits31 P.XORB)) :-:
! ("i31xorb_8", (bits31 P.XORB)) :-:
! ("i31notb", (bits31 P.NOTB)) :-:
! ("i31notb_8", (bits31 P.NOTB)) :-:
! ("i31neg", (int31 P.~)) :-:
! ("i31neg_8", (int31 P.~)) :-:
! ("i31lshift", (bits31 P.LSHIFT)) :-:
! ("i31lshift_8", (bits31 P.LSHIFT)) :-:
! ("i31rshift", (bits31 P.RSHIFT)) :-:
! ("i31rshift_8", (bits31 P.RSHIFT)) :-:
! ("i31lt", (int31cmp P.<)) :-:
! ("i31lt_8", (int31cmp P.<)) :-:
! ("i31lt_c", (int31cmp P.<)) :-:
! ("i31le", (int31cmp P.<=)) :-:
! ("i31le_8", (int31cmp P.<=)) :-:
! ("i31le_c", (int31cmp P.<=)) :-:
! ("i31gt", (int31cmp P.>)) :-:
! ("i31gt_8", (int31cmp P.>)) :-:
! ("i31gt_c", (int31cmp P.>)) :-:
! ("i31ge", (int31cmp P.>=)) :-:
! ("i31ge_8", (int31cmp P.>=)) :-:
! ("i31ge_c", (int31cmp P.>=)) :-:
! ("i31ltu", (word31cmp P.LTU)) :-:
! ("i31geu", (word31cmp P.GEU)) :-:
! ("i31eq", (int31cmp P.EQL)) :-:
! ("i31ne", (int31cmp P.NEQ)) :-:
! ("i31min", (P.INLMIN (P.INT 31))) :-:
! ("i31min_8", (P.INLMIN (P.INT 31))) :-:
! ("i31max", (P.INLMAX (P.INT 31))) :-:
! ("i31max_8", (P.INLMAX (P.INT 31))) :-:
! ("i31abs", (P.INLABS (P.INT 31))) :-:
(*** integer 32 primops ***)
! ("i32mul", (int32 P.* )) :-:
! ("i32div", (int32 P.DIV)) :-:
! ("i32mod", (int32 P.MOD)) :-:
! ("i32quot", (int32 P./)) :-:
! ("i32rem", (int32 P.REM)) :-:
! ("i32add", (int32 P.+)) :-:
! ("i32sub", (int32 P.-)) :-:
! ("i32orb", (bits32 P.ORB)) :-:
! ("i32andb", (bits32 P.ANDB)) :-:
! ("i32xorb", (bits32 P.XORB)) :-:
! ("i32lshift", (bits32 P.LSHIFT)) :-:
! ("i32rshift", (bits32 P.RSHIFT)) :-:
! ("i32neg", (int32 P.~)) :-:
! ("i32lt", (int32cmp P.<)) :-:
! ("i32le", (int32cmp P.<=)) :-:
! ("i32gt", (int32cmp P.>)) :-:
! ("i32ge", (int32cmp P.>=)) :-:
! ("i32eq", (int32cmp P.EQL)) :-:
! ("i32ne", (int32cmp P.NEQ)) :-:
! ("i32min", (P.INLMIN (P.INT 32))) :-:
! ("i32max", (P.INLMAX (P.INT 32))) :-:
! ("i32abs", (P.INLABS (P.INT 32))) :-:
(*** float 64 primops ***)
! ("f64add", (purefloat64 (P.+))) :-:
! ("f64sub", (purefloat64 (P.-))) :-:
! ("f64div", (purefloat64 (P./))) :-:
! ("f64mul", (purefloat64 (P.* ))) :-:
! ("f64neg", (purefloat64 P.~)) :-:
! ("f64ge", (float64cmp (P.>=))) :-:
! ("f64gt", (float64cmp (P.>))) :-:
! ("f64le", (float64cmp (P.<=))) :-:
! ("f64lt", (float64cmp (P.<))) :-:
! ("f64eq", (float64cmp P.EQL)) :-:
! ("f64ne", (float64cmp P.NEQ)) :-:
! ("f64abs", (purefloat64 P.ABS)) :-:
! ("f64sin", (purefloat64 P.FSIN)) :-:
! ("f64cos", (purefloat64 P.FCOS)) :-:
! ("f64tan", (purefloat64 P.FTAN)) :-:
! ("f64sqrt", (purefloat64 P.FSQRT)) :-:
! ("f64min", (P.INLMIN (P.FLOAT 64))) :-:
! ("f64max", (P.INLMAX (P.FLOAT 64))) :-:
(*** float64 array ***)
! ("f64Sub", (sub (P.FLOAT 64))) :-:
! ("f64chkSub", (chkSub (P.FLOAT 64))) :-:
! ("f64Update", (update (P.FLOAT 64))) :-:
! ("f64chkUpdate", (chkUpdate (P.FLOAT 64))) :-:
(*** word8 primops ***)
***************
*** 558,696 ****
* are correctly implemented.
*
! * ("w8mul", word8 (P.* ), w8w8_w8)) :-:
! * ("w8div", word8 (P./), w8w8_w8)) :-:
! * ("w8add", word8 (P.+), w8w8_w8)) :-:
! * ("w8sub", word8 (P.-), w8w8_w8)) :-:
*
! * ("w8notb", word31 P.NOTB, w8_w8)) :-:
! * ("w8rshift", word8 P.RSHIFT, w8w_w8)) :-:
! * ("w8rshiftl", word8 P.RSHIFTL, w8w_w8)) :-:
! * ("w8lshift", word8 P.LSHIFT, w8w_w8)) :-:
*
* ("w8toint", P.ROUND{floor=true,
* fromkind=P.UINT 8,
! * tokind=P.INT 31}, w8_i)) :-:
* ("w8fromint", P.REAL{fromkind=P.INT 31,
! * tokind=P.UINT 8}, i_w8)) :-:
*)
! ("w8orb", (word31 P.ORB, w8w8_w8)) :-:
! ("w8xorb", (word31 P.XORB, w8w8_w8)) :-:
! ("w8andb", (word31 P.ANDB, w8w8_w8)) :-:
! ("w8gt", (word8cmp P.>, w8w8_b)) :-:
! ("w8ge", (word8cmp P.>=, w8w8_b)) :-:
! ("w8lt", (word8cmp P.<, w8w8_b)) :-:
! ("w8le", (word8cmp P.<=, w8w8_b)) :-:
! ("w8eq", (word8cmp P.EQL, w8w8_b)) :-:
! ("w8ne", (word8cmp P.NEQ, w8w8_b)) :-:
(*** word8 array and vector ***)
! ("w8Sub", (sub (P.UINT 8), numSubTy)) :-:
! ("w8chkSub", (chkSub (P.UINT 8), numSubTy)) :-:
! ("w8subv", (subv (P.UINT 8), numSubTy)) :-:
! ("w8chkSubv", (chkSubv (P.UINT 8), numSubTy)) :-:
! ("w8update", (update (P.UINT 8), numUpdTy)) :-:
! ("w8chkUpdate", (chkUpdate (P.UINT 8), numUpdTy)) :-:
(* word31 primops *)
! ("w31mul", (word31 (P.* ), ww_w)) :-:
! ("w31div", (word31 (P./), ww_w)) :-:
! ("w31mod", (word31 (P.REM), ww_w)) :-:
! ("w31add", (word31 (P.+), ww_w)) :-:
! ("w31sub", (word31 (P.-), ww_w)) :-:
! ("w31orb", (word31 P.ORB, ww_w)) :-:
! ("w31xorb", (word31 P.XORB, ww_w)) :-:
! ("w31andb", (word31 P.ANDB, ww_w)) :-:
! ("w31notb", (word31 P.NOTB, w_w)) :-:
! ("w31neg", (word31 P.~, w_w)) :-:
! ("w31rshift", (word31 P.RSHIFT, ww_w)) :-:
! ("w31rshiftl", (word31 P.RSHIFTL, ww_w)) :-:
! ("w31lshift", (word31 P.LSHIFT, ww_w)) :-:
! ("w31gt", (word31cmp (P.>), ww_b)) :-:
! ("w31ge", (word31cmp (P.>=), ww_b)) :-:
! ("w31lt", (word31cmp (P.<), ww_b)) :-:
! ("w31le", (word31cmp (P.<=), ww_b)) :-:
! ("w31eq", (word31cmp P.EQL, ww_b)) :-:
! ("w31ne", (word31cmp P.NEQ, ww_b)) :-:
! ("w31ChkRshift", (P.INLRSHIFT(P.UINT 31), ww_w)) :-:
! ("w31ChkRshiftl",(P.INLRSHIFTL(P.UINT 31),ww_w)) :-:
! ("w31ChkLshift", (P.INLLSHIFT(P.UINT 31), ww_w)) :-:
! ("w31min", (P.INLMIN (P.UINT 31), ww_w)) :-:
! ("w31max", (P.INLMAX (P.UINT 31), ww_w)) :-:
(* (pseudo-)word8 primops *)
! ("w31mul_8", (word31 (P.* ), w8w8_w8)) :-:
! ("w31div_8", (word31 (P./), w8w8_w8)) :-:
! ("w31mod_8", (word31 (P.REM), w8w8_w8)) :-:
! ("w31add_8", (word31 (P.+), w8w8_w8)) :-:
! ("w31sub_8", (word31 (P.-), w8w8_w8)) :-:
! ("w31orb_8", (word31 P.ORB, w8w8_w8)) :-:
! ("w31xorb_8", (word31 P.XORB, w8w8_w8)) :-:
! ("w31andb_8", (word31 P.ANDB, w8w8_w8)) :-:
! ("w31notb_8", (word31 P.NOTB, w8_w8)) :-:
! ("w31neg_8", (word31 P.~, w8_w8)) :-:
! ("w31rshift_8", (word31 P.RSHIFT, w8w_w8)) :-:
! ("w31rshiftl_8", (word31 P.RSHIFTL, w8w_w8)) :-:
! ("w31lshift_8", (word31 P.LSHIFT, w8w_w8)) :-:
! ("w31gt_8", (word31cmp (P.>), w8w8_b)) :-:
! ("w31ge_8", (word31cmp (P.>=), w8w8_b)) :-:
! ("w31lt_8", (word31cmp (P.<), w8w8_b)) :-:
! ("w31le_8", (word31cmp (P.<=), w8w8_b)) :-:
! ("w31eq_8", (word31cmp P.EQL, w8w8_b)) :-:
! ("w31ne_8", (word31cmp P.NEQ, w8w8_b)) :-:
! ("w31ChkRshift_8", (P.INLRSHIFT(P.UINT 31), w8w_w8)) :-:
! ("w31ChkRshiftl_8",(P.INLRSHIFTL(P.UINT 31),w8w_w8)) :-:
! ("w31ChkLshift_8", (P.INLLSHIFT(P.UINT 31), w8w_w8)) :-:
! ("w31min_8", (P.INLMIN (P.UINT 31), w8w8_w8)) :-:
! ("w31max_8", (P.INLMAX (P.UINT 31), w8w8_w8)) :-:
(*** word32 primops ***)
! ("w32mul", (word32 (P.* ), w32w32_w32)) :-:
! ("w32div", (word32 (P./), w32w32_w32)) :-:
! ("w32mod", (word32 (P.REM), w32w32_w32)) :-:
! ("w32add", (word32 (P.+), w32w32_w32)) :-:
! ("w32sub", (word32 (P.-), w32w32_w32)) :-:
! ("w32orb", (word32 P.ORB, w32w32_w32)) :-:
! ("w32xorb", (word32 P.XORB, w32w32_w32)) :-:
! ("w32andb", (word32 P.ANDB, w32w32_w32)) :-:
! ("w32notb", (word32 P.NOTB, w32_w32)) :-:
! ("w32neg", (word32 P.~, w32_w32)) :-:
! ("w32rshift", (word32 P.RSHIFT, w32w_w32)) :-:
! ("w32rshiftl", (word32 P.RSHIFTL, w32w_w32)) :-:
! ("w32lshift", (word32 P.LSHIFT, w32w_w32)) :-:
! ("w32gt", (word32cmp (P.>), w32w32_b)) :-:
! ("w32ge", (word32cmp (P.>=), w32w32_b)) :-:
! ("w32lt", (word32cmp (P.<), w32w32_b)) :-:
! ("w32le", (word32cmp (P.<=), w32w32_b)) :-:
! ("w32eq", (word32cmp P.EQL, w32w32_b)) :-:
! ("w32ne", (word32cmp P.NEQ, w32w32_b)) :-:
! ("w32ChkRshift", (P.INLRSHIFT(P.UINT 32), w32w_w32)) :-:
! ("w32ChkRshiftl",(P.INLRSHIFTL(P.UINT 32),w32w_w32)) :-:
! ("w32ChkLshift", (P.INLLSHIFT(P.UINT 32), w32w_w32)) :-:
! ("w32min", (P.INLMIN (P.UINT 32), w32w32_w32)) :-:
! ("w32max", (P.INLMAX (P.UINT 32), w32w32_w32)) :-:
(* experimental C FFI primops *)
! ("raww8l", (P.RAW_LOAD (P.UINT 8), w32_w32)) :-:
! ("rawi8l", (P.RAW_LOAD (P.INT 8), w32_i32)) :-:
! ("raww16l", (P.RAW_LOAD (P.UINT 16), w32_w32)) :-:
! ("rawi16l", (P.RAW_LOAD (P.INT 16), w32_i32)) :-:
! ("raww32l", (P.RAW_LOAD (P.UINT 32), w32_w32)) :-:
! ("rawi32l", (P.RAW_LOAD (P.INT 32), w32_i32)) :-:
! ("rawf32l", (P.RAW_LOAD (P.FLOAT 32), w32_f64)) :-:
! ("rawf64l", (P.RAW_LOAD (P.FLOAT 64), w32_f64)) :-:
! ("raww8s", (P.RAW_STORE (P.UINT 8), w32w32_u)) :-:
! ("rawi8s", (P.RAW_STORE (P.INT 8), w32i32_u)) :-:
! ("raww16s", (P.RAW_STORE (P.UINT 16), w32w32_u)) :-:
! ("rawi16s", (P.RAW_STORE (P.INT 16), w32i32_u)) :-:
! ("raww32s", (P.RAW_STORE (P.UINT 32), w32w32_u)) :-:
! ("rawi32s", (P.RAW_STORE (P.INT 32), w32i32_u)) :-:
! ("rawf32s", (P.RAW_STORE (P.FLOAT 32), w32f64_u)) :-:
! ("rawf64s", (P.RAW_STORE (P.FLOAT 64), w32f64_u)) :-:
! ("rawccall", (P.RAW_CCALL NONE, rccType)) :-:
(* Support for direct construction of C objects on ML heap.
--- 558,696 ----
* are correctly implemented.
*
! * ("w8mul", word8 (P.* ))) :-:
! * ("w8div", word8 (P./))) :-:
! * ("w8add", word8 (P.+))) :-:
! * ("w8sub", word8 (P.-))) :-:
*
! * ("w8notb", word31 P.NOTB)) :-:
! * ("w8rshift", word8 P.RSHIFT)) :-:
! * ("w8rshiftl", word8 P.RSHIFTL)) :-:
! * ("w8lshift", word8 P.LSHIFT)) :-:
*
* ("w8toint", P.ROUND{floor=true,
* fromkind=P.UINT 8,
! * tokind=P.INT 31})) :-:
* ("w8fromint", P.REAL{fromkind=P.INT 31,
! * tokind=P.UINT 8})) :-:
*)
! ("w8orb", (word31 P.ORB)) :-:
! ("w8xorb", (word31 P.XORB)) :-:
! ("w8andb", (word31 P.ANDB)) :-:
! ("w8gt", (word8cmp P.>)) :-:
! ("w8ge", (word8cmp P.>=)) :-:
! ("w8lt", (word8cmp P.<)) :-:
! ("w8le", (word8cmp P.<=)) :-:
! ("w8eq", (word8cmp P.EQL)) :-:
! ("w8ne", (word8cmp P.NEQ)) :-:
(*** word8 array and vector ***)
! ("w8Sub", (sub (P.UINT 8))) :-:
! ("w8chkSub", (chkSub (P.UINT 8))) :-:
! ("w8subv", (subv (P.UINT 8))) :-:
! ("w8chkSubv", (chkSubv (P.UINT 8))) :-:
! ("w8update", (update (P.UINT 8))) :-:
! ("w8chkUpdate", (chkUpdate (P.UINT 8))) :-:
(* word31 primops *)
! ("w31mul", (word31 (P.* ))) :-:
! ("w31div", (word31 (P./))) :-:
! ("w31mod", (word31 (P.REM))) :-:
! ("w31add", (word31 (P.+))) :-:
! ("w31sub", (word31 (P.-))) :-:
! ("w31orb", (word31 P.ORB)) :-:
! ("w31xorb", (word31 P.XORB)) :-:
! ("w31andb", (word31 P.ANDB)) :-:
! ("w31notb", (word31 P.NOTB)) :-:
! ("w31neg", (word31 P.~)) :-:
! ("w31rshift", (word31 P.RSHIFT)) :-:
! ("w31rshiftl", (word31 P.RSHIFTL)) :-:
! ("w31lshift", (word31 P.LSHIFT)) :-:
! ("w31gt", (word31cmp (P.>))) :-:
! ("w31ge", (word31cmp (P.>=))) :-:
! ("w31lt", (word31cmp (P.<))) :-:
! ("w31le", (word31cmp (P.<=))) :-:
! ("w31eq", (word31cmp P.EQL)) :-:
! ("w31ne", (word31cmp P.NEQ)) :-:
! ("w31ChkRshift", (P.INLRSHIFT(P.UINT 31))) :-:
! ("w31ChkRshiftl",(P.INLRSHIFTL(P.UINT 31))) :-:
! ("w31ChkLshift", (P.INLLSHIFT(P.UINT 31))) :-:
! ("w31min", (P.INLMIN (P.UINT 31))) :-:
! ("w31max", (P.INLMAX (P.UINT 31))) :-:
(* (pseudo-)word8 primops *)
! ("w31mul_8", (word31 (P.* ))) :-:
! ("w31div_8", (word31 (P./))) :-:
! ("w31mod_8", (word31 (P.REM))) :-:
! ("w31add_8", (word31 (P.+))) :-:
! ("w31sub_8", (word31 (P.-))) :-:
! ("w31orb_8", (word31 P.ORB)) :-:
! ("w31xorb_8", (word31 P.XORB)) :-:
! ("w31andb_8", (word31 P.ANDB)) :-:
! ("w31notb_8", (word31 P.NOTB)) :-:
! ("w31neg_8", (word31 P.~)) :-:
! ("w31rshift_8", (word31 P.RSHIFT)) :-:
! ("w31rshiftl_8", (word31 P.RSHIFTL)) :-:
! ("w31lshift_8", (word31 P.LSHIFT)) :-:
! ("w31gt_8", (word31cmp (P.>))) :-:
! ("w31ge_8", (word31cmp (P.>=))) :-:
! ("w31lt_8", (word31cmp (P.<))) :-:
! ("w31le_8", (word31cmp (P.<=))) :-:
! ("w31eq_8", (word31cmp P.EQL)) :-:
! ("w31ne_8", (word31cmp P.NEQ)) :-:
! ("w31ChkRshift_8", (P.INLRSHIFT(P.UINT 31))) :-:
! ("w31ChkRshiftl_8",(P.INLRSHIFTL(P.UINT 31))) :-:
! ("w31ChkLshift_8", (P.INLLSHIFT(P.UINT 31))) :-:
! ("w31min_8", (P.INLMIN (P.UINT 31))) :-:
! ("w31max_8", (P.INLMAX (P.UINT 31))) :-:
(*** word32 primops ***)
! ("w32mul", (word32 (P.* ))) :-:
! ("w32div", (word32 (P./))) :-:
! ("w32mod", (word32 (P.REM))) :-:
! ("w32add", (word32 (P.+))) :-:
! ("w32sub", (word32 (P.-))) :-:
! ("w32orb", (word32 P.ORB)) :-:
! ("w32xorb", (word32 P.XORB)) :-:
! ("w32andb", (word32 P.ANDB)) :-:
! ("w32notb", (word32 P.NOTB)) :-:
! ("w32neg", (word32 P.~)) :-:
! ("w32rshift", (word32 P.RSHIFT)) :-:
! ("w32rshiftl", (word32 P.RSHIFTL)) :-:
! ("w32lshift", (word32 P.LSHIFT)) :-:
! ("w32gt", (word32cmp (P.>))) :-:
! ("w32ge", (word32cmp (P.>=))) :-:
! ("w32lt", (word32cmp (P.<))) :-:
! ("w32le", (word32cmp (P.<=))) :-:
! ("w32eq", (word32cmp P.EQL)) :-:
! ("w32ne", (word32cmp P.NEQ)) :-:
! ("w32ChkRshift", (P.INLRSHIFT(P.UINT 32))) :-:
! ("w32ChkRshiftl",(P.INLRSHIFTL(P.UINT 32))) :-:
! ("w32ChkLshift", (P.INLLSHIFT(P.UINT 32))) :-:
! ("w32min", (P.INLMIN (P.UINT 32))) :-:
! ("w32max", (P.INLMAX (P.UINT 32))) :-:
(* experimental C FFI primops *)
! ("raww8l", (P.RAW_LOAD (P.UINT 8))) :-:
! ("rawi8l", (P.RAW_LOAD (P.INT 8))) :-:
! ("raww16l", (P.RAW_LOAD (P.UINT 16))) :-:
! ("rawi16l", (P.RAW_LOAD (P.INT 16))) :-:
! ("raww32l", (P.RAW_LOAD (P.UINT 32))) :-:
! ("rawi32l", (P.RAW_LOAD (P.INT 32))) :-:
! ("rawf32l", (P.RAW_LOAD (P.FLOAT 32))) :-:
! ("rawf64l", (P.RAW_LOAD (P.FLOAT 64))) :-:
! ("raww8s", (P.RAW_STORE (P.UINT 8))) :-:
! ("rawi8s", (P.RAW_STORE (P.INT 8))) :-:
! ("raww16s", (P.RAW_STORE (P.UINT 16))) :-:
! ("rawi16s", (P.RAW_STORE (P.INT 16))) :-:
! ("raww32s", (P.RAW_STORE (P.UINT 32))) :-:
! ("rawi32s", (P.RAW_STORE (P.INT 32))) :-:
! ("rawf32s", (P.RAW_STORE (P.FLOAT 32))) :-:
! ("rawf64s", (P.RAW_STORE (P.FLOAT 64))) :-:
! ("rawccall", (P.RAW_CCALL NONE)) :-:
(* Support for direct construction of C objects on ML heap.
***************
*** 703,726 ****
*)
! ("rawrecord", (P.RAW_RECORD { fblock = false }, i_x)) :-:
! ("rawrecord64", (P.RAW_RECORD { fblock = true }, i_x)) :-:
! ("rawselectw8", (P.RAW_LOAD (P.UINT 8), xw32_w32)) :-:
! ("rawselecti8", (P.RAW_LOAD (P.INT 8), xw32_i32)) :-:
! ("rawselectw16", (P.RAW_LOAD (P.UINT 16), xw32_w32)) :-:
! ("rawselecti16", (P.RAW_LOAD (P.INT 16), xw32_i32)) :-:
! ("rawselectw32", (P.RAW_LOAD (P.UINT 32), xw32_w32)) :-:
! ("rawselecti32", (P.RAW_LOAD (P.INT 32), xw32_i32)) :-:
! ("rawselectf32", (P.RAW_LOAD (P.FLOAT 32), xw32_f64)) :-:
! ("rawselectf64", (P.RAW_LOAD (P.FLOAT 64), xw32_f64)) :-:
! ("rawupdatew8", (P.RAW_STORE (P.UINT 8), xw32w32_u)) :-:
! ("rawupdatei8", (P.RAW_STORE (P.INT 8), xw32i32_u)) :-:
! ("rawupdatew16", (P.RAW_STORE (P.UINT 16), xw32w32_u)) :-:
! ("rawupdatei16", (P.RAW_STORE (P.INT 16), xw32i32_u)) :-:
! ("rawupdatew32", (P.RAW_STORE (P.UINT 32), xw32w32_u)) :-:
! ("rawupdatei32", (P.RAW_STORE (P.INT 32), xw32i32_u)) :-:
! ("rawupdatef32", (P.RAW_STORE (P.FLOAT 32), xw32f64_u)) :-:
! ("rawupdatef64", (P.RAW_STORE (P.FLOAT 64), xw32f64_u))
fun primopMap name = RBMap.find(primops,name)
--- 703,726 ----
*)
! ("rawrecord", (P.RAW_RECORD { fblock = false })) :-:
! ("rawrecord64", (P.RAW_RECORD { fblock = true })) :-:
! ("rawselectw8", (P.RAW_LOAD (P.UINT 8))) :-:
! ("rawselecti8", (P.RAW_LOAD (P.INT 8))) :-:
! ("rawselectw16", (P.RAW_LOAD (P.UINT 16))) :-:
! ("rawselecti16", (P.RAW_LOAD (P.INT 16))) :-:
! ("rawselectw32", (P.RAW_LOAD (P.UINT 32))) :-:
! ("rawselecti32", (P.RAW_LOAD (P.INT 32))) :-:
! ("rawselectf32", (P.RAW_LOAD (P.FLOAT 32))) :-:
! ("rawselectf64", (P.RAW_LOAD (P.FLOAT 64))) :-:
! ("rawupdatew8", (P.RAW_STORE (P.UINT 8))) :-:
! ("rawupdatei8", (P.RAW_STORE (P.INT 8))) :-:
! ("rawupdatew16", (P.RAW_STORE (P.UINT 16))) :-:
! ("rawupdatei16", (P.RAW_STORE (P.INT 16))) :-:
! ("rawupdatew32", (P.RAW_STORE (P.UINT 32))) :-:
! ("rawupdatei32", (P.RAW_STORE (P.INT 32))) :-:
! ("rawupdatef32", (P.RAW_STORE (P.FLOAT 32))) :-:
! ("rawupdatef64", (P.RAW_STORE (P.FLOAT 64)))
fun primopMap name = RBMap.find(primops,name)
-------------------------------------------------------------------------
Using Tomcat but need to do more? Need to support web services, security?
Get stuff done quickly with pre-integrated technology to make your job easier
Download IBM WebSphere Application Server v.1.0.1 based on Apache Geronimo
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=120709&bid=263057&dat=121642