package wasm_of_ocaml-compiler

  1. Overview
  2. Docs

Source file target_sig.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
(* Wasm_of_ocaml compiler
 * http://www.ocsigen.org/js_of_ocaml/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, with linking exception;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *)

module type S = sig
  type expression = Code_generation.expression

  module Memory : sig
    val allocate :
         tag:int
      -> deadcode_sentinal:Code.Var.t
      -> load:(Code.Var.t -> expression)
      -> [ `Expr of Wasm_ast.expression | `Var of Wasm_ast.var ] list
      -> expression

    val load_function_pointer :
         cps:bool
      -> arity:int
      -> ?skip_cast:bool
      -> expression
      -> (Wasm_ast.var * Wasm_ast.expression) Code_generation.t

    val load_real_closure :
         cps:bool
      -> arity:int
      -> expression
      -> (Wasm_ast.var * Wasm_ast.expression) Code_generation.t

    val check_function_arity :
         Code.Var.t
      -> cps:bool
      -> arity:int
      -> (typ:Wasm_ast.value_type option -> expression -> expression)
      -> unit Code_generation.t
      -> unit Code_generation.t

    val tag : expression -> expression

    val field : expression -> int -> expression

    val set_field : expression -> int -> expression -> unit Code_generation.t

    val array_get : expression -> expression -> expression

    val array_set : expression -> expression -> expression -> unit Code_generation.t

    val float_array_get : expression -> expression -> expression

    val float_array_set : expression -> expression -> expression -> unit Code_generation.t

    val check_is_float_array : expression -> expression

    val gen_array_get : expression -> expression -> expression

    val gen_array_set : expression -> expression -> expression -> unit Code_generation.t

    val array_length : expression -> expression

    val float_array_length : expression -> expression

    val gen_array_length : expression -> expression

    val bytes_length : expression -> expression

    val bytes_get : expression -> expression -> expression

    val bytes_set : expression -> expression -> expression -> unit Code_generation.t

    val box_float : expression -> expression

    val unbox_float : expression -> expression

    val box_int32 : expression -> expression

    val unbox_int32 : expression -> expression

    val box_int64 : expression -> expression

    val unbox_int64 : expression -> expression

    val box_nativeint : expression -> expression

    val unbox_nativeint : expression -> expression
  end

  module Type : sig
    val value : Wasm_ast.value_type

    val func_type : int -> Wasm_ast.func_type

    val primitive_type : int -> Wasm_ast.func_type
  end

  module Value : sig
    val unit : expression

    val val_int : expression -> expression

    val int_val : expression -> expression

    val check_is_not_zero : expression -> expression
    (** Returns an int32 value *)

    val check_is_int : expression -> expression
    (** Returns an int32 value *)

    val not : expression -> expression

    val lt : expression -> expression -> expression

    val le : expression -> expression -> expression

    val js_eqeqeq : negate:bool -> expression -> expression -> expression

    val phys_eq : expression -> expression -> expression

    val phys_neq : expression -> expression -> expression

    val ult : expression -> expression -> expression

    val is_int : expression -> expression

    val int_add : expression -> expression -> expression

    val int_sub : expression -> expression -> expression

    val int_mul : expression -> expression -> expression

    val int_div : expression -> expression -> expression

    val int_mod : expression -> expression -> expression

    val int_neg : expression -> expression

    val int_or : expression -> expression -> expression

    val int_and : expression -> expression -> expression

    val int_xor : expression -> expression -> expression

    val int_lsl : expression -> expression -> expression

    val int_lsr : expression -> expression -> expression

    val int_asr : expression -> expression -> expression

    val block_type : Wasm_ast.value_type Code_generation.t

    val dummy_block : expression

    val as_block : expression -> expression
  end

  module Constant : sig
    val translate : Code.constant -> expression
  end

  module Closure : sig
    val translate :
         context:Code_generation.context
      -> closures:Closure_conversion.closure Code.Var.Map.t
      -> cps:bool
      -> Code.Var.t
      -> expression

    val bind_environment :
         context:Code_generation.context
      -> closures:Closure_conversion.closure Code.Var.Map.t
      -> cps:bool
      -> Code.Var.t
      -> unit Code_generation.t

    val curry_allocate :
         cps:bool
      -> arity:int
      -> int
      -> f:Code.Var.t
      -> closure:Code.Var.t
      -> arg:Code.Var.t
      -> Wasm_ast.expression Code_generation.t

    val curry_load :
         cps:bool
      -> arity:int
      -> int
      -> Code.Var.t
      -> (expression * expression * Wasm_ast.value_type option) Code_generation.t

    val dummy : cps:bool -> arity:int -> Wasm_ast.expression Code_generation.t
  end

  module Math : sig
    val cos : expression -> expression

    val sin : expression -> expression

    val tan : expression -> expression

    val acos : expression -> expression

    val asin : expression -> expression

    val atan : expression -> expression

    val atan2 : expression -> expression -> expression

    val cosh : expression -> expression

    val sinh : expression -> expression

    val tanh : expression -> expression

    val acosh : expression -> expression

    val asinh : expression -> expression

    val atanh : expression -> expression

    val cbrt : expression -> expression

    val exp : expression -> expression

    val exp2 : expression -> expression

    val log : expression -> expression

    val expm1 : expression -> expression

    val log1p : expression -> expression

    val log2 : expression -> expression

    val log10 : expression -> expression

    val hypot : expression -> expression -> expression

    val power : expression -> expression -> expression

    val fmod : expression -> expression -> expression

    val round : expression -> expression
  end

  val internal_primitives :
    (string
    * Primitive.kind
    * ((Code.prim_arg -> expression) -> Code.prim_arg list -> expression))
    list

  val handle_exceptions :
       result_typ:Wasm_ast.value_type list
    -> fall_through:'a
    -> context:([> `Catch | `Skip ] as 'b) list
    -> (   result_typ:Wasm_ast.value_type list
        -> fall_through:[> `Skip ]
        -> context:'b list
        -> unit Code_generation.t)
    -> Wasm_ast.var
    -> (   result_typ:Wasm_ast.value_type list
        -> fall_through:'a
        -> context:'b list
        -> unit Code_generation.t)
    -> unit Code_generation.t

  val post_process_function_body :
       param_names:Wasm_ast.var list
    -> locals:(Wasm_ast.var * Wasm_ast.value_type) list
    -> Wasm_ast.instruction list
    -> (Wasm_ast.var * Wasm_ast.value_type) list * Wasm_ast.instruction list

  val entry_point :
       toplevel_fun:Wasm_ast.var
    -> Wasm_ast.func_type * Wasm_ast.var list * unit Code_generation.t
end
OCaml

Innovation. Community. Security.