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 4879 - (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 :    
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 :     * `ptreql : 'a * 'a -> bool`<br/>
111 :     `P.PTREQL`
112 :    
113 :     * `ptrneq : 'a * 'a -> bool`<br/>
114 :     `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 :     * `setpseudo : 'a * int -> unit`<br/>
125 :     `P.SETPSEUDO`
126 :    
127 :     * `getpseudo : int -> 'a`<br/>
128 :     `P.GETPSEUDO`
129 :    
130 :     * `mkspecial : int * 'a -> 'b`<br/>
131 :     `P.MKSPECIAL`
132 :    
133 :     * `getspecial : 'a -> int`<br/>
134 :     `P.GETSPECIAL`
135 :    
136 :     * `setspecial : 'a * int -> unit`<br/>
137 :     `P.SETSPECIAL`
138 :    
139 :     * `gethdlr : unit -> 'a cont`<br/>
140 :     `P.GETHDLR`
141 :    
142 :     * `sethdlr : 'a cont -> unit`<br/>
143 :     `P.SETHDLR`
144 :    
145 :     * `gettag : 'a -> int`<br/>
146 :     `P.GETTAG`
147 :    
148 :     * `setmark : 'a -> unit`<br/>
149 :     `P.SETMARK`
150 :    
151 :     * `dispose : 'a -> unit`<br/>
152 :     `P.DISPOSE`
153 :    
154 :    
155 :     #### Inline operations
156 :     * `compose : ('b -> 'c) * ('a -> 'b) -> 'a -> 'c`<br/>
157 :     `P.INLCOMPOSE`
158 :    
159 :     * `before : 'a * 'b -> 'a`<br/>
160 :     `P.INLBEFORE`
161 :    
162 :     * `ignore : 'a -> unit`<br/>
163 :     `P.INLIGNORE`
164 :    
165 :     * `identity : 'a -> 'a`<br/>
166 :     `P.INLIDENTITY`
167 :    
168 :     * `length : 'a -> int`<br/>
169 :     `P.LENGTH`
170 :    
171 :     * `objlength : 'a -> int`<br/>
172 :     `P.OBJLENGTH`
173 :    
174 : jhr 4879 * `bool_not : bool -> bool`<br/>
175 : jhr 4876 `P.INLNOT`
176 :    
177 :    
178 :     #### Bytearray and bytevector operations
179 : jhr 4879 Operations on byte/char array/vectors. We renamed these to make it clear
180 :     which operations do bounds checking and which do not.
181 : jhr 4876
182 : jhr 4879 * `bvec_unsafe_sub : 'a * int -> 'b`<br/>
183 :     subscript from byte vector without bounds checking
184 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=true}`)
185 : jhr 4876
186 : jhr 4879 * `barr_unsafe_sub : 'a * int -> 'b`<br/>
187 :     subscript from byte array without bounds checking
188 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=false}`)
189 : jhr 4876
190 : jhr 4879 * `barr_unsafe_update : 'a * int * 'b -> unit`<br/>
191 :     update byte array without bounds checking
192 :     (`P.NUMUPDATE{kind=P.INT 8, checked=false}`)
193 : jhr 4876
194 : jhr 4879 * `bvec_sub : 'a * int -> 'b`<br/>
195 :     subscript from byte vector
196 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=true}`)
197 : jhr 4876
198 : jhr 4879 * `barr_sub : 'a * int -> 'b`<br/>
199 :     subscript from byte array
200 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=false}`)
201 : jhr 4876
202 : jhr 4879 * `barr_update : 'a * int * 'b -> unit`<br/>
203 :     update byte array
204 :     (`P.NUMUPDATE{kind=P.INT 8, checked=true}`)
205 :    
206 :    
207 : jhr 4876 #### Polymorphic array and vector
208 :     * `mkarray : int * 'a -> 'a array`<br/>
209 : jhr 4879 create a polymorphic array
210 :     (`P.INLMKARRAY`)
211 : jhr 4876
212 : jhr 4879 * `arr_unsafe_sub : 'a array * int -> 'a`<br/>
213 :     subscript from polymorphic array without bounds checking
214 :     (`P.SUBSCRIPT`)
215 : jhr 4876
216 : jhr 4879 * `arr_sub : 'a array * int -> 'a`<br/>
217 :     subscript from polymorphic array
218 :     (`P.INLSUBSCRIPT`)
219 : jhr 4876
220 : jhr 4879 * `vec_unsafe_sub : 'a vector * int -> 'a`<br/>
221 :     subscript from polymorphic vector without bounds checking
222 :     (`P.SUBSCRIPTV`)
223 : jhr 4876
224 : jhr 4879 * `vec_sub : 'a vector * int -> 'a`<br/>
225 :     subscript from polymorphic vector
226 :     (`P.INLSUBSCRIPTV`)
227 : jhr 4876
228 : jhr 4879 * `arr_unsafe_update : 'a array * int * 'a -> unit`<br/>
229 :     update a polymorphic array without bounds checking
230 :     (`P.UPDATE`)
231 : jhr 4876
232 : jhr 4879 * `arr_update : 'a array * int * 'a -> unit`<br/>
233 :     update a polymorphic array
234 :     (`P.INLUPDATE`)
235 : jhr 4876
236 : jhr 4879 * `arr_unboxed_update : 'a array * int * 'a -> unit`<br/>
237 :     update a polymorphic array with an unboxed value, which means that there is
238 :     no store-list entry created for the update.
239 :     `P.UNBOXEDUPDATE`
240 : jhr 4876
241 : jhr 4879
242 : jhr 4876 #### Sequence operations
243 :     * `newArray0 : unit -> 'a`<br/>
244 :     `P.NEW_ARRAY0`
245 :    
246 : jhr 4879 * `seq_get_data : 'a -> 'b`<br/>
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 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT <int-size>}`
265 :    
266 :     * `int_sub : int * int -> int`<br/>
267 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT <int-size>}`
268 :    
269 :     * `int_mul : int * int -> int`<br/>
270 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT <int-size>}`
271 :    
272 :     * `int_div : int * int -> int`<br/>
273 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
274 :    
275 :     * `int_mod : int * int -> int`<br/>
276 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
277 :    
278 :     * `int_quot : int * int -> int`<br/>
279 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
280 :    
281 :     * `int_rem : int * int -> int`<br/>
282 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
283 :    
284 :     * `int_orb : int * int -> int`<br/>
285 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
286 :    
287 :     * `int_xorb : int * int -> int`<br/>
288 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
289 :    
290 :     * `int_andb : int * int -> int`<br/>
291 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
292 :    
293 :     * `int_neg : word32 -> word32`<br/>
294 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT <int-size>}`
295 :    
296 :     * `int_raw_rshift : int * word -> int`<br/>
297 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
298 :    
299 :     * `int_raw_lshift : int * word -> int`<br/>
300 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
301 :    
302 :     * `int_gt : int * int -> bool`<br/>
303 :     `P.CMP{oper=P.GT, kind=P.INT <int-size>}`
304 :    
305 :     * `int_ge : int * int -> bool`<br/>
306 :     `P.CMP{oper=P.GTE, kind=P.INT <int-size>}`
307 :    
308 :     * `int_lt : int * int -> bool`<br/>
309 :     `P.CMP{oper=P.LT, kind=P.INT <int-size>}`
310 :    
311 :     * `int_le : int * int -> bool`<br/>
312 :     `P.CMP{oper=P.LTE, kind=P.INT <int-size>}`
313 :    
314 :     * `int_eq : int * int -> bool`<br/>
315 :     `P.CMP{oper=P.EQL, kind=P.INT <int-size>}`
316 :    
317 :     * `int_ne : int * int -> bool`<br/>
318 :     `P.CMP{oper=P.NEQ, kind=P.INT <int-size>}`
319 :    
320 :     * `int_min : int * int -> int`<br/>
321 :     `P.INLMIN (P.INT <int-size>)`
322 :    
323 :     * `int_max : int * int -> int`<br/>
324 :     `P.INLMAX (P.INT <int-size>)`
325 :    
326 :     * `int_abs : word32 -> word32`<br/>
327 :     `P.INLABS (P.INT <int-size>)`
328 :    
329 :     #### Default tagged word operations
330 : jhr 4879 These are the primitive operations on the default tagged word
331 :     type (`Word.word`).
332 :    
333 : jhr 4876 * `word_mul : word * word -> word`<br/>
334 :     `P.ARITH{oper=P.MUL, overflow=false, kind=P.INT <int-size>}`
335 :    
336 :     * `word_div : word * word -> word`<br/>
337 :     `P.ARITH{oper=P.QUOT, overflow=false, kind=P.INT <int-size>}`
338 :    
339 :     * `word_mod : word * word -> word`<br/>
340 :     `P.ARITH{oper=P.REM, overflow=false, kind=P.INT <int-size>}`
341 :    
342 :     * `word_add : word * word -> word`<br/>
343 :     `P.ARITH{oper=P.ADD, overflow=false, kind=P.INT <int-size>}`
344 :    
345 :     * `word_sub : word * word -> word`<br/>
346 :     `P.ARITH{oper=P.SUB, overflow=false, kind=P.INT <int-size>}`
347 :    
348 :     * `word_orb : word * word -> word`<br/>
349 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
350 :    
351 :     * `word_xorb : word * word -> word`<br/>
352 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
353 :    
354 :     * `word_andb : word * word -> word`<br/>
355 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
356 :    
357 :     * `word_notb : word -> word`<br/>
358 :     `P.ARITH{oper=P.NOTB, overflow=false, kind=P.INT <int-size>}`
359 :    
360 :     * `word_neg : word -> word`<br/>
361 :     `P.ARITH{oper=P.NEG, overflow=false, kind=P.INT <int-size>}`
362 :    
363 :     * `word_rshift : word * word -> word`<br/>
364 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
365 :    
366 :     * `word_rshiftl : word * word -> word`<br/>
367 :     `P.ARITH{oper=P.RSHIFTL, overflow=false, kind=P.INT <int-size>}`
368 :    
369 :     * `word_lshift : word * word -> word`<br/>
370 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
371 :    
372 :     * `word_gt : word * word -> bool`<br/>
373 :     `P.CMP{oper=P.GT, kind=P.UINT <int-size>}`
374 :    
375 :     * `word_ge : word * word -> bool`<br/>
376 :     `P.CMP{oper=P.GTE, kind=P.UINT <int-size>}`
377 :    
378 :     * `word_lt : word * word -> bool`<br/>
379 :     `P.CMP{oper=P.LT, kind=P.UINT <int-size>}`
380 :    
381 :     * `word_le : word * word -> bool`<br/>
382 :     `P.CMP{oper=P.LTE, kind=P.UINT <int-size>}`
383 :    
384 :     * `word_eq : word * word -> bool`<br/>
385 :     `P.CMP{oper=P.EQL, kind=P.UINT <int-size>}`
386 :    
387 :     * `word_ne : word * word -> bool`<br/>
388 :     `P.CMP{oper=P.NEQ, kind=P.UINT <int-size>}`
389 :    
390 :     * `word_raw_rshift : word * word -> word`<br/>
391 :     `P.INLRSHIFT(P.UINT <int-size>)`
392 :    
393 :     * `word_raw_rshiftl : word * word -> word`<br/>
394 :     `P.INLRSHIFTL(P.UINT <int-size>)`
395 :    
396 :     * `word_raw_lshift : word * word -> word`<br/>
397 :     `P.INLLSHIFT(P.UINT <int-size>)`
398 :    
399 :     * `word_min : word * word -> word`<br/>
400 :     `P.INLMIN (P.UINT <int-size>)`
401 :    
402 :     * `word_max : word * word -> word`<br/>
403 :     `P.INLMAX (P.UINT <int-size>)`
404 :    
405 :     #### 8-bit word operations
406 :    
407 :     #### 32-bit integer operations
408 :     * `int32_add : int32 * int32 -> int32`<br/>
409 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 32}`
410 :    
411 :     * `int32_sub : int32 * int32 -> int32`<br/>
412 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 32}`
413 :    
414 :     * `int32_mul : int32 * int32 -> int32`<br/>
415 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 32}`
416 :    
417 :     * `int32_div : int32 * int32 -> int32`<br/>
418 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
419 :    
420 :     * `int32_mod : int32 * int32 -> int32`<br/>
421 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
422 :    
423 :     * `int32_quot : int32 * int32 -> int32`<br/>
424 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
425 :    
426 :     * `int32_rem : int32 * int32 -> int32`<br/>
427 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
428 :    
429 :     * `int32_orb : int32 * int32 -> int32`<br/>
430 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 32}`
431 :    
432 :     * `int32_xorb : int32 * int32 -> int32`<br/>
433 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 32}`
434 :    
435 :     * `int32_andb : int32 * int32 -> int32`<br/>
436 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 32}`
437 :    
438 :     * `int32_neg : word32 -> word32`<br/>
439 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 32}`
440 :    
441 :     * `int32_raw_rshift : int32 * word -> int32`<br/>
442 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 32}`
443 :    
444 :     * `int32_raw_lshift : int32 * word -> int32`<br/>
445 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 32}`
446 :    
447 :     * `int32_gt : int32 * int32 -> bool`<br/>
448 :     `P.CMP{oper=P.GT, kind=P.INT 32}`
449 :    
450 :     * `int32_ge : int32 * int32 -> bool`<br/>
451 :     `P.CMP{oper=P.GTE, kind=P.INT 32}`
452 :    
453 :     * `int32_lt : int32 * int32 -> bool`<br/>
454 :     `P.CMP{oper=P.LT, kind=P.INT 32}`
455 :    
456 :     * `int32_le : int32 * int32 -> bool`<br/>
457 :     `P.CMP{oper=P.LTE, kind=P.INT 32}`
458 :    
459 :     * `int32_eq : int32 * int32 -> bool`<br/>
460 :     `P.CMP{oper=P.EQL, kind=P.INT 32}`
461 :    
462 :     * `int32_ne : int32 * int32 -> bool`<br/>
463 :     `P.CMP{oper=P.NEQ, kind=P.INT 32}`
464 :    
465 :     * `int32_min : int32 * int32 -> int32`<br/>
466 :     `P.INLMIN (P.INT 32)`
467 :    
468 :     * `int32_max : int32 * int32 -> int32`<br/>
469 :     `P.INLMAX (P.INT 32)`
470 :    
471 :     * `int32_abs : word32 -> word32`<br/>
472 :     `P.INLABS (P.INT 32)`
473 :    
474 :     #### 32-bit word operations
475 :    
476 :     #### 64-bit integer operations
477 :     * `int64_add : int64 * int64 -> int64`<br/>
478 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 64}`
479 :    
480 :     * `int64_sub : int64 * int64 -> int64`<br/>
481 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 64}`
482 :    
483 :     * `int64_mul : int64 * int64 -> int64`<br/>
484 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 64}`
485 :    
486 :     * `int64_div : int64 * int64 -> int64`<br/>
487 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
488 :    
489 :     * `int64_mod : int64 * int64 -> int64`<br/>
490 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
491 :    
492 :     * `int64_quot : int64 * int64 -> int64`<br/>
493 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
494 :    
495 :     * `int64_rem : int64 * int64 -> int64`<br/>
496 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
497 :    
498 :     * `int64_orb : int64 * int64 -> int64`<br/>
499 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 64}`
500 :    
501 :     * `int64_xorb : int64 * int64 -> int64`<br/>
502 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 64}`
503 :    
504 :     * `int64_andb : int64 * int64 -> int64`<br/>
505 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 64}`
506 :    
507 :     * `int64_neg : word32 -> word32`<br/>
508 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 64}`
509 :    
510 :     * `int64_raw_rshift : int64 * word -> int64`<br/>
511 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 64}`
512 :    
513 :     * `int64_raw_lshift : int64 * word -> int64`<br/>
514 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 64}`
515 :    
516 :     * `int64_gt : int64 * int64 -> bool`<br/>
517 :     `P.CMP{oper=P.GT, kind=P.INT 64}`
518 :    
519 :     * `int64_ge : int64 * int64 -> bool`<br/>
520 :     `P.CMP{oper=P.GTE, kind=P.INT 64}`
521 :    
522 :     * `int64_lt : int64 * int64 -> bool`<br/>
523 :     `P.CMP{oper=P.LT, kind=P.INT 64}`
524 :    
525 :     * `int64_le : int64 * int64 -> bool`<br/>
526 :     `P.CMP{oper=P.LTE, kind=P.INT 64}`
527 :    
528 :     * `int64_eq : int64 * int64 -> bool`<br/>
529 :     `P.CMP{oper=P.EQL, kind=P.INT 64}`
530 :    
531 :     * `int64_ne : int64 * int64 -> bool`<br/>
532 :     `P.CMP{oper=P.NEQ, kind=P.INT 64}`
533 :    
534 :     * `int64_min : int64 * int64 -> int64`<br/>
535 :     `P.INLMIN (P.INT 64)`
536 :    
537 :     * `int64_max : int64 * int64 -> int64`<br/>
538 :     `P.INLMAX (P.INT 64)`
539 :    
540 :     * `int64_abs : word32 -> word32`<br/>
541 :     `P.INLABS (P.INT 64)`
542 :    
543 :     #### 64-bit word operations
544 :    
545 :     #### 64-bit real operations
546 :    
547 :     ### Conversions

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