Source file nativelambda.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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
open Util
open Names
open Esubst
open Constr
open Declarations
open Environ
open Nativevalues
module RelDecl = Context.Rel.Declaration
(** This file defines the lambda code generation phase of the native compiler *)
type prefix = string
type lambda =
| Lrel of Name.t * int
| Lvar of Id.t
| Lmeta of metavariable * lambda
| Levar of Evar.t * lambda array
| Lprod of lambda * lambda
| Llam of Name.t Context.binder_annot array * lambda
| Lrec of Name.t Context.binder_annot * lambda
| Llet of Name.t Context.binder_annot * lambda * lambda
| Lapp of lambda * lambda array
| Lconst of prefix * pconstant
| Lproj of prefix * inductive * int
| Lprim of prefix * pconstant * CPrimitives.t * lambda array
| Lcase of annot_sw * lambda * lambda * lam_branches
| Lif of lambda * lambda * lambda
| Lfix of (int array * (string * inductive) array * int) * fix_decl
| Lcofix of int * fix_decl
| Lint of int
| Lparray of lambda array * lambda
| Lmakeblock of prefix * inductive * int * lambda array
| Luint of Uint63.t
| Lfloat of Float64.t
| Lval of Nativevalues.t
| Lsort of Sorts.t
| Lind of prefix * pinductive
| Llazy
| Lforce
and lam_branches =
{ constant_branches : lambda array;
nonconstant_branches : (Name.t Context.binder_annot array * lambda) array;
}
and fix_decl = Name.t Context.binder_annot array * lambda array * lambda array
type evars =
{ evars_val : existential -> constr option;
evars_metas : metavariable -> types }
let mkLapp f args =
if Array.is_empty args then f
else
match f with
| Lapp(f', args') -> Lapp (f', Array.append args' args)
| _ -> Lapp(f, args)
let mkLlam ids body =
if Array.is_empty ids then body
else
match body with
| Llam(ids', body) -> Llam(Array.append ids ids', body)
| _ -> Llam(ids, body)
let decompose_Llam lam =
match lam with
| Llam(ids,body) -> ids, body
| _ -> [||], lam
let rec decompose_Llam_Llet lam =
match lam with
| Llam(ids,body) ->
let vars, body = decompose_Llam_Llet body in
Array.fold_right (fun x l -> (x, None) :: l) ids vars, body
| Llet(id,def,body) ->
let vars, body = decompose_Llam_Llet body in
(id,Some def) :: vars, body
| _ -> [], lam
let decompose_Llam_Llet lam =
let vars, body = decompose_Llam_Llet lam in
Array.of_list vars, body
let subst_id = subs_id 0
let lift = subs_lift
let liftn = subs_liftn
let cons v subst = subs_cons v subst
let shift subst = subs_shft (1, subst)
let get_mind_prefix env mind =
let _,name = lookup_mind_key mind env in
match !name with
| NotLinked -> ""
| Linked s -> s
let get_const_prefix env c =
let _,(nameref,_) = lookup_constant_key c env in
match !nameref with
| NotLinked -> ""
| Linked s -> s
let map_lam_with_binders g f n lam =
match lam with
| Lrel _ | Lvar _ | Lconst _ | Lproj _ | Lval _ | Lsort _ | Lind _ | Luint _
| Llazy | Lforce | Lmeta _ | Lint _ | Lfloat _ -> lam
| Lprod(dom,codom) ->
let dom' = f n dom in
let codom' = f n codom in
if dom == dom' && codom == codom' then lam else Lprod(dom',codom')
| Llam(ids,body) ->
let body' = f (g (Array.length ids) n) body in
if body == body' then lam else mkLlam ids body'
| Lrec(id,body) ->
let body' = f (g 1 n) body in
if body == body' then lam else Lrec(id,body')
| Llet(id,def,body) ->
let def' = f n def in
let body' = f (g 1 n) body in
if body == body' && def == def' then lam else Llet(id,def',body')
| Lapp(fct,args) ->
let fct' = f n fct in
let args' = Array.Smart.map (f n) args in
if fct == fct' && args == args' then lam else mkLapp fct' args'
| Lprim(prefix,kn,op,args) ->
let args' = Array.Smart.map (f n) args in
if args == args' then lam else Lprim(prefix,kn,op,args')
| Lcase(annot,t,a,branches) ->
let const = branches.constant_branches in
let nonconst = branches.nonconstant_branches in
let t' = f n t in
let a' = f n a in
let const' = Array.Smart.map (f n) const in
let on_b b =
let (ids,body) = b in
let body' = f (g (Array.length ids) n) body in
if body == body' then b else (ids,body') in
let nonconst' = Array.Smart.map on_b nonconst in
let branches' =
if const == const' && nonconst == nonconst' then
branches
else
{ constant_branches = const';
nonconstant_branches = nonconst' }
in
if t == t' && a == a' && branches == branches' then lam else
Lcase(annot,t',a',branches')
| Lif(t,bt,bf) ->
let t' = f n t in
let bt' = f n bt in
let bf' = f n bf in
if t == t' && bt == bt' && bf == bf' then lam else Lif(t',bt',bf')
| Lfix(init,(ids,ltypes,lbodies)) ->
let ltypes' = Array.Smart.map (f n) ltypes in
let lbodies' = Array.Smart.map (f (g (Array.length ids) n)) lbodies in
if ltypes == ltypes' && lbodies == lbodies' then lam
else Lfix(init,(ids,ltypes',lbodies'))
| Lcofix(init,(ids,ltypes,lbodies)) ->
let ltypes' = Array.Smart.map (f n) ltypes in
let lbodies' = Array.Smart.map (f (g (Array.length ids) n)) lbodies in
if ltypes == ltypes' && lbodies == lbodies' then lam
else Lcofix(init,(ids,ltypes',lbodies'))
| Lmakeblock(prefix,cn,tag,args) ->
let args' = Array.Smart.map (f n) args in
if args == args' then lam else Lmakeblock(prefix,cn,tag,args')
| Levar (evk, args) ->
let args' = Array.Smart.map (f n) args in
if args == args' then lam else Levar (evk, args')
| Lparray (p,def) ->
let p' = Array.Smart.map (f n) p in
let def' = f n def in
if def' == def && p == p' then lam else Lparray (p', def')
let rec lam_exlift el lam =
match lam with
| Lrel(id,i) ->
let i' = reloc_rel i el in
if i == i' then lam else Lrel(id,i')
| _ -> map_lam_with_binders el_liftn lam_exlift el lam
let lam_lift k lam =
if Int.equal k 0 then lam
else lam_exlift (el_shft k el_id) lam
let lam_subst_rel lam id n subst =
match expand_rel n subst with
| Inl(k,v) -> lam_lift k v
| Inr(n',_) ->
if n == n' then lam
else Lrel(id, n')
let rec lam_exsubst subst lam =
match lam with
| Lrel(id,i) -> lam_subst_rel lam id i subst
| _ -> map_lam_with_binders liftn lam_exsubst subst lam
let lam_subst_args subst args =
if is_subs_id subst then args
else Array.Smart.map (lam_exsubst subst) args
(** Simplification of lambda expression *)
let can_subst lam =
match lam with
| Lrel _ | Lvar _ | Lconst _ | Lproj _ | Lval _ | Lsort _ | Lind _ | Llam _
| Lmeta _ | Levar _ -> true
| _ -> false
let can_merge_if bt bf =
match bt, bf with
| Llam(_idst,_), Llam(_idsf,_) -> true
| _ -> false
let merge_if t bt bf =
let (idst,bodyt) = decompose_Llam bt in
let (idsf,bodyf) = decompose_Llam bf in
let nt = Array.length idst in
let nf = Array.length idsf in
let common,idst,idsf =
if Int.equal nt nf then idst, [||], [||]
else
if nt < nf then idst,[||], Array.sub idsf nt (nf - nt)
else idsf, Array.sub idst nf (nt - nf), [||] in
Llam(common,
Lif(lam_lift (Array.length common) t,
mkLlam idst bodyt,
mkLlam idsf bodyf))
let rec simplify subst lam =
match lam with
| Lrel(id,i) -> lam_subst_rel lam id i subst
| Llet(id,def,body) ->
let def' = simplify subst def in
if can_subst def' then simplify (cons def' subst) body
else
let body' = simplify (lift subst) body in
if def == def' && body == body' then lam
else Llet(id,def',body')
| Lapp(f,args) ->
begin match simplify_app subst f subst args with
| Lapp(f',args') when f == f' && args == args' -> lam
| lam' -> lam'
end
| Lif(t,bt,bf) ->
let t' = simplify subst t in
let bt' = simplify subst bt in
let bf' = simplify subst bf in
if can_merge_if bt' bf' then merge_if t' bt' bf'
else
if t == t' && bt == bt' && bf == bf' then lam
else Lif(t',bt',bf')
| _ -> map_lam_with_binders liftn simplify subst lam
and simplify_app substf f substa args =
match f with
| Lrel(id, i) ->
begin match lam_subst_rel f id i substf with
| Llam(ids, body) ->
reduce_lapp
subst_id (Array.to_list ids) body
substa (Array.to_list args)
| f' -> mkLapp f' (simplify_args substa args)
end
| Llam(ids, body) ->
reduce_lapp substf (Array.to_list ids) body substa (Array.to_list args)
| Llet(id, def, body) ->
let def' = simplify substf def in
if can_subst def' then
simplify_app (cons def' substf) body substa args
else
Llet(id, def', simplify_app (lift substf) body (shift substa) args)
| Lapp(f, args') ->
let args = Array.append
(lam_subst_args substf args') (lam_subst_args substa args) in
simplify_app substf f subst_id args
| _ -> mkLapp (simplify substf f) (simplify_args substa args)
and simplify_args subst args = Array.Smart.map (simplify subst) args
and reduce_lapp substf lids body substa largs =
match lids, largs with
| id::lids, a::largs ->
let a = simplify substa a in
if can_subst a then
reduce_lapp (cons a substf) lids body substa largs
else
let body = reduce_lapp (lift substf) lids body (shift substa) largs in
Llet(id, a, body)
| [], [] -> simplify substf body
| _::_, _ ->
Llam(Array.of_list lids, simplify (liftn (List.length lids) substf) body)
| [], _::_ -> simplify_app substf body substa (Array.of_list largs)
let is_value lc =
match lc with
| Lval _ | Lint _ | Luint _ | Lfloat _ -> true
| _ -> false
let get_value lc =
match lc with
| Lval v -> v
| Lint tag -> Nativevalues.mk_int tag
| Luint i -> Nativevalues.mk_uint i
| Lfloat f -> Nativevalues.mk_float f
| _ -> raise Not_found
let make_args start _end =
Array.init (start - _end + 1) (fun i -> Lrel (Anonymous, start - i))
let expand_constructor prefix ind tag nparams arity =
let anon = Context.make_annot Anonymous Sorts.Relevant in
let ids = Array.make (nparams + arity) anon in
if Int.equal arity 0 then mkLlam ids (Lint tag)
else
let args = make_args arity 1 in
Llam(ids, Lmakeblock (prefix, ind, tag, args))
let makeblock env ind tag nparams arity args =
let nargs = Array.length args in
if nparams > 0 || nargs < arity then
let prefix = get_mind_prefix env (fst ind) in
mkLapp (expand_constructor prefix ind tag nparams arity) args
else
if Int.equal arity 0 then Lint tag
else
if Array.for_all is_value args then
let dummy_val = Obj.magic 0 in
let args =
let a = Array.make (Array.length args) dummy_val in
Array.iteri (fun i v -> a.(i) <- get_value v) args; a in
Lval (Nativevalues.mk_block tag args)
else
let prefix = get_mind_prefix env (fst ind) in
Lmakeblock(prefix, ind, tag, args)
let makearray args def =
Lparray (args, def)
let rec get_alias env (kn, u as p) =
let tps = (lookup_constant kn env).const_body_code in
match tps with
| None -> p
| Some tps ->
match tps with
| Vmemitcodes.BCalias kn' -> get_alias env (kn', u)
| _ -> p
let prim env kn p args =
let prefix = get_const_prefix env (fst kn) in
Lprim(prefix, kn, p, args)
let expand_prim env kn op arity =
let ids = Array.make arity Context.anonR in
let args = make_args arity 1 in
Llam(ids, prim env kn op args)
let lambda_of_prim env kn op args =
let arity = CPrimitives.arity op in
match Int.compare (Array.length args) arity with
| 0 -> prim env kn op args
| x when x > 0 ->
let prim_args = Array.sub args 0 arity in
let = Array.sub args arity (Array.length args - arity) in
mkLapp(prim env kn op prim_args) extra_args
| _ -> mkLapp (expand_prim env kn op arity) args
let get_names decl =
let decl = Array.of_list decl in
Array.map fst decl
let empty_args = [||]
module Cache =
struct
module ConstrHash =
struct
type t = constructor
let equal = Construct.CanOrd.equal
let hash = Construct.CanOrd.hash
end
module ConstrTable = Hashtbl.Make(ConstrHash)
type constructor_info = tag * int * int
let get_construct_info cache env c : constructor_info =
try ConstrTable.find cache c
with Not_found ->
let ((mind,j), i) = c in
let oib = lookup_mind mind env in
let oip = oib.mind_packets.(j) in
let tag,arity = oip.mind_reloc_tbl.(i-1) in
let nparams = oib.mind_nparams in
let r = (tag, nparams, arity) in
ConstrTable.add cache c r;
r
end
let is_lazy t =
match Constr.kind t with
| App _ | LetIn _ | Case _ | Proj _ -> true
| _ -> false
let evar_value sigma ev = sigma.evars_val ev
let meta_type sigma mv = sigma.evars_metas mv
let empty_evars =
{ evars_val = (fun _ -> None);
evars_metas = (fun _ -> assert false) }
(** Extract the inductive type over which a fixpoint is decreasing *)
let rec get_fix_struct env i t = match kind (Reduction.whd_all env t) with
| Prod (na, dom, t) ->
if Int.equal i 0 then
let dom = Reduction.whd_all env dom in
let (dom, _) = decompose_appvect dom in
match kind dom with
| Ind (ind, _) -> ind
| _ -> assert false
else
let env = Environ.push_rel (RelDecl.LocalAssum (na, dom)) env in
get_fix_struct env (i - 1) t
| _ -> assert false
let rec lambda_of_constr cache env sigma c =
match kind c with
| Meta mv ->
let ty = meta_type sigma mv in
Lmeta (mv, lambda_of_constr cache env sigma ty)
| Evar (evk,args as ev) ->
(match evar_value sigma ev with
| None ->
let args = Array.map_of_list (fun c -> lambda_of_constr cache env sigma c) args in
Levar(evk, args)
| Some t -> lambda_of_constr cache env sigma t)
| Cast (c, _, _) -> lambda_of_constr cache env sigma c
| Rel i -> Lrel (RelDecl.get_name (Environ.lookup_rel i env), i)
| Var id -> Lvar id
| Sort s -> Lsort s
| Ind (ind,_u as pind) ->
let prefix = get_mind_prefix env (fst ind) in
Lind (prefix, pind)
| Prod(id, dom, codom) ->
let ld = lambda_of_constr cache env sigma dom in
let env = Environ.push_rel (RelDecl.LocalAssum (id, dom)) env in
let lc = lambda_of_constr cache env sigma codom in
Lprod(ld, Llam([|id|], lc))
| Lambda _ ->
let params, body = Term.decompose_lam c in
let fold (na, t) env = Environ.push_rel (RelDecl.LocalAssum (na, t)) env in
let env = List.fold_right fold params env in
let lb = lambda_of_constr cache env sigma body in
let ids = get_names (List.rev params) in
mkLlam ids lb
| LetIn(id, def, t, body) ->
let ld = lambda_of_constr cache env sigma def in
let env = Environ.push_rel (RelDecl.LocalDef (id, def, t)) env in
let lb = lambda_of_constr cache env sigma body in
Llet(id, ld, lb)
| App(f, args) -> lambda_of_app cache env sigma f args
| Const _ -> lambda_of_app cache env sigma c empty_args
| Construct _ -> lambda_of_app cache env sigma c empty_args
| Proj (p, c) ->
let ind = Projection.inductive p in
let prefix = get_mind_prefix env (fst ind) in
mkLapp (Lproj (prefix, ind, Projection.arg p)) [|lambda_of_constr cache env sigma c|]
| Case (ci, u, pms, t, iv, a, br) ->
let (ci, t, _iv, a, branches) = Inductive.expand_case env (ci, u, pms, t, iv, a, br) in
let (mind,i as ind) = ci.ci_ind in
let mib = lookup_mind mind env in
let oib = mib.mind_packets.(i) in
let tbl = oib.mind_reloc_tbl in
let prefix = get_mind_prefix env mind in
let annot_sw =
{ asw_ind = ind;
asw_ci = ci;
asw_reloc = tbl;
asw_finite = mib.mind_finite <> CoFinite;
asw_prefix = prefix}
in
let la = lambda_of_constr cache env sigma a in
let lt = lambda_of_constr cache env sigma t in
let dummy = Lrel(Anonymous,0) in
let consts = Array.make oib.mind_nb_constant dummy in
let blocks = Array.make oib.mind_nb_args ([||],dummy) in
let rtbl = oib.mind_reloc_tbl in
for i = 0 to Array.length rtbl - 1 do
let tag, arity = rtbl.(i) in
let b = lambda_of_constr cache env sigma branches.(i) in
if arity = 0 then consts.(tag) <- b
else
let b =
match b with
| Llam(ids, body) when Array.length ids = arity -> (ids, body)
| _ ->
let anon = Context.make_annot Anonymous Sorts.Relevant in
let ids = Array.make arity anon in
let args = make_args arity 1 in
let ll = lam_lift arity b in
(ids, mkLapp ll args)
in blocks.(tag-1) <- b
done;
let branches =
{ constant_branches = consts;
nonconstant_branches = blocks }
in
Lcase(annot_sw, lt, la, branches)
| Fix((pos, i), (names,type_bodies,rec_bodies)) ->
let ltypes = lambda_of_args cache env sigma 0 type_bodies in
let map i t =
let ind = get_fix_struct env i t in
let prefix = get_mind_prefix env (fst ind) in
(prefix, ind)
in
let inds = Array.map2 map pos type_bodies in
let env = Environ.push_rec_types (names, type_bodies, rec_bodies) env in
let lbodies = lambda_of_args cache env sigma 0 rec_bodies in
Lfix((pos, inds, i), (names, ltypes, lbodies))
| CoFix(init,(names,type_bodies,rec_bodies)) ->
let ltypes = lambda_of_args cache env sigma 0 type_bodies in
let env = Environ.push_rec_types (names, type_bodies, rec_bodies) env in
let map c ty = Reduction.eta_expand env c (Vars.lift (Array.length type_bodies) ty) in
let rec_bodies = Array.map2 map rec_bodies type_bodies in
let lbodies = lambda_of_args cache env sigma 0 rec_bodies in
Lcofix(init, (names, ltypes, lbodies))
| Int i -> Luint i
| Float f -> Lfloat f
| Array (_u, t, def, _ty) ->
let def = lambda_of_constr cache env sigma def in
makearray (lambda_of_args cache env sigma 0 t) def
and lambda_of_app cache env sigma f args =
match kind f with
| Const (_kn,_u as c) ->
let kn,u = get_alias env c in
let cb = lookup_constant kn env in
begin match cb.const_body with
| Primitive op -> lambda_of_prim env c op (lambda_of_args cache env sigma 0 args)
| Def csubst ->
if cb.const_inline_code then
lambda_of_app cache env sigma csubst args
else
let prefix = get_const_prefix env kn in
let t =
if is_lazy csubst then
mkLapp Lforce [|Lconst (prefix, (kn,u))|]
else Lconst (prefix, (kn,u))
in
mkLapp t (lambda_of_args cache env sigma 0 args)
| OpaqueDef _ | Undef _ ->
let prefix = get_const_prefix env kn in
mkLapp (Lconst (prefix, (kn,u))) (lambda_of_args cache env sigma 0 args)
end
| Construct ((ind,_ as c),_) ->
let tag, nparams, arity = Cache.get_construct_info cache env c in
let nargs = Array.length args in
if nparams < nargs then
let args = lambda_of_args cache env sigma nparams args in
makeblock env ind tag 0 arity args
else makeblock env ind tag (nparams - nargs) arity empty_args
| _ ->
let f = lambda_of_constr cache env sigma f in
let args = lambda_of_args cache env sigma 0 args in
mkLapp f args
and lambda_of_args cache env sigma start args =
let nargs = Array.length args in
if start < nargs then
Array.init (nargs - start)
(fun i -> lambda_of_constr cache env sigma args.(start + i))
else empty_args
let optimize lam =
let lam = simplify subst_id lam in
lam
let lambda_of_constr env sigma c =
let cache = Cache.ConstrTable.create 91 in
let lam = lambda_of_constr cache env sigma c in
optimize lam
let mk_lazy c =
mkLapp Llazy [|c|]