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 5019 - (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 : jhr 4985 * `compiler/ElabData/prim/primop.sig`<br/>
18 : jhr 4876 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 : jhr 5004 * "`w8arr`" -- bytearray (used for arrays of `Word8.word` and `char`)
45 :     * "`w8vec`" -- bytevector (used for strings and vectors of `Word8.word`)
46 : jhr 4879 * "`arr`" -- polymorphic arrays
47 :     * "`vec`" -- polymorphic vectors
48 : jhr 4880 * "`seq`" -- sequence types (arrays and vectors)
49 : jhr 4879
50 : jhr 4978 Following the type prefix may one or more attributes, which highlight properties
51 :     of the operation.
52 :    
53 : jhr 4879 We use the attribute "`raw`" to denote direct machine operations that are not
54 :     directly accesible in the Basis Library (*e.g.*, shift operations, where the basis
55 :     versions clamp the shift amount to the word size, but the raw versions do not).
56 :    
57 :     We use the attribute "`unsafe`" for operations that could potentially result in
58 :     a crash (*e.g.*, array subscript operations that do not check the index against
59 :     the array bounds).
60 :    
61 : jhr 4876 ## Primitive operators
62 :    
63 :     ### Size-independent primops
64 :    
65 :     #### Continuation operators
66 :     * `callcc : ('a cont -> 'a) -> 'a`<br/>
67 :     `P.CALLCC`
68 :    
69 :     * `throw : 'a cont -> 'a -> 'b`<br/>
70 :     `P.THROW`
71 :    
72 :     * `capture : ('a control_cont -> 'a) -> 'a`<br/>
73 :     `P.CAPTURE`
74 :    
75 :     * `isolate : ('a -> unit) -> 'a cont`<br/>
76 :     `P.ISOLATE`
77 :    
78 :     * `cthrow : 'a control_cont -> 'a -> 'b`<br/>
79 :     `P.THROW`
80 :    
81 :    
82 :     #### Reference operations
83 :     * `! : 'a ref -> 'a`<br/>
84 :     `P.DEREF`
85 :    
86 : jhr 4879 * `:= : 'a ref * 'a -> unit`<br/>
87 : jhr 4876 `P.ASSIGN`
88 :    
89 :     * `makeref : 'a ref * 'a -> unit`<br/>
90 :     `P.MAKEREF`
91 :    
92 :    
93 :     #### Boxity tests
94 :     * `boxed : 'a -> bool`<br/>
95 :     `P.BOXED`
96 :    
97 :     * `unboxed : 'a -> bool`<br/>
98 :     `P.UNBOXED`
99 :    
100 :    
101 :     #### Type cast
102 :     * `cast : 'a -> 'b`<br/>
103 :     `P.CAST`
104 :    
105 :    
106 :     #### Equality tests
107 :     * `= : ''a * ''a -> bool`<br/>
108 :     `P.POLYEQL`
109 :    
110 :     * `<> : ''a * ''a -> bool`<br/>
111 :     `P.POLYNEQ`
112 :    
113 : jhr 4885 * `ptr_eql : 'a * 'a -> bool`<br/>
114 : jhr 4876 `P.PTREQL`
115 :    
116 : jhr 4885 * `ptr_neq : 'a * 'a -> bool`<br/>
117 : jhr 4876 `P.PTRNEQ`
118 :    
119 :    
120 :     #### Runtime hooks
121 :     * `getvar : unit -> 'a`<br/>
122 :     `P.GETVAR`
123 :    
124 :     * `setvar : 'a -> unit`<br/>
125 :     `P.SETVAR`
126 :    
127 :     * `mkspecial : int * 'a -> 'b`<br/>
128 :     `P.MKSPECIAL`
129 :    
130 :     * `getspecial : 'a -> int`<br/>
131 :     `P.GETSPECIAL`
132 :    
133 :     * `setspecial : 'a * int -> unit`<br/>
134 :     `P.SETSPECIAL`
135 :    
136 :     * `gethdlr : unit -> 'a cont`<br/>
137 :     `P.GETHDLR`
138 :    
139 :     * `sethdlr : 'a cont -> unit`<br/>
140 :     `P.SETHDLR`
141 :    
142 :     * `gettag : 'a -> int`<br/>
143 :     `P.GETTAG`
144 :    
145 : jhr 4888 * `objlength : 'a -> int`<br/>
146 :     extracts the length field from an object's header word.
147 : jhr 4988 (`P.OBJLENGTH`)
148 : jhr 4876
149 :    
150 :     #### Inline operations
151 : jhr 4888 These primops are Basis Library functions that should be inlined for efficiency.
152 : jhr 4876 * `compose : ('b -> 'c) * ('a -> 'b) -> 'a -> 'c`<br/>
153 :     `P.INLCOMPOSE`
154 :    
155 :     * `before : 'a * 'b -> 'a`<br/>
156 :     `P.INLBEFORE`
157 :    
158 :     * `ignore : 'a -> unit`<br/>
159 :     `P.INLIGNORE`
160 :    
161 :     * `identity : 'a -> 'a`<br/>
162 :     `P.INLIDENTITY`
163 :    
164 : jhr 4879 * `bool_not : bool -> bool`<br/>
165 : jhr 4876 `P.INLNOT`
166 :    
167 : jhr 5019 * `char_chr : int -> char`<br/>
168 :     `P.INLCHR`
169 : jhr 4978
170 : jhr 5019 Some additional candidates for inlined operations include `hd`, `tl`, and `null`.
171 :    
172 : jhr 4888 If the compiler had the `option` and `order` datatypes builtin (like `bool` and `list`),
173 : jhr 4978 then `valOf`, `isSome`, `isNone` and some of the `compare` functions could also
174 :     be inlined.
175 : jhr 4876
176 : jhr 4978 In the long run, however, a better way to support inlining library functions would
177 :     be through a reliable cross-module inliner.
178 : jhr 4888
179 : jhr 4876 #### Bytearray and bytevector operations
180 : jhr 4879 Operations on byte/char array/vectors. We renamed these to make it clear
181 :     which operations do bounds checking and which do not.
182 : jhr 4876
183 : jhr 5004 * `w8vec_unsafe_sub : 'a * int -> 'b`<br/>
184 : jhr 4879 subscript from byte vector without bounds checking
185 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=true}`)
186 : jhr 4876
187 : jhr 5004 * `w8arr_unsafe_sub : 'a * int -> 'b`<br/>
188 : jhr 4879 subscript from byte array without bounds checking
189 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=false}`)
190 : jhr 4876
191 : jhr 5004 * `w8arr_unsafe_update : 'a * int * 'b -> unit`<br/>
192 : jhr 4879 update byte array without bounds checking
193 :     (`P.NUMUPDATE{kind=P.INT 8, checked=false}`)
194 : jhr 4876
195 : jhr 5004 * `w8vec_sub : 'a * int -> 'b`<br/>
196 : jhr 4879 subscript from byte vector
197 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=true}`)
198 : jhr 4876
199 : jhr 5004 * `w8arr_sub : 'a * int -> 'b`<br/>
200 : jhr 4879 subscript from byte array
201 :     (`P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=false}`)
202 : jhr 4876
203 : jhr 5004 * `w8arr_update : 'a * int * 'b -> unit`<br/>
204 : jhr 4879 update byte array
205 :     (`P.NUMUPDATE{kind=P.INT 8, checked=true}`)
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 : jhr 4988 (`P.UNBOXEDUPDATE`)
240 : jhr 4876
241 :     #### Sequence operations
242 : jhr 4880 Sequence values (*e.g.*, `string`, `'a array`, `RealVector.vector`, *etc*.)
243 :     are represented by a header consisting of a length (in elements) and a data
244 :     pointer to the raw sequence data.
245 :    
246 : jhr 4876 * `newArray0 : unit -> 'a`<br/>
247 :     `P.NEW_ARRAY0`
248 :    
249 : jhr 4880 * `seq_length : 'a -> int`<br/>
250 :     get the length field from a sequence header
251 : jhr 4988 (`P.LENGTH`)
252 : jhr 4880
253 :     * `seq_data : 'a -> 'b`<br/>
254 :     get the length field from a sequence header
255 : jhr 4988 (`P.GET_SEQ_DATA`)
256 : jhr 4876
257 : jhr 4879 * `unsafe_record_sub : 'a * int -> 'b`<br/>
258 : jhr 4876 `P.SUBSCRIPT_REC`
259 :    
260 :     * `raw64Sub : 'a * int -> real64`<br/>
261 : jhr 4978 gets an element from a packed tuple of 64-bit reals. The only use of
262 :     this function is in the implementation of the `Unsafe.Object.nth`
263 :     function. <br/>
264 : jhr 4988 (`P.SUBSCRIPT_RAW64`)
265 : jhr 4876
266 :    
267 :     ### Numeric primops
268 :    
269 :     #### Default tagged integer operations
270 : jhr 4879 These are the primitive operations on the default tagged integer
271 :     type (`Int.int`).
272 :    
273 : jhr 4876 * `int_add : int * int -> int`<br/>
274 : jhr 4884 Signed integer addition with overflow checking.
275 : jhr 5019 (`P.IARITH{oper=P.IADD, sz=<int-size>}`)
276 : jhr 4876
277 : jhr 4884 * `int_unsafe_add : int * int -> int`<br/>
278 :     Signed integer addition *without* overflow checking.
279 : jhr 5019 (`P.PURE_ARITH{oper=P.ADD, kind=P.UINT <int-size>}`)
280 : jhr 4884
281 : jhr 4876 * `int_sub : int * int -> int`<br/>
282 : jhr 4884 Signed integer subtraction with overflow checking.
283 : jhr 5019 (`P.IARITH{oper=P.ISUB, sz=<int-size>}`)
284 : jhr 4876
285 : jhr 4884 * `int_unsafe_sub : int * int -> int`<br/>
286 :     Signed integer subtraction *without* overflow checking.
287 : jhr 5019 (`P.PURE_ARITH{oper=P.SUB, kind=P.UINT <int-size>}`)
288 : jhr 4884
289 : jhr 4876 * `int_mul : int * int -> int`<br/>
290 : jhr 5019 `P.IARITH{oper=P.IMUL, sz=<int-size>}`
291 : jhr 4876
292 :     * `int_div : int * int -> int`<br/>
293 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=<int-size>}`
294 : jhr 4876
295 :     * `int_mod : int * int -> int`<br/>
296 : jhr 5019 `P.IARITH{oper=P.IREM, sz=<int-size>}`
297 : jhr 4876
298 :     * `int_quot : int * int -> int`<br/>
299 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=<int-size>}`
300 : jhr 4876
301 :     * `int_rem : int * int -> int`<br/>
302 : jhr 5019 `P.IARITH{oper=P.IREM, sz=<int-size>}`
303 : jhr 4876
304 :     * `int_orb : int * int -> int`<br/>
305 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.INT <int-size>}`
306 : jhr 4876
307 :     * `int_xorb : int * int -> int`<br/>
308 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.INT <int-size>}`
309 : jhr 4876
310 :     * `int_andb : int * int -> int`<br/>
311 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.INT <int-size>}`
312 : jhr 4876
313 :     * `int_neg : word32 -> word32`<br/>
314 : jhr 5019 `P.IARITH{oper=P.INEG, sz=<int-size>}`
315 : jhr 4876
316 :     * `int_raw_rshift : int * word -> int`<br/>
317 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.INT <int-size>}`
318 : jhr 4876
319 :     * `int_raw_lshift : int * word -> int`<br/>
320 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.INT <int-size>}`
321 : jhr 4876
322 :     * `int_gt : int * int -> bool`<br/>
323 :     `P.CMP{oper=P.GT, kind=P.INT <int-size>}`
324 :    
325 :     * `int_ge : int * int -> bool`<br/>
326 :     `P.CMP{oper=P.GTE, kind=P.INT <int-size>}`
327 :    
328 :     * `int_lt : int * int -> bool`<br/>
329 :     `P.CMP{oper=P.LT, kind=P.INT <int-size>}`
330 :    
331 :     * `int_le : int * int -> bool`<br/>
332 :     `P.CMP{oper=P.LTE, kind=P.INT <int-size>}`
333 :    
334 : jhr 4885 * `int_eql : int * int -> bool`<br/>
335 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT <int-size>}`
336 :    
337 : jhr 4885 * `int_neq : int * int -> bool`<br/>
338 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT <int-size>}`
339 :    
340 :     * `int_min : int * int -> int`<br/>
341 :     `P.INLMIN (P.INT <int-size>)`
342 :    
343 :     * `int_max : int * int -> int`<br/>
344 :     `P.INLMAX (P.INT <int-size>)`
345 :    
346 : jhr 4985 * `int_abs : int -> int`<br/>
347 : jhr 4876 `P.INLABS (P.INT <int-size>)`
348 :    
349 :     #### Default tagged word operations
350 : jhr 4879 These are the primitive operations on the default tagged word
351 :     type (`Word.word`).
352 :    
353 : jhr 4876 * `word_mul : word * word -> word`<br/>
354 : jhr 5019 `P.PURE_ARITH{oper=P.MUL, kind=P.UINT <int-size>}`
355 : jhr 4876
356 :     * `word_div : word * word -> word`<br/>
357 : jhr 5019 `P.PURE_ARITH{oper=P.QUOT, kind=P.UINT <int-size>}`
358 : jhr 4876
359 :     * `word_mod : word * word -> word`<br/>
360 : jhr 5019 `P.PURE_ARITH{oper=P.REM, kind=P.UINT <int-size>}`
361 : jhr 4876
362 :     * `word_add : word * word -> word`<br/>
363 : jhr 5019 `P.PURE_ARITH{oper=P.ADD, kind=P.UINT <int-size>}`
364 : jhr 4876
365 :     * `word_sub : word * word -> word`<br/>
366 : jhr 5019 `P.PURE_ARITH{oper=P.SUB, kind=P.UINT <int-size>}`
367 : jhr 4876
368 :     * `word_orb : word * word -> word`<br/>
369 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.UINT <int-size>}`
370 : jhr 4876
371 :     * `word_xorb : word * word -> word`<br/>
372 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.UINT <int-size>}`
373 : jhr 4876
374 :     * `word_andb : word * word -> word`<br/>
375 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.UINT <int-size>}`
376 : jhr 4876
377 :     * `word_notb : word -> word`<br/>
378 : jhr 5019 `P.PURE_ARITH{oper=P.NOTB, kind=P.UINT <int-size>}`
379 : jhr 4876
380 :     * `word_neg : word -> word`<br/>
381 : jhr 5019 `P.PURE_ARITH{oper=P.NEG, kind=P.UINT <int-size>}`
382 : jhr 4876
383 :     * `word_rshift : word * word -> word`<br/>
384 : jhr 4985 `P.INLRSHIFT(P.UINT <int-size>)`
385 : jhr 4876
386 :     * `word_rshiftl : word * word -> word`<br/>
387 : jhr 4985 `P.INLRSHIFTL(P.UINT <int-size>)`
388 : jhr 4876
389 :     * `word_lshift : word * word -> word`<br/>
390 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.UINT <int-size>}`
391 : jhr 4876
392 : jhr 4985 * `word_raw_rshift : word * word -> word`<br/>
393 :     `P.INLLSHIFT(P.UINT <int-size>)`
394 :    
395 :     * `word_raw_rshiftl : word * word -> word`<br/>
396 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFTL, kind=P.UINT <int-size>}`
397 : jhr 4985
398 :     * `word_raw_lshift : word * word -> word`<br/>
399 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.UINT <int-size>}`
400 : jhr 4985
401 : jhr 4876 * `word_gt : word * word -> bool`<br/>
402 :     `P.CMP{oper=P.GT, kind=P.UINT <int-size>}`
403 :    
404 :     * `word_ge : word * word -> bool`<br/>
405 :     `P.CMP{oper=P.GTE, kind=P.UINT <int-size>}`
406 :    
407 :     * `word_lt : word * word -> bool`<br/>
408 :     `P.CMP{oper=P.LT, kind=P.UINT <int-size>}`
409 :    
410 :     * `word_le : word * word -> bool`<br/>
411 :     `P.CMP{oper=P.LTE, kind=P.UINT <int-size>}`
412 :    
413 : jhr 4885 * `word_eql : word * word -> bool`<br/>
414 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.UINT <int-size>}`
415 :    
416 : jhr 4885 * `word_neq : word * word -> bool`<br/>
417 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.UINT <int-size>}`
418 :    
419 :     * `word_min : word * word -> word`<br/>
420 :     `P.INLMIN (P.UINT <int-size>)`
421 :    
422 :     * `word_max : word * word -> word`<br/>
423 :     `P.INLMAX (P.UINT <int-size>)`
424 :    
425 :     #### 8-bit word operations
426 :    
427 :     #### 32-bit integer operations
428 :     * `int32_add : int32 * int32 -> int32`<br/>
429 : jhr 5019 `P.IARITH{oper=P.IADD, sz=32}`
430 : jhr 4876
431 :     * `int32_sub : int32 * int32 -> int32`<br/>
432 : jhr 5019 `P.IARITH{oper=P.ISUB, sz=32}`
433 : jhr 4876
434 :     * `int32_mul : int32 * int32 -> int32`<br/>
435 : jhr 5019 `P.IARITH{oper=P.IMUL, sz=32}`
436 : jhr 4876
437 :     * `int32_div : int32 * int32 -> int32`<br/>
438 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=32}`
439 : jhr 4876
440 :     * `int32_mod : int32 * int32 -> int32`<br/>
441 : jhr 5019 `P.IARITH{oper=P.IREM, sz=32}`
442 : jhr 4876
443 :     * `int32_quot : int32 * int32 -> int32`<br/>
444 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=32}`
445 : jhr 4876
446 :     * `int32_rem : int32 * int32 -> int32`<br/>
447 : jhr 5019 `P.IARITH{oper=P.IREM, sz=32}`
448 : jhr 4876
449 :     * `int32_orb : int32 * int32 -> int32`<br/>
450 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.INT 32}`
451 : jhr 4876
452 :     * `int32_xorb : int32 * int32 -> int32`<br/>
453 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.INT 32}`
454 : jhr 4876
455 :     * `int32_andb : int32 * int32 -> int32`<br/>
456 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.INT 32}`
457 : jhr 4876
458 :     * `int32_neg : word32 -> word32`<br/>
459 : jhr 5019 `P.IARITH{oper=P.INEG, sz=32}`
460 : jhr 4876
461 :     * `int32_raw_rshift : int32 * word -> int32`<br/>
462 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.INT 32}`
463 : jhr 4876
464 :     * `int32_raw_lshift : int32 * word -> int32`<br/>
465 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.INT 32}`
466 : jhr 4876
467 :     * `int32_gt : int32 * int32 -> bool`<br/>
468 :     `P.CMP{oper=P.GT, kind=P.INT 32}`
469 :    
470 :     * `int32_ge : int32 * int32 -> bool`<br/>
471 :     `P.CMP{oper=P.GTE, kind=P.INT 32}`
472 :    
473 :     * `int32_lt : int32 * int32 -> bool`<br/>
474 :     `P.CMP{oper=P.LT, kind=P.INT 32}`
475 :    
476 :     * `int32_le : int32 * int32 -> bool`<br/>
477 :     `P.CMP{oper=P.LTE, kind=P.INT 32}`
478 :    
479 : jhr 4885 * `int32_eql : int32 * int32 -> bool`<br/>
480 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT 32}`
481 :    
482 : jhr 4885 * `int32_neq : int32 * int32 -> bool`<br/>
483 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT 32}`
484 :    
485 :     * `int32_min : int32 * int32 -> int32`<br/>
486 :     `P.INLMIN (P.INT 32)`
487 :    
488 :     * `int32_max : int32 * int32 -> int32`<br/>
489 :     `P.INLMAX (P.INT 32)`
490 :    
491 : jhr 4985 * `int32_abs : int32 -> int32`<br/>
492 : jhr 4876 `P.INLABS (P.INT 32)`
493 :    
494 :     #### 32-bit word operations
495 : jhr 4985 These operations work on the boxed 32-bit word type on 32-bit
496 :     machines and are just wrappers for 63-bit tagged word operations
497 :     on 64-bit machines.
498 : jhr 4876
499 : jhr 4985 * `word32_mul : word32 * word32 -> word32`<br/>
500 : jhr 5019 `P.PURE_ARITH{oper=P.MUL, kind=P.UINT 32}`
501 : jhr 4985
502 :     * `word32_div : word32 * word32 -> word32`<br/>
503 : jhr 5019 `P.PURE_ARITH{oper=P.QUOT, kind=P.UINT 32}`
504 : jhr 4985
505 :     * `word32_mod : word32 * word32 -> word32`<br/>
506 : jhr 5019 `P.PURE_ARITH{oper=P.REM, kind=P.UINT 32}`
507 : jhr 4985
508 :     * `word32_add : word32 * word32 -> word32`<br/>
509 : jhr 5019 `P.PURE_ARITH{oper=P.ADD, kind=P.UINT 32}`
510 : jhr 4985
511 :     * `word32_sub : word32 * word32 -> word32`<br/>
512 : jhr 5019 `P.PURE_ARITH{oper=P.SUB, kind=P.UINT 32}`
513 : jhr 4985
514 :     * `word32_orb : word32 * word32 -> word32`<br/>
515 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.UINT 32}`
516 : jhr 4985
517 :     * `word32_xorb : word32 * word32 -> word32`<br/>
518 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.UINT 32}`
519 : jhr 4985
520 :     * `word32_andb : word32 * word32 -> word32`<br/>
521 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.UINT 32}`
522 : jhr 4985
523 :     * `word32_notb : word32 -> word32`<br/>
524 : jhr 5019 `P.PURE_ARITH{oper=P.NOTB, kind=P.UINT 32}`
525 : jhr 4985
526 :     * `word32_neg : word32 -> word32`<br/>
527 : jhr 5019 `P.PURE_ARITH{oper=P.NEG, kind=P.UINT 32}`
528 : jhr 4985
529 :     * `word32_rshift : word32 * word -> word`<br/>
530 :     `P.INLRSHIFT(P.UINT 32)`
531 :    
532 :     * `word32_rshiftl : word32 * word -> word`<br/>
533 :     `P.INLRSHIFTL(P.UINT 32)`
534 :    
535 :     * `word32_lshift : word32 * word -> word`<br/>
536 :     `P.INLLSHIFT(P.UINT 32)`
537 :    
538 :     * `word32_raw_rshift : word32 * word -> word`<br/>
539 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.UINT 32}`
540 : jhr 4985
541 :     * `word32_raw_rshiftl : word32 * word -> word`<br/>
542 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFTL, kind=P.UINT 32}`
543 : jhr 4985
544 :     * `word32_raw_lshift : word32 * word -> word`<br/>
545 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.UINT 32}`
546 : jhr 4985
547 :     * `word32_gt : word32 * word32 -> bool`<br/>
548 :     `P.CMP{oper=P.GT, kind=P.UINT 32}`
549 :    
550 :     * `word32_ge : word32 * word32 -> bool`<br/>
551 :     `P.CMP{oper=P.GTE, kind=P.UINT 32}`
552 :    
553 :     * `word32_lt : word32 * word32 -> bool`<br/>
554 :     `P.CMP{oper=P.LT, kind=P.UINT 32}`
555 :    
556 :     * `word32_le : word32 * word32 -> bool`<br/>
557 :     `P.CMP{oper=P.LTE, kind=P.UINT 32}`
558 :    
559 :     * `word32_eql : word32 * word32 -> bool`<br/>
560 :     `P.CMP{oper=P.EQL, kind=P.UINT 32}`
561 :    
562 :     * `word32_neq : word32 * word32 -> bool`<br/>
563 :     `P.CMP{oper=P.NEQ, kind=P.UINT 32}`
564 :    
565 :     * `word32_min : word32 * word32 -> word32`<br/>
566 :     `P.INLMIN (P.UINT 32)`
567 :    
568 :     * `word32_max : word32 * word32 -> word32`<br/>
569 :     `P.INLMAX (P.UINT 32)`
570 :    
571 : jhr 4876 #### 64-bit integer operations
572 :     * `int64_add : int64 * int64 -> int64`<br/>
573 : jhr 5019 `P.IARITH{oper=P.IADD, sz=64}`
574 : jhr 4876
575 :     * `int64_sub : int64 * int64 -> int64`<br/>
576 : jhr 5019 `P.IARITH{oper=P.ISUB, sz=64}`
577 : jhr 4876
578 :     * `int64_mul : int64 * int64 -> int64`<br/>
579 : jhr 5019 `P.IARITH{oper=P.IMUL, sz=64}`
580 : jhr 4876
581 :     * `int64_div : int64 * int64 -> int64`<br/>
582 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=64}`
583 : jhr 4876
584 :     * `int64_mod : int64 * int64 -> int64`<br/>
585 : jhr 5019 `P.IARITH{oper=P.IREM, sz=64}`
586 : jhr 4876
587 :     * `int64_quot : int64 * int64 -> int64`<br/>
588 : jhr 5019 `P.IARITH{oper=P.IQUOT, sz=64}`
589 : jhr 4876
590 :     * `int64_rem : int64 * int64 -> int64`<br/>
591 : jhr 5019 `P.IARITH{oper=P.IREM, sz=64}`
592 : jhr 4876
593 :     * `int64_orb : int64 * int64 -> int64`<br/>
594 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.INT 64}`
595 : jhr 4876
596 :     * `int64_xorb : int64 * int64 -> int64`<br/>
597 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.INT 64}`
598 : jhr 4876
599 :     * `int64_andb : int64 * int64 -> int64`<br/>
600 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.INT 64}`
601 : jhr 4876
602 :     * `int64_neg : word32 -> word32`<br/>
603 : jhr 5019 `P.IARITH{oper=P.INEG, sz=64}`
604 : jhr 4876
605 :     * `int64_raw_rshift : int64 * word -> int64`<br/>
606 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.INT 64}`
607 : jhr 4876
608 :     * `int64_raw_lshift : int64 * word -> int64`<br/>
609 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.INT 64}`
610 : jhr 4876
611 :     * `int64_gt : int64 * int64 -> bool`<br/>
612 :     `P.CMP{oper=P.GT, kind=P.INT 64}`
613 :    
614 :     * `int64_ge : int64 * int64 -> bool`<br/>
615 :     `P.CMP{oper=P.GTE, kind=P.INT 64}`
616 :    
617 :     * `int64_lt : int64 * int64 -> bool`<br/>
618 :     `P.CMP{oper=P.LT, kind=P.INT 64}`
619 :    
620 :     * `int64_le : int64 * int64 -> bool`<br/>
621 :     `P.CMP{oper=P.LTE, kind=P.INT 64}`
622 :    
623 : jhr 4885 * `int64_eql : int64 * int64 -> bool`<br/>
624 : jhr 4876 `P.CMP{oper=P.EQL, kind=P.INT 64}`
625 :    
626 : jhr 4885 * `int64_neq : int64 * int64 -> bool`<br/>
627 : jhr 4876 `P.CMP{oper=P.NEQ, kind=P.INT 64}`
628 :    
629 :     * `int64_min : int64 * int64 -> int64`<br/>
630 :     `P.INLMIN (P.INT 64)`
631 :    
632 :     * `int64_max : int64 * int64 -> int64`<br/>
633 :     `P.INLMAX (P.INT 64)`
634 :    
635 : jhr 4985 * `int64_abs : int64 -> int64`<br/>
636 : jhr 4876 `P.INLABS (P.INT 64)`
637 :    
638 :     #### 64-bit word operations
639 :    
640 : jhr 4985 * `word64_mul : word64 * word64 -> word64`<br/>
641 : jhr 5019 `P.PURE_ARITH{oper=P.MUL, kind=P.UINT 64}`
642 : jhr 4985
643 :     * `word64_div : word64 * word64 -> word64`<br/>
644 : jhr 5019 `P.PURE_ARITH{oper=P.QUOT, kind=P.UINT 64}`
645 : jhr 4985
646 :     * `word64_mod : word64 * word64 -> word64`<br/>
647 : jhr 5019 `P.PURE_ARITH{oper=P.REM, kind=P.UINT 64}`
648 : jhr 4985
649 :     * `word64_add : word64 * word64 -> word64`<br/>
650 : jhr 5019 `P.PURE_ARITH{oper=P.ADD, kind=P.UINT 64}`
651 : jhr 4985
652 :     * `word64_sub : word64 * word64 -> word64`<br/>
653 : jhr 5019 `P.PURE_ARITH{oper=P.SUB, kind=P.UINT 64}`
654 : jhr 4985
655 :     * `word64_orb : word64 * word64 -> word64`<br/>
656 : jhr 5019 `P.PURE_ARITH{oper=P.ORB, kind=P.UINT 64}`
657 : jhr 4985
658 :     * `word64_xorb : word64 * word64 -> word64`<br/>
659 : jhr 5019 `P.PURE_ARITH{oper=P.XORB, kind=P.UINT 64}`
660 : jhr 4985
661 :     * `word64_andb : word64 * word64 -> word64`<br/>
662 : jhr 5019 `P.PURE_ARITH{oper=P.ANDB, kind=P.UINT 64}`
663 : jhr 4985
664 :     * `word64_notb : word64 -> word64`<br/>
665 : jhr 5019 `P.PURE_ARITH{oper=P.NOTB, kind=P.UINT 64}`
666 : jhr 4985
667 :     * `word64_neg : word64 -> word64`<br/>
668 : jhr 5019 `P.PURE_ARITH{oper=P.NEG, kind=P.UINT 64}`
669 : jhr 4985
670 :     * `word64_rshift : word64 * word -> word`<br/>
671 :     `P.INLRSHIFT(P.UINT 64)`
672 :    
673 :     * `word64_rshiftl : word64 * word -> word`<br/>
674 :     `P.INLRSHIFTL(P.UINT 64)`
675 :    
676 :     * `word64_lshift : word64 * word -> word`<br/>
677 :     `P.INLLSHIFT(P.UINT 64)`
678 :    
679 :     * `word64_raw_rshift : word64 * word -> word`<br/>
680 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFT, kind=P.UINT 64}`
681 : jhr 4985
682 :     * `word64_raw_rshiftl : word64 * word -> word`<br/>
683 : jhr 5019 `P.PURE_ARITH{oper=P.RSHIFTL, kind=P.UINT 64}`
684 : jhr 4985
685 :     * `word64_raw_lshift : word64 * word -> word`<br/>
686 : jhr 5019 `P.PURE_ARITH{oper=P.LSHIFT, kind=P.UINT 64}`
687 : jhr 4985
688 :     * `word64_gt : word64 * word64 -> bool`<br/>
689 :     `P.CMP{oper=P.GT, kind=P.UINT 64}`
690 :    
691 :     * `word64_ge : word64 * word64 -> bool`<br/>
692 :     `P.CMP{oper=P.GTE, kind=P.UINT 64}`
693 :    
694 :     * `word64_lt : word64 * word64 -> bool`<br/>
695 :     `P.CMP{oper=P.LT, kind=P.UINT 64}`
696 :    
697 :     * `word64_le : word64 * word64 -> bool`<br/>
698 :     `P.CMP{oper=P.LTE, kind=P.UINT 64}`
699 :    
700 :     * `word64_eql : word64 * word64 -> bool`<br/>
701 :     `P.CMP{oper=P.EQL, kind=P.UINT 64}`
702 :    
703 :     * `word64_neq : word64 * word64 -> bool`<br/>
704 :     `P.CMP{oper=P.NEQ, kind=P.UINT 64}`
705 :    
706 :     * `word64_min : word64 * word64 -> word64`<br/>
707 :     `P.INLMIN (P.UINT 64)`
708 :    
709 :     * `word64_max : word64 * word64 -> word64`<br/>
710 :     `P.INLMAX (P.UINT 64)`
711 :    
712 : jhr 4876 #### 64-bit real operations
713 : jhr 4985 * `real64_add : real64 * real64 -> real64`<br/>
714 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.FLOAT 64}`
715 : jhr 4876
716 : jhr 4985 * `real64_sub : real64 * real64 -> real64`<br/>
717 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.FLOAT 64}`
718 :    
719 :     * `real64_mul : real64 * real64 -> real64`<br/>
720 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.FLOAT 64}`
721 :    
722 :     * `real64_div : real64 * real64 -> real64`<br/>
723 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.FLOAT 64}`
724 :    
725 :     * `real64_neg : word32 -> word32`<br/>
726 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.FLOAT 64}`
727 :    
728 :     * `real64_gt : real64 * real64 -> bool`<br/>
729 :     `P.CMP{oper=P.GT, kind=P.FLOAT 64}`
730 :    
731 :     * `real64_ge : real64 * real64 -> bool`<br/>
732 :     `P.CMP{oper=P.GTE, kind=P.FLOAT 64}`
733 :    
734 :     * `real64_lt : real64 * real64 -> bool`<br/>
735 :     `P.CMP{oper=P.LT, kind=P.FLOAT 64}`
736 :    
737 :     * `real64_le : real64 * real64 -> bool`<br/>
738 :     `P.CMP{oper=P.LTE, kind=P.FLOAT 64}`
739 :    
740 :     * `real64_eql : real64 * real64 -> bool`<br/>
741 :     `P.CMP{oper=P.EQL, kind=P.FLOAT 64}`
742 :    
743 :     * `real64_neq : real64 * real64 -> bool`<br/>
744 :     `P.CMP{oper=P.NEQ, kind=P.FLOAT 64}`
745 :    
746 :     * `real64_sgn : real64 -> bool`<br/>
747 :     `P.CMP{oper=P.FSGN, kind=P.FLOAT 64}`
748 :    
749 :     * `real64_min : real64 * real64 -> real64`<br/>
750 :     `P.INLMIN (P.FLOAT 64)`
751 :    
752 :     * `real64_max : real64 * real64 -> real64`<br/>
753 :     `P.INLMAX (P.FLOAT 64)`
754 :    
755 :     * `abs : real64 -> real64`<br/>
756 :     `P.ARITH{oper=P.ABS, kind=P.FLOAT 64}`
757 :    
758 :     * `real64_sin : real64 -> real64`<br/>
759 :     `P.ARITH{oper=P.FSIN, kind=P.FLOAT 64}`
760 :    
761 :     * `real64_cos : real64 -> real64`<br/>
762 :     `P.ARITH{oper=P.FCOS, kind=P.FLOAT 64}`
763 :    
764 :     * `real64_tan : real64 -> real64`<br/>
765 :     `P.ARITH{oper=P.FTAN, kind=P.FLOAT 64}`
766 :    
767 :     * `real64_sqrt : real64 -> real64`<br/>
768 :     `P.ARITH{oper=P.FSQRT, kind=P.FLOAT 64}`
769 :    
770 :    
771 :     ### Conversions
772 :    
773 :     We use the following operation-prefixes for conversions between integer and
774 :     word types:
775 :    
776 :     * `cvt_unsigned` -- for word to integer conversions where the resulting
777 :     integer will be non-negative (*i.e.*, represent the same number as the
778 :     argument). These operations raise `Overflow` if the argument it not
779 :     representable as an integer of the specified size.
780 :    
781 :     * `cvt_signed` -- for word to integer conversions where the resulting
782 :     integer will have the same bit representation as the argument. These
783 :     operations raise `Overflow` if the argument (interpreted as a signed
784 :     2's complement number) is not representable as an integer of the specified
785 :     size.
786 :    
787 :     * `cvt` -- for integer-to-integer, integer-to-word, and word-to-word,
788 :     conversions. In the case of integer-to-integer conversions, the
789 :     operation will raise `Overflow` if the argument is too large to
790 :     represent in the result type.
791 :    
792 :     For conversions between integer and word types, there are five basic
793 :     primitive operations (**TEST**, **TESTU**, **EXTEND**, **TRUNC**, and **COPY**),
794 :     which are described in the `conversions.md` file.
795 :    
796 :     * `cvt_int_to_word : int -> word`<br />
797 :     `P.COPY(<int-size>, <int-size>)`
798 :    
799 :     * `cvt_signed_word_to_int : word -> int`<br />
800 :     `P.COPY(<int-size>, <int-size>)`
801 :    
802 :     * `cvt_unsigned_word_to_int : word -> int`<br />
803 :     `P.TESTU(<int-size>, <int-size>)`
804 :    
805 :     * `cvt_int_to_int8 : int -> int8`<br />
806 :     `P.TEST(<int-size>, 8)`
807 :    
808 :     * `cvt_int_to_word8 : int -> word8`<br />
809 :     `P.TRUNC(<int-size>, 8)`
810 :    
811 :     * `cvt_signed_word_to_int8 : word -> int8`<br />
812 :     `P.TEST(<int-size>, 8)`
813 :    
814 :     * `cvt_unsigned_word_to_int8 : word -> int8`<br />
815 :     `P.TESTU(<int-size>, 8)`
816 :    
817 :     * `cvt_word_to_word8 : word -> word8`<br />
818 :     `P.TRUNC(<int-size>, 8)`
819 :    
820 :     * `cvt_int_to_int32 : int -> int32`<br />
821 :     `P.EXTEND(31, 32)` on 32-bit targets or `P.TEST(63, 32)` on 64-bit targets.
822 :    
823 :     * `cvt_int_to_word32 : int -> word32`<br />
824 :     `P.COPY(31, 32)` on 32-bit targets or `P.TRUNC(63, 32)` on 64-bit targets.
825 :    
826 :     * `cvt_signed_word_to_int32 : word -> int32`<br />
827 :     `P.EXTEND(31, 32)` on 32-bit targets or `P.TEST(63, 32)` on 64-bit targets.
828 :    
829 :     * `cvt_unsigned_word_to_int32 : word -> int32`<br />
830 :     `P.COPY(31, 32)` on 32-bit targets or `P.TESTU(63, 32)` on 64-bit targets.
831 :    
832 :     * `cvt_word_to_word32 : word -> word32`<br />
833 :     `P.COPY(31, 32)` on 32-bit targets or `P.TRUNC(63, 32)` on 64-bit targets.
834 :    
835 :     * `cvt_int_to_int64 : int -> int64`<br />
836 :     `P.EXTEND(<int-size>, 64)`
837 :    
838 :     * `cvt_int_to_word64 : int -> word64`<br />
839 :    
840 :     * `cvt_signed_word_to_int64 : word -> int64`<br />
841 :    
842 :     * `cvt_unsigned_word_to_int64 : word -> int64`<br />
843 :    
844 :     * `cvt_word_to_word64 : word -> word64`<br />
845 :    
846 :     * `cvt_int8_to_int : int8 -> int`<br />
847 :    
848 :     * `cvt_int8_to_word : int8 -> word`<br />
849 :    
850 :     * `cvt_signed_word8_to_int : word8 -> int`<br />
851 :    
852 :     * `cvt_unsigned_word8_to_int : word8 -> int`<br />
853 :    
854 :     * `cvt_word8_to_word : word8 -> word`<br />
855 :    
856 :     * `cvt_int32_to_int : int32 -> int`<br />
857 :    
858 :     * `cvt_int32_to_word : int32 -> word`<br />
859 :    
860 :     * `cvt_signed_word32_to_int : word32 -> int`<br />
861 :    
862 :     * `cvt_unsigned_word32_to_int : word32 -> int`<br />
863 :    
864 :     * `cvt_word32_to_word : word32 -> word`<br />
865 :    
866 :     * `cvt_int64_to_int : int64 -> int`<br />
867 :    
868 :     * `cvt_int64_to_word : int64 -> word`<br />
869 :    
870 :     * `cvt_signed_word64_to_int : word64 -> int`<br />
871 :    
872 :     * `cvt_unsigned_word64_to_int : word64 -> int`<br />
873 :    
874 :     * `cvt_word64_to_word : word64 -> word`<br />
875 :    
876 :     #### Conversions that are specific to 32-bit targets
877 :    
878 :     These conversions assume that the `LargeWord` structure is
879 :     bound to `Word32` (even though there is a `Word64` structure).
880 :    
881 :     * `cvt_int8_to_word32 : int8 -> word32`<br />
882 :     `P.EXTEND(8, 32)`
883 :    
884 :     * `cvt_word8_to_word32 : word8 -> word32`<br />
885 :     `P.COPY(8, 32)`
886 :    
887 :     * `cvt_int32_to_word32 : int32 -> word32`<br />
888 :     `P.COPY(32, 32)`
889 :    
890 :     * `cvt_int64_to_word32 : int64 -> word32`<br />
891 :     `P.TRUNC(64, 32)`
892 :    
893 :     * `cvt_word64_to_word32 : word64 -> word32`<br />
894 :     `P.TRUNC(64, 32)`
895 :    
896 :     #### Conversions that are specific to 64-bit targets
897 :    
898 :     * `cvt_int8_to_word64 : int8 -> word64`<br />
899 :     `P.EXTEND(8, 64)`
900 :    
901 :     * `cvt_word8_to_word64 : word8 -> word64`<br />
902 :     `P.COPY(8, 64)`
903 :    
904 :     * `cvt_int32_to_word64 : int32 -> word64`<br />
905 :     `P.EXTEND(32, 64)`
906 :    
907 :     * `cvt_word32_to_word64 : word32 -> word64`<br />
908 :     `P.COPY(32, 64)`
909 :    
910 :     * `cvt_int64_to_word64 : int64 -> word64`<br />
911 :     `P.COPY(64, 64)`
912 :    
913 :     #### Conversions between integers and reals
914 :    
915 : jhr 4989 * `cvt_int_to_real64 : int -> real64`<br />
916 : jhr 4993 `P.INT_TO_REAL{from=<int-size>, to=64}`
917 : jhr 4989
918 :     * `cvt_int32_to_real64 : int32 -> real64`<br />
919 : jhr 4993 `P.INT_TO_REAL{from=32, to=64}`
920 : jhr 4989
921 :     * `floor_real64_to_int : real64 -> int`<br />
922 : jhr 4985 `P.ROUND{floor=true, from=64, to=<int-size>}`
923 :    
924 : jhr 4989 * `round_real64_to_int : real64 -> int`<br />
925 : jhr 4985 `P.ROUND{floor=false, from=64, to=<int-size>}`
926 : jhr 5019
927 :     ### Character comparisons
928 :    
929 :     * `char_lt : char * char -> bool`<br />
930 :     `P.CMP{oper=P.LT, kind=P.UINT <int-size>}`
931 :    
932 :     * `char_lte : char * char -> bool`<br />
933 :     `P.CMP{oper=P.LTE, kind=P.UINT <int-size>}`
934 :    
935 :     * `char_gt : char * char -> bool`<br />
936 :     `P.CMP{oper=P.GT, kind=P.UINT <int-size>}`
937 :    
938 :     * `char_gte : char * char -> bool`<br />
939 :     `P.CMP{oper=P.GTE, kind=P.UINT <int-size>}`

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