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 4876 - (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 :     ## Primitive operators
33 :    
34 :     ### Size-independent primops
35 :    
36 :     #### Continuation operators
37 :     * `callcc : ('a cont -> 'a) -> 'a`<br/>
38 :     `P.CALLCC`
39 :    
40 :     * `throw : 'a cont -> 'a -> 'b`<br/>
41 :     `P.THROW`
42 :    
43 :     * `capture : ('a control_cont -> 'a) -> 'a`<br/>
44 :     `P.CAPTURE`
45 :    
46 :     * `isolate : ('a -> unit) -> 'a cont`<br/>
47 :     `P.ISOLATE`
48 :    
49 :     * `cthrow : 'a control_cont -> 'a -> 'b`<br/>
50 :     `P.THROW`
51 :    
52 :    
53 :     #### Reference operations
54 :     * `! : 'a ref -> 'a`<br/>
55 :     `P.DEREF`
56 :    
57 :     * `:= : xx`<br/>
58 :     `P.ASSIGN`
59 :    
60 :     * `makeref : 'a ref * 'a -> unit`<br/>
61 :     `P.MAKEREF`
62 :    
63 :    
64 :     #### Boxity tests
65 :     * `boxed : 'a -> bool`<br/>
66 :     `P.BOXED`
67 :    
68 :     * `unboxed : 'a -> bool`<br/>
69 :     `P.UNBOXED`
70 :    
71 :    
72 :     #### Type cast
73 :     * `cast : 'a -> 'b`<br/>
74 :     `P.CAST`
75 :    
76 :    
77 :     #### Equality tests
78 :     * `= : ''a * ''a -> bool`<br/>
79 :     `P.POLYEQL`
80 :    
81 :     * `<> : ''a * ''a -> bool`<br/>
82 :     `P.POLYNEQ`
83 :    
84 :     * `ptreql : 'a * 'a -> bool`<br/>
85 :     `P.PTREQL`
86 :    
87 :     * `ptrneq : 'a * 'a -> bool`<br/>
88 :     `P.PTRNEQ`
89 :    
90 :    
91 :     #### Runtime hooks
92 :     * `getvar : unit -> 'a`<br/>
93 :     `P.GETVAR`
94 :    
95 :     * `setvar : 'a -> unit`<br/>
96 :     `P.SETVAR`
97 :    
98 :     * `setpseudo : 'a * int -> unit`<br/>
99 :     `P.SETPSEUDO`
100 :    
101 :     * `getpseudo : int -> 'a`<br/>
102 :     `P.GETPSEUDO`
103 :    
104 :     * `mkspecial : int * 'a -> 'b`<br/>
105 :     `P.MKSPECIAL`
106 :    
107 :     * `getspecial : 'a -> int`<br/>
108 :     `P.GETSPECIAL`
109 :    
110 :     * `setspecial : 'a * int -> unit`<br/>
111 :     `P.SETSPECIAL`
112 :    
113 :     * `gethdlr : unit -> 'a cont`<br/>
114 :     `P.GETHDLR`
115 :    
116 :     * `sethdlr : 'a cont -> unit`<br/>
117 :     `P.SETHDLR`
118 :    
119 :     * `gettag : 'a -> int`<br/>
120 :     `P.GETTAG`
121 :    
122 :     * `setmark : 'a -> unit`<br/>
123 :     `P.SETMARK`
124 :    
125 :     * `dispose : 'a -> unit`<br/>
126 :     `P.DISPOSE`
127 :    
128 :    
129 :     #### Inline operations
130 :     * `compose : ('b -> 'c) * ('a -> 'b) -> 'a -> 'c`<br/>
131 :     `P.INLCOMPOSE`
132 :    
133 :     * `before : 'a * 'b -> 'a`<br/>
134 :     `P.INLBEFORE`
135 :    
136 :     * `ignore : 'a -> unit`<br/>
137 :     `P.INLIGNORE`
138 :    
139 :     * `identity : 'a -> 'a`<br/>
140 :     `P.INLIDENTITY`
141 :    
142 :     * `length : 'a -> int`<br/>
143 :     `P.LENGTH`
144 :    
145 :     * `objlength : 'a -> int`<br/>
146 :     `P.OBJLENGTH`
147 :    
148 :     * `unboxedupdate : 'a array * int * 'a -> unit`<br/>
149 :     `P.UNBOXEDUPDATE`
150 :    
151 :    
152 :     #### Boolean operations
153 :     * `inlnot : bool -> bool`<br/>
154 :     `P.INLNOT`
155 :    
156 :    
157 :     #### Bytearray and bytevector operations
158 :     * `ordof : 'a * int -> 'b`<br/>
159 :     `P.NUMSUBSCRIPT{kind=P.INT 8, checked=false, immutable=true}`
160 :    
161 :     * `store : 'a * int * 'b -> unit`<br/>
162 :     `P.NUMUPDATE{kind=P.INT 8, checked=false}`
163 :    
164 :     * `inlbyteof : 'a * int -> 'b`<br/>
165 :     `P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=false}`
166 :    
167 :     * `inlstore : 'a * int * 'b -> unit`<br/>
168 :     `P.NUMUPDATE{kind=P.INT 8, checked=true}`
169 :    
170 :     * `inlordof : 'a * int -> 'b`<br/>
171 :     `P.NUMSUBSCRIPT{kind=P.INT 8, checked=true, immutable=true}`
172 :    
173 :    
174 :     #### Polymorphic array and vector
175 :     * `mkarray : int * 'a -> 'a array`<br/>
176 :     `P.INLMKARRAY`
177 :    
178 :     * `arrSub : 'a array * int -> 'a`<br/>
179 :     `P.SUBSCRIPT`
180 :    
181 :     * `arrChkSub : 'a array * int -> 'a`<br/>
182 :     `P.INLSUBSCRIPT`
183 :    
184 :     * `vecSub : 'a vector * int -> 'a`<br/>
185 :     `P.SUBSCRIPTV`
186 :    
187 :     * `vecChkSub : 'a vector * int -> 'a`<br/>
188 :     `P.INLSUBSCRIPTV`
189 :    
190 :     * `arrUpdate : 'a array * int * 'a -> unit`<br/>
191 :     `P.UPDATE`
192 :    
193 :     * `arrChkUpdate : 'a array * int * 'a -> unit`<br/>
194 :     `P.INLUPDATE`
195 :    
196 :    
197 :     #### Sequence operations
198 :     * `newArray0 : unit -> 'a`<br/>
199 :     `P.NEW_ARRAY0`
200 :    
201 :     * `getSeqData : 'a -> 'b`<br/>
202 :     `P.GET_SEQ_DATA`
203 :    
204 :     * `recordSub : 'a * int -> 'b`<br/>
205 :     `P.SUBSCRIPT_REC`
206 :    
207 :     * `raw64Sub : 'a * int -> real64`<br/>
208 :     `P.SUBSCRIPT_RAW64`
209 :    
210 :    
211 :     ### Numeric primops
212 :    
213 :     #### Default tagged integer operations
214 :     * `int_add : int * int -> int`<br/>
215 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT <int-size>}`
216 :    
217 :     * `int_sub : int * int -> int`<br/>
218 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT <int-size>}`
219 :    
220 :     * `int_mul : int * int -> int`<br/>
221 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT <int-size>}`
222 :    
223 :     * `int_div : int * int -> int`<br/>
224 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
225 :    
226 :     * `int_mod : int * int -> int`<br/>
227 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
228 :    
229 :     * `int_quot : int * int -> int`<br/>
230 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT <int-size>}`
231 :    
232 :     * `int_rem : int * int -> int`<br/>
233 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT <int-size>}`
234 :    
235 :     * `int_orb : int * int -> int`<br/>
236 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
237 :    
238 :     * `int_xorb : int * int -> int`<br/>
239 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
240 :    
241 :     * `int_andb : int * int -> int`<br/>
242 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
243 :    
244 :     * `int_neg : word32 -> word32`<br/>
245 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT <int-size>}`
246 :    
247 :     * `int_raw_rshift : int * word -> int`<br/>
248 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
249 :    
250 :     * `int_raw_lshift : int * word -> int`<br/>
251 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
252 :    
253 :     * `int_gt : int * int -> bool`<br/>
254 :     `P.CMP{oper=P.GT, kind=P.INT <int-size>}`
255 :    
256 :     * `int_ge : int * int -> bool`<br/>
257 :     `P.CMP{oper=P.GTE, kind=P.INT <int-size>}`
258 :    
259 :     * `int_lt : int * int -> bool`<br/>
260 :     `P.CMP{oper=P.LT, kind=P.INT <int-size>}`
261 :    
262 :     * `int_le : int * int -> bool`<br/>
263 :     `P.CMP{oper=P.LTE, kind=P.INT <int-size>}`
264 :    
265 :     * `int_eq : int * int -> bool`<br/>
266 :     `P.CMP{oper=P.EQL, kind=P.INT <int-size>}`
267 :    
268 :     * `int_ne : int * int -> bool`<br/>
269 :     `P.CMP{oper=P.NEQ, kind=P.INT <int-size>}`
270 :    
271 :     * `int_min : int * int -> int`<br/>
272 :     `P.INLMIN (P.INT <int-size>)`
273 :    
274 :     * `int_max : int * int -> int`<br/>
275 :     `P.INLMAX (P.INT <int-size>)`
276 :    
277 :     * `int_abs : word32 -> word32`<br/>
278 :     `P.INLABS (P.INT <int-size>)`
279 :    
280 :     #### Default tagged word operations
281 :     * `word_mul : word * word -> word`<br/>
282 :     `P.ARITH{oper=P.MUL, overflow=false, kind=P.INT <int-size>}`
283 :    
284 :     * `word_div : word * word -> word`<br/>
285 :     `P.ARITH{oper=P.QUOT, overflow=false, kind=P.INT <int-size>}`
286 :    
287 :     * `word_mod : word * word -> word`<br/>
288 :     `P.ARITH{oper=P.REM, overflow=false, kind=P.INT <int-size>}`
289 :    
290 :     * `word_add : word * word -> word`<br/>
291 :     `P.ARITH{oper=P.ADD, overflow=false, kind=P.INT <int-size>}`
292 :    
293 :     * `word_sub : word * word -> word`<br/>
294 :     `P.ARITH{oper=P.SUB, overflow=false, kind=P.INT <int-size>}`
295 :    
296 :     * `word_orb : word * word -> word`<br/>
297 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT <int-size>}`
298 :    
299 :     * `word_xorb : word * word -> word`<br/>
300 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT <int-size>}`
301 :    
302 :     * `word_andb : word * word -> word`<br/>
303 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT <int-size>}`
304 :    
305 :     * `word_notb : word -> word`<br/>
306 :     `P.ARITH{oper=P.NOTB, overflow=false, kind=P.INT <int-size>}`
307 :    
308 :     * `word_neg : word -> word`<br/>
309 :     `P.ARITH{oper=P.NEG, overflow=false, kind=P.INT <int-size>}`
310 :    
311 :     * `word_rshift : word * word -> word`<br/>
312 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT <int-size>}`
313 :    
314 :     * `word_rshiftl : word * word -> word`<br/>
315 :     `P.ARITH{oper=P.RSHIFTL, overflow=false, kind=P.INT <int-size>}`
316 :    
317 :     * `word_lshift : word * word -> word`<br/>
318 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT <int-size>}`
319 :    
320 :     * `word_gt : word * word -> bool`<br/>
321 :     `P.CMP{oper=P.GT, kind=P.UINT <int-size>}`
322 :    
323 :     * `word_ge : word * word -> bool`<br/>
324 :     `P.CMP{oper=P.GTE, kind=P.UINT <int-size>}`
325 :    
326 :     * `word_lt : word * word -> bool`<br/>
327 :     `P.CMP{oper=P.LT, kind=P.UINT <int-size>}`
328 :    
329 :     * `word_le : word * word -> bool`<br/>
330 :     `P.CMP{oper=P.LTE, kind=P.UINT <int-size>}`
331 :    
332 :     * `word_eq : word * word -> bool`<br/>
333 :     `P.CMP{oper=P.EQL, kind=P.UINT <int-size>}`
334 :    
335 :     * `word_ne : word * word -> bool`<br/>
336 :     `P.CMP{oper=P.NEQ, kind=P.UINT <int-size>}`
337 :    
338 :     * `word_raw_rshift : word * word -> word`<br/>
339 :     `P.INLRSHIFT(P.UINT <int-size>)`
340 :    
341 :     * `word_raw_rshiftl : word * word -> word`<br/>
342 :     `P.INLRSHIFTL(P.UINT <int-size>)`
343 :    
344 :     * `word_raw_lshift : word * word -> word`<br/>
345 :     `P.INLLSHIFT(P.UINT <int-size>)`
346 :    
347 :     * `word_min : word * word -> word`<br/>
348 :     `P.INLMIN (P.UINT <int-size>)`
349 :    
350 :     * `word_max : word * word -> word`<br/>
351 :     `P.INLMAX (P.UINT <int-size>)`
352 :    
353 :     #### 8-bit word operations
354 :    
355 :     #### 32-bit integer operations
356 :     * `int32_add : int32 * int32 -> int32`<br/>
357 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 32}`
358 :    
359 :     * `int32_sub : int32 * int32 -> int32`<br/>
360 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 32}`
361 :    
362 :     * `int32_mul : int32 * int32 -> int32`<br/>
363 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 32}`
364 :    
365 :     * `int32_div : int32 * int32 -> int32`<br/>
366 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
367 :    
368 :     * `int32_mod : int32 * int32 -> int32`<br/>
369 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
370 :    
371 :     * `int32_quot : int32 * int32 -> int32`<br/>
372 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 32}`
373 :    
374 :     * `int32_rem : int32 * int32 -> int32`<br/>
375 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 32}`
376 :    
377 :     * `int32_orb : int32 * int32 -> int32`<br/>
378 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 32}`
379 :    
380 :     * `int32_xorb : int32 * int32 -> int32`<br/>
381 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 32}`
382 :    
383 :     * `int32_andb : int32 * int32 -> int32`<br/>
384 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 32}`
385 :    
386 :     * `int32_neg : word32 -> word32`<br/>
387 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 32}`
388 :    
389 :     * `int32_raw_rshift : int32 * word -> int32`<br/>
390 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 32}`
391 :    
392 :     * `int32_raw_lshift : int32 * word -> int32`<br/>
393 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 32}`
394 :    
395 :     * `int32_gt : int32 * int32 -> bool`<br/>
396 :     `P.CMP{oper=P.GT, kind=P.INT 32}`
397 :    
398 :     * `int32_ge : int32 * int32 -> bool`<br/>
399 :     `P.CMP{oper=P.GTE, kind=P.INT 32}`
400 :    
401 :     * `int32_lt : int32 * int32 -> bool`<br/>
402 :     `P.CMP{oper=P.LT, kind=P.INT 32}`
403 :    
404 :     * `int32_le : int32 * int32 -> bool`<br/>
405 :     `P.CMP{oper=P.LTE, kind=P.INT 32}`
406 :    
407 :     * `int32_eq : int32 * int32 -> bool`<br/>
408 :     `P.CMP{oper=P.EQL, kind=P.INT 32}`
409 :    
410 :     * `int32_ne : int32 * int32 -> bool`<br/>
411 :     `P.CMP{oper=P.NEQ, kind=P.INT 32}`
412 :    
413 :     * `int32_min : int32 * int32 -> int32`<br/>
414 :     `P.INLMIN (P.INT 32)`
415 :    
416 :     * `int32_max : int32 * int32 -> int32`<br/>
417 :     `P.INLMAX (P.INT 32)`
418 :    
419 :     * `int32_abs : word32 -> word32`<br/>
420 :     `P.INLABS (P.INT 32)`
421 :    
422 :     #### 32-bit word operations
423 :    
424 :     #### 64-bit integer operations
425 :     * `int64_add : int64 * int64 -> int64`<br/>
426 :     `P.ARITH{oper=P.ADD, overflow=true, kind=P.INT 64}`
427 :    
428 :     * `int64_sub : int64 * int64 -> int64`<br/>
429 :     `P.ARITH{oper=P.SUB, overflow=true, kind=P.INT 64}`
430 :    
431 :     * `int64_mul : int64 * int64 -> int64`<br/>
432 :     `P.ARITH{oper=P.MUL, overflow=true, kind=P.INT 64}`
433 :    
434 :     * `int64_div : int64 * int64 -> int64`<br/>
435 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
436 :    
437 :     * `int64_mod : int64 * int64 -> int64`<br/>
438 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
439 :    
440 :     * `int64_quot : int64 * int64 -> int64`<br/>
441 :     `P.ARITH{oper=P.QUOT, overflow=true, kind=P.INT 64}`
442 :    
443 :     * `int64_rem : int64 * int64 -> int64`<br/>
444 :     `P.ARITH{oper=P.REM, overflow=true, kind=P.INT 64}`
445 :    
446 :     * `int64_orb : int64 * int64 -> int64`<br/>
447 :     `P.ARITH{oper=P.ORB, overflow=false, kind=P.INT 64}`
448 :    
449 :     * `int64_xorb : int64 * int64 -> int64`<br/>
450 :     `P.ARITH{oper=P.XORB, overflow=false, kind=P.INT 64}`
451 :    
452 :     * `int64_andb : int64 * int64 -> int64`<br/>
453 :     `P.ARITH{oper=P.ANDB, overflow=false, kind=P.INT 64}`
454 :    
455 :     * `int64_neg : word32 -> word32`<br/>
456 :     `P.ARITH{oper=P.NEG, overflow=true, kind=P.INT 64}`
457 :    
458 :     * `int64_raw_rshift : int64 * word -> int64`<br/>
459 :     `P.ARITH{oper=P.RSHIFT, overflow=false, kind=P.INT 64}`
460 :    
461 :     * `int64_raw_lshift : int64 * word -> int64`<br/>
462 :     `P.ARITH{oper=P.LSHIFT, overflow=false, kind=P.INT 64}`
463 :    
464 :     * `int64_gt : int64 * int64 -> bool`<br/>
465 :     `P.CMP{oper=P.GT, kind=P.INT 64}`
466 :    
467 :     * `int64_ge : int64 * int64 -> bool`<br/>
468 :     `P.CMP{oper=P.GTE, kind=P.INT 64}`
469 :    
470 :     * `int64_lt : int64 * int64 -> bool`<br/>
471 :     `P.CMP{oper=P.LT, kind=P.INT 64}`
472 :    
473 :     * `int64_le : int64 * int64 -> bool`<br/>
474 :     `P.CMP{oper=P.LTE, kind=P.INT 64}`
475 :    
476 :     * `int64_eq : int64 * int64 -> bool`<br/>
477 :     `P.CMP{oper=P.EQL, kind=P.INT 64}`
478 :    
479 :     * `int64_ne : int64 * int64 -> bool`<br/>
480 :     `P.CMP{oper=P.NEQ, kind=P.INT 64}`
481 :    
482 :     * `int64_min : int64 * int64 -> int64`<br/>
483 :     `P.INLMIN (P.INT 64)`
484 :    
485 :     * `int64_max : int64 * int64 -> int64`<br/>
486 :     `P.INLMAX (P.INT 64)`
487 :    
488 :     * `int64_abs : word32 -> word32`<br/>
489 :     `P.INLABS (P.INT 64)`
490 :    
491 :     #### 64-bit word operations
492 :    
493 :     #### 64-bit real operations
494 :    
495 :     ### Conversions

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