Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /dev-notes/primop-list.md
ViewVC logotype

Annotation of /dev-notes/primop-list.md

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4961 - (view) (download)

1 : jhr 4876 # SML/NJ Primitive Operations
2 :    
3 :     This document describes the primitive operators (primops) that the
4 :     compiler exposes. These are used to define the `InlineT` structure,
5 :     which, in turn is used in the implementation of the Basis Library.
6 :     With the addition of 64-bit targets, the mapping from primop to
7 :     internal representation becomes target-specific in many cases.
8 :    
9 :    
10 :     ## Relavant source files
11 :    
12 :     * `compiler/ElabData/prim/primop.sml`<br/>
13 :     this file defines the `Primop` structure, which includes the various
14 :     datatypes used to represent primitive operations internally in the
15 :     front-end of the compiler. The main type is `Primop.primop`.
16 :    
17 :     * `compiler/ElabData/prim/primop.sml`<br/>
18 :     this file defines the `PRIMOP` signature use for the `Primop` structure.
19 :    
20 :     * `compiler/Semant/prim/primop-bindings.sml`<br/>
21 :     this file defines the bindings between the SML variables
22 :     exposed by the compiler and the internal `Primop.primop`
23 :     type.
24 :    
25 :     * `system/smlnj/init/built-in32.sml`<br/>
26 :     this file defines the `InlineT` structure for 32-bit targets
27 :    
28 :    
29 :     ## Naming conventions
30 :    
31 : jhr 4879 Operations that "belong" to a specific type (*e.g.*, addition) have an initial
32 :     prefix that specifies the type as follows:
33 :    
34 :     * "`int`" -- default tagged integer type (*i.e.*, either `Int31.int` or `Int63.int`)
35 :     * "`word`" -- default tagged word type (*i.e.*, either `Word31.word` or `Word63.word`)
36 :     * "`int32`" -- 32-bit integers
37 :     * "`word32`" -- 32-bit words
38 :     * "`int64`" -- 64-bit integers
39 :     * "`word64`" -- 64-bit words
40 :     * "`intinf`" -- arbitrary precision integers
41 :     * "`real32`" -- 32-bit real numbers (not yet supported)
42 :     * "`real64`" -- 64-bit real numbers
43 :     * "`ptr`" -- machine address
44 :     * "`barr`" -- bytearray (used for arrays of `Word8.word` and `char`)
45 :     * "`bvec`" -- bytevector (used for strings and vectors of `Word8.word`)
46 :     * "`arr`" -- polymorphic arrays
47 :     * "`vec`" -- polymorphic vectors
48 : jhr 4880 * "`seq`" -- sequence types (arrays and vectors)
49 : jhr 4879
50 :     We use the attribute "`raw`" to denote direct machine operations that are not
51 :     directly accesible in the Basis Library (*e.g.*, shift operations, where the basis
52 :     versions clamp the shift amount to the word size, but the raw versions do not).
53 :    
54 :     We use the attribute "`unsafe`" for operations that could potentially result in
55 :     a crash (*e.g.*, array subscript operations that do not check the index against
56 :     the array bounds).
57 :    
58 : jhr 4876 ## Primitive operators
59 :    
60 :     ### Size-independent primops
61 :    
62 :     #### Continuation operators
63 :     * `callcc : ('a cont -> 'a) -> 'a`<br/>
64 :     `P.CALLCC`
65 :    
66 :     * `throw : 'a cont -> 'a -> 'b`<br/>
67 :     `P.THROW`
68 :    
69 :     * `capture : ('a control_cont -> 'a) -> 'a`<br/>
70 :     `P.CAPTURE`
71 :    
72 :     * `isolate : ('a -> unit) -> 'a cont`<br/>
73 :     `P.ISOLATE`
74 :    
75 :     * `cthrow : 'a control_cont -> 'a -> 'b`<br/>
76 :     `P.THROW`
77 :    
78 :    
79 :     #### Reference operations
80 :     * `! : 'a ref -> 'a`<br/>
81 :     `P.DEREF`
82 :    
83 : jhr 4879 * `:= : 'a ref * 'a -> unit`<br/>
84 : jhr 4876 `P.ASSIGN`
85 :    
86 :     * `makeref : 'a ref * 'a -> unit`<br/>
87 :     `P.MAKEREF`
88 :    
89 :    
90 :     #### Boxity tests
91 :     * `boxed : 'a -> bool`<br/>
92 :     `P.BOXED`
93 :    
94 :     * `unboxed : 'a -> bool`<br/>
95 :     `P.UNBOXED`
96 :    
97 :    
98 :     #### Type cast
99 :     * `cast : 'a -> 'b`<br/>
100 :     `P.CAST`
101 :    
102 :    
103 :     #### Equality tests
104 :     * `= : ''a * ''a -> bool`<br/>
105 :     `P.POLYEQL`
106 :    
107 :     * `<> : ''a * ''a -> bool`<br/>
108 :     `P.POLYNEQ`
109 :    
110 : jhr 4885 * `ptr_eql : 'a * 'a -> bool`<br/>
111 : jhr 4876 `P.PTREQL`
112 :    
113 : jhr 4885 * `ptr_neq : 'a * 'a -> bool`<br/>
114 : jhr 4876 `P.PTRNEQ`
115 :    
116 :    
117 :     #### Runtime hooks
118 :     * `getvar : unit -> 'a`<br/>
119 :     `P.GETVAR`
120 :    
121 :     * `setvar : 'a -> unit`<br/>
122 :     `P.SETVAR`
123 :    
124 :     * `mkspecial : int * 'a -> 'b`<br/>
125 :     `P.MKSPECIAL`
126 :    
127 :     * `getspecial : 'a -> int`<br/>
128 :     `P.GETSPECIAL`
129 :    
130 :     * `setspecial : 'a * int -> unit`<br/>
131 :     `P.SETSPECIAL`
132 :    
133 :     * `gethdlr : unit -> 'a cont`<br/>
134 :     `P.GETHDLR`
135 :    
136 :     * `sethdlr : 'a cont -> unit`<br/>
137 :     `P.SETHDLR`
138 :    
139 :     * `gettag : 'a -> int`<br/>
140 :     `P.GETTAG`
141 :    
142 : jhr 4888 * `objlength : 'a -> int`<br/>
143 :     extracts the length field from an object's header word.
144 :     `P.OBJLENGTH`
145 : jhr 4876
146 :    
147 :     #### Inline operations
148 : jhr 4888 These primops are Basis Library functions that should be inlined for efficiency.
149 : jhr 4876 * `compose : ('b -> 'c) * ('a -> 'b) -> 'a -> 'c`<br/>
150 :     `P.INLCOMPOSE`
151 :    
152 :     * `before : 'a * 'b -> 'a`<br/>
153 :     `P.INLBEFORE`
154 :    
155 :     * `ignore : 'a -> unit`<br/>
156 :     `P.INLIGNORE`
157 :    
158 :     * `identity : 'a -> 'a`<br/>
159 :     `P.INLIDENTITY`
160 :    
161 : jhr 4879 * `bool_not : bool -> bool`<br/>
162 : jhr 4876 `P.INLNOT`
163 :    
164 : jhr 4888 Some additional candidates for inlined operations include `hd`, `tl`, `null`, `chr`, and `ord`.
165 :     If the compiler had the `option` and `order` datatypes builtin (like `bool` and `list`),
166 :     then `valOf`, `isSome`, `isNone` and some of the `compare` functions could be inlined.
167 : jhr 4876
168 : jhr 4888
169 : jhr 4876 #### Bytearray and bytevector operations
170 : jhr 4879 Operations on byte/char array/vectors. We renamed these to make it clear
171 :     which operations do bounds checking and which do not.
172 : jhr 4876
173 : jhr 4879 * `bvec_unsafe_sub : 'a * int -> 'b`<br/>
174 :     subscript from byte vector without bounds checking
175 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=true}`)
176 : jhr 4876
177 : jhr 4879 * `barr_unsafe_sub : 'a * int -> 'b`<br/>
178 :     subscript from byte array without bounds checking
179 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=false}`)
180 : jhr 4876
181 : jhr 4879 * `barr_unsafe_update : 'a * int * 'b -> unit`<br/>
182 :     update byte array without bounds checking
183 :     (`P.NUMUPDATE{kind=P.INT 8, checked=false}`)
184 : jhr 4876
185 : jhr 4879 * `bvec_sub : 'a * int -> 'b`<br/>
186 :     subscript from byte vector
187 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=true}`)
188 : jhr 4876
189 : jhr 4879 * `barr_sub : 'a * int -> 'b`<br/>
190 :     subscript from byte array
191 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=false}`)
192 : jhr 4876
193 : jhr 4879 * `barr_update : 'a * int * 'b -> unit`<br/>
194 :     update byte array
195 :     (`P.NUMUPDATE{kind=P.INT 8, checked=true}`)
196 :    
197 :    
198 : jhr 4876 #### Polymorphic array and vector
199 :     * `mkarray : int * 'a -> 'a array`<br/>
200 : jhr 4879 create a polymorphic array
201 :     (`P.INLMKARRAY`)
202 : jhr 4876
203 : jhr 4879 * `arr_unsafe_sub : 'a array * int -> 'a`<br/>
204 :     subscript from polymorphic array without bounds checking
205 :     (`P.SUBSCRIPT`)
206 : jhr 4876
207 : jhr 4879 * `arr_sub : 'a array * int -> 'a`<br/>
208 :     subscript from polymorphic array
209 :     (`P.INLSUBSCRIPT`)
210 : jhr 4876
211 : jhr 4879 * `vec_unsafe_sub : 'a vector * int -> 'a`<br/>
212 :     subscript from polymorphic vector without bounds checking
213 :     (`P.SUBSCRIPTV`)
214 : jhr 4876
215 : jhr 4879 * `vec_sub : 'a vector * int -> 'a`<br/>
216 :     subscript from polymorphic vector
217 :     (`P.INLSUBSCRIPTV`)
218 : jhr 4876
219 : jhr 4879 * `arr_unsafe_update : 'a array * int * 'a -> unit`<br/>
220 :     update a polymorphic array without bounds checking
221 :     (`P.UPDATE`)
222 : jhr 4876
223 : jhr 4879 * `arr_update : 'a array * int * 'a -> unit`<br/>
224 :     update a polymorphic array
225 :     (`P.INLUPDATE`)
226 : jhr 4876
227 : jhr 4879 * `arr_unboxed_update : 'a array * int * 'a -> unit`<br/>
228 :     update a polymorphic array with an unboxed value, which means that there is
229 :     no store-list entry created for the update.
230 :     `P.UNBOXEDUPDATE`
231 : jhr 4876
232 : jhr 4879
233 : jhr 4876 #### Sequence operations
234 : jhr 4880 Sequence values (*e.g.*, `string`, `'a array`, `RealVector.vector`, *etc*.)
235 :     are represented by a header consisting of a length (in elements) and a data
236 :     pointer to the raw sequence data.
237 :    
238 : jhr 4876 * `newArray0 : unit -> 'a`<br/>
239 :     `P.NEW_ARRAY0`
240 :    
241 : jhr 4880 * `seq_length : 'a -> int`<br/>
242 :     get the length field from a sequence header
243 :     `P.LENGTH`
244 :    
245 :     * `seq_data : 'a -> 'b`<br/>
246 :     get the length field from a sequence header
247 : jhr 4876 `P.GET_SEQ_DATA`
248 :    
249 : jhr 4879 * `unsafe_record_sub : 'a * int -> 'b`<br/>
250 : jhr 4876 `P.SUBSCRIPT_REC`
251 :    
252 :     * `raw64Sub : 'a * int -> real64`<br/>
253 : jhr 4879 Unclear what purpose this primop serves
254 : jhr 4876 `P.SUBSCRIPT_RAW64`
255 :    
256 :    
257 :     ### Numeric primops
258 :    
259 :     #### Default tagged integer operations
260 : jhr 4879 These are the primitive operations on the default tagged integer
261 :     type (`Int.int`).
262 :    
263 : jhr 4876 * `int_add : int * int -> int`<br/>
264 : jhr 4884 Signed integer addition with overflow checking.
265 : jhr 4876 `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT <int-size>}`
266 :    
267 : jhr 4884 * `int_unsafe_add : int * int -> int`<br/>
268 :     Signed integer addition *without* overflow checking.
269 :     `P.ARITH{oper=P.ADD, overflow=false, kind=P.INT <int-size>}`
270 :    
271 : jhr 4876 * `int_sub : int * int -> int`<br/>
272 : jhr 4884 Signed integer subtraction with overflow checking.
273 : jhr 4876 `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT <int-size>}`
274 :    
275 : jhr 4884 * `int_unsafe_sub : int * int -> int`<br/>
276 :     Signed integer subtraction *without* overflow checking.
277 :     `P.ARITH{oper=P.SUB, overflow=false, kind=P.INT <int-size>}`
278 :    
279 : jhr 4876 * `int_mul : int * int -> int`<br/>
280 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT <int-size>}`
281 :    
282 :     * `int_div : int * int -> int`<br/>
283 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
284 :    
285 :     * `int_mod : int * int -> int`<br/>
286 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
287 :    
288 :     * `int_quot : int * int -> int`<br/>
289 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
290 :    
291 :     * `int_rem : int * int -> int`<br/>
292 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
293 :    
294 :     * `int_orb : int * int -> int`<br/>
295 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
296 :    
297 :     * `int_xorb : int * int -> int`<br/>
298 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
299 :    
300 :     * `int_andb : int * int -> int`<br/>
301 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
302 :    
303 :     * `int_neg : word32 -> word32`<br/>
304 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT <int-size>}`
305 :    
306 :     * `int_raw_rshift : int * word -> int`<br/>
307 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
308 :    
309 :     * `int_raw_lshift : int * word -> int`<br/>
310 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
311 :    
312 :     * `int_gt : int * int -> bool`<br/>
313 :     `P.CMP{oper=P.GT, kind=P.INT <int-size>}`
314 :    
315 :     * `int_ge : int * int -> bool`<br/>
316 :     `P.CMP{oper=P.GTE, kind=P.INT <int-size>}`
317 :    
318 :     * `int_lt : int * int -> bool`<br/>
319 :     `P.CMP{oper=P.LT, kind=P.INT <int-size>}`
320 :    
321 :     * `int_le : int * int -> bool`<br/>
322 :     `P.CMP{oper=P.LTE, kind=P.INT <int-size>}`
323 :    
324 : jhr 4885 * `int_eql : int * int -> bool`<br/>
325 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT <int-size>}`
326 :    
327 : jhr 4885 * `int_neq : int * int -> bool`<br/>
328 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT <int-size>}`
329 :    
330 :     * `int_min : int * int -> int`<br/>
331 :     `P.INLMIN (P.INT <int-size>)`
332 :    
333 :     * `int_max : int * int -> int`<br/>
334 :     `P.INLMAX (P.INT <int-size>)`
335 :    
336 :     * `int_abs : word32 -> word32`<br/>
337 :     `P.INLABS (P.INT <int-size>)`
338 :    
339 :     #### Default tagged word operations
340 : jhr 4879 These are the primitive operations on the default tagged word
341 :     type (`Word.word`).
342 :    
343 : jhr 4876 * `word_mul : word * word -> word`<br/>
344 :     `P.ARITH{oper=P.MUL, overflow=false, kind=P.INT <int-size>}`
345 :    
346 :     * `word_div : word * word -> word`<br/>
347 :     `P.ARITH{oper=P.QUOT, overflow=false, kind=P.INT <int-size>}`
348 :    
349 :     * `word_mod : word * word -> word`<br/>
350 :     `P.ARITH{oper=P.REM, overflow=false, kind=P.INT <int-size>}`
351 :    
352 :     * `word_add : word * word -> word`<br/>
353 :     `P.ARITH{oper=P.ADD, overflow=false, kind=P.INT <int-size>}`
354 :    
355 :     * `word_sub : word * word -> word`<br/>
356 :     `P.ARITH{oper=P.SUB, overflow=false, kind=P.INT <int-size>}`
357 :    
358 :     * `word_orb : word * word -> word`<br/>
359 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
360 :    
361 :     * `word_xorb : word * word -> word`<br/>
362 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
363 :    
364 :     * `word_andb : word * word -> word`<br/>
365 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
366 :    
367 :     * `word_notb : word -> word`<br/>
368 :     `P.ARITH{oper=P.NOTB, overflow=false, kind=P.INT <int-size>}`
369 :    
370 :     * `word_neg : word -> word`<br/>
371 :     `P.ARITH{oper=P.NEG, overflow=false, kind=P.INT <int-size>}`
372 :    
373 :     * `word_rshift : word * word -> word`<br/>
374 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
375 :    
376 :     * `word_rshiftl : word * word -> word`<br/>
377 :     `P.ARITH{oper=P.RSHIFTL, overflow=false, kind=P.INT <int-size>}`
378 :    
379 :     * `word_lshift : word * word -> word`<br/>
380 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
381 :    
382 :     * `word_gt : word * word -> bool`<br/>
383 :     `P.CMP{oper=P.GT, kind=P.UINT <int-size>}`
384 :    
385 :     * `word_ge : word * word -> bool`<br/>
386 :     `P.CMP{oper=P.GTE, kind=P.UINT <int-size>}`
387 :    
388 :     * `word_lt : word * word -> bool`<br/>
389 :     `P.CMP{oper=P.LT, kind=P.UINT <int-size>}`
390 :    
391 :     * `word_le : word * word -> bool`<br/>
392 :     `P.CMP{oper=P.LTE, kind=P.UINT <int-size>}`
393 :    
394 : jhr 4885 * `word_eql : word * word -> bool`<br/>
395 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.UINT <int-size>}`
396 :    
397 : jhr 4885 * `word_neq : word * word -> bool`<br/>
398 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.UINT <int-size>}`
399 :    
400 :     * `word_raw_rshift : word * word -> word`<br/>
401 :     `P.INLRSHIFT(P.UINT <int-size>)`
402 :    
403 :     * `word_raw_rshiftl : word * word -> word`<br/>
404 :     `P.INLRSHIFTL(P.UINT <int-size>)`
405 :    
406 :     * `word_raw_lshift : word * word -> word`<br/>
407 :     `P.INLLSHIFT(P.UINT <int-size>)`
408 :    
409 :     * `word_min : word * word -> word`<br/>
410 :     `P.INLMIN (P.UINT <int-size>)`
411 :    
412 :     * `word_max : word * word -> word`<br/>
413 :     `P.INLMAX (P.UINT <int-size>)`
414 :    
415 :     #### 8-bit word operations
416 :    
417 :     #### 32-bit integer operations
418 :     * `int32_add : int32 * int32 -> int32`<br/>
419 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 32}`
420 :    
421 :     * `int32_sub : int32 * int32 -> int32`<br/>
422 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 32}`
423 :    
424 :     * `int32_mul : int32 * int32 -> int32`<br/>
425 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 32}`
426 :    
427 :     * `int32_div : int32 * int32 -> int32`<br/>
428 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
429 :    
430 :     * `int32_mod : int32 * int32 -> int32`<br/>
431 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
432 :    
433 :     * `int32_quot : int32 * int32 -> int32`<br/>
434 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
435 :    
436 :     * `int32_rem : int32 * int32 -> int32`<br/>
437 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
438 :    
439 :     * `int32_orb : int32 * int32 -> int32`<br/>
440 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 32}`
441 :    
442 :     * `int32_xorb : int32 * int32 -> int32`<br/>
443 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 32}`
444 :    
445 :     * `int32_andb : int32 * int32 -> int32`<br/>
446 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 32}`
447 :    
448 :     * `int32_neg : word32 -> word32`<br/>
449 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 32}`
450 :    
451 :     * `int32_raw_rshift : int32 * word -> int32`<br/>
452 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 32}`
453 :    
454 :     * `int32_raw_lshift : int32 * word -> int32`<br/>
455 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 32}`
456 :    
457 :     * `int32_gt : int32 * int32 -> bool`<br/>
458 :     `P.CMP{oper=P.GT, kind=P.INT 32}`
459 :    
460 :     * `int32_ge : int32 * int32 -> bool`<br/>
461 :     `P.CMP{oper=P.GTE, kind=P.INT 32}`
462 :    
463 :     * `int32_lt : int32 * int32 -> bool`<br/>
464 :     `P.CMP{oper=P.LT, kind=P.INT 32}`
465 :    
466 :     * `int32_le : int32 * int32 -> bool`<br/>
467 :     `P.CMP{oper=P.LTE, kind=P.INT 32}`
468 :    
469 : jhr 4885 * `int32_eql : int32 * int32 -> bool`<br/>
470 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT 32}`
471 :    
472 : jhr 4885 * `int32_neq : int32 * int32 -> bool`<br/>
473 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT 32}`
474 :    
475 :     * `int32_min : int32 * int32 -> int32`<br/>
476 :     `P.INLMIN (P.INT 32)`
477 :    
478 :     * `int32_max : int32 * int32 -> int32`<br/>
479 :     `P.INLMAX (P.INT 32)`
480 :    
481 :     * `int32_abs : word32 -> word32`<br/>
482 :     `P.INLABS (P.INT 32)`
483 :    
484 :     #### 32-bit word operations
485 :    
486 :     #### 64-bit integer operations
487 :     * `int64_add : int64 * int64 -> int64`<br/>
488 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 64}`
489 :    
490 :     * `int64_sub : int64 * int64 -> int64`<br/>
491 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 64}`
492 :    
493 :     * `int64_mul : int64 * int64 -> int64`<br/>
494 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 64}`
495 :    
496 :     * `int64_div : int64 * int64 -> int64`<br/>
497 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
498 :    
499 :     * `int64_mod : int64 * int64 -> int64`<br/>
500 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
501 :    
502 :     * `int64_quot : int64 * int64 -> int64`<br/>
503 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
504 :    
505 :     * `int64_rem : int64 * int64 -> int64`<br/>
506 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
507 :    
508 :     * `int64_orb : int64 * int64 -> int64`<br/>
509 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 64}`
510 :    
511 :     * `int64_xorb : int64 * int64 -> int64`<br/>
512 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 64}`
513 :    
514 :     * `int64_andb : int64 * int64 -> int64`<br/>
515 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 64}`
516 :    
517 :     * `int64_neg : word32 -> word32`<br/>
518 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 64}`
519 :    
520 :     * `int64_raw_rshift : int64 * word -> int64`<br/>
521 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 64}`
522 :    
523 :     * `int64_raw_lshift : int64 * word -> int64`<br/>
524 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 64}`
525 :    
526 :     * `int64_gt : int64 * int64 -> bool`<br/>
527 :     `P.CMP{oper=P.GT, kind=P.INT 64}`
528 :    
529 :     * `int64_ge : int64 * int64 -> bool`<br/>
530 :     `P.CMP{oper=P.GTE, kind=P.INT 64}`
531 :    
532 :     * `int64_lt : int64 * int64 -> bool`<br/>
533 :     `P.CMP{oper=P.LT, kind=P.INT 64}`
534 :    
535 :     * `int64_le : int64 * int64 -> bool`<br/>
536 :     `P.CMP{oper=P.LTE, kind=P.INT 64}`
537 :    
538 : jhr 4885 * `int64_eql : int64 * int64 -> bool`<br/>
539 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT 64}`
540 :    
541 : jhr 4885 * `int64_neq : int64 * int64 -> bool`<br/>
542 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT 64}`
543 :    
544 :     * `int64_min : int64 * int64 -> int64`<br/>
545 :     `P.INLMIN (P.INT 64)`
546 :    
547 :     * `int64_max : int64 * int64 -> int64`<br/>
548 :     `P.INLMAX (P.INT 64)`
549 :    
550 :     * `int64_abs : word32 -> word32`<br/>
551 :     `P.INLABS (P.INT 64)`
552 :    
553 :     #### 64-bit word operations
554 :    
555 :     #### 64-bit real operations
556 :    
557 :     ### Conversions

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