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

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