Revised infrastructure for lazy loading of opaque proofs

 Get rid of the LightenLibrary hack : no more last-minute
 collect of opaque terms and Obj.magic tricks. Instead, we
 make coqc accumulate the opaque terms as soon as constant_bodies
 are created outside sections. In these cases, the opaque
 terms are placed in a special table, and some (DirPath.t * int)
 are used as indexes in constant_body. In an interactive session,
 the local opaque terms stay directly stored in the constant_body.

 The structure of .vo file stays similar : magic number, regular
 library structure, digest of the first part, array of opaque terms.
 In addition, we now have a final checksum for checking the
 integrity of the whole .vo file. The other difference is that
 lazy_constr aren't changed into int indexes in .vo files, but are
 now coded as (substitution list * DirPath.t * int). In particular
 this approach allows to refer to opaque terms from another
 library. This (and accumulating substitutions in lazy_constr)
 seems to greatly help decreasing the size of opaque tables :
 -20% of vo size on the standard library :-). The compilation times
 are slightly better, but that can be statistic noise.

 The -force-load-proofs isn't active anymore : it behaves now
 just like -lazy-load-proofs. The -dont-load-proofs mode has
 slightly changed : opaque terms aren't seen as axioms anymore,
 but accessing their bodies will raise an error.

 Btw, API change : Declareops.body_of_constant now produces directly
 a constr option instead of a constr_substituted option

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@16382 85f007b7-540e-0410-9357-904b9bb8a0f7

1 files changed, 45 insertions, 12 deletions

diff --git a/kernel/lazyconstr.ml b/kernel/lazyconstr.ml
index 31cb76575e..21aba6348a 100644
--- a/kernel/lazyconstr.ml
+++ b/kernel/lazyconstr.ml
@@ -6,6 +6,7 @@
 (*         *       GNU Lesser General Public License Version 2.1        *)
 (************************************************************************)
 
+open Names
 open Term
 open Mod_subst
 
@@ -20,24 +21,56 @@ let force = force subst_mps
 
 let subst_constr_subst = subst_substituted
 
-(** Opaque proof terms are not loaded immediately, but are there
-    in a lazy form. Forcing this lazy may trigger some unmarshal of
-    the necessary structure. The ['a substituted] type isn't really great
-    here, so we store "manually" a substitution list, the younger one at top.
+(** Opaque proof terms might be in some external tables.
+    The [force_opaque] function below allows to access these tables,
+    this might trigger the read of some extra parts of .vo files.
+    In the [Indirect] case, we accumulate "manually" a substitution
+    list, the younger one coming first. Nota: no [Direct] constructor
+    should end in a .vo, this is checked by coqchk.
 *)
 
-type lazy_constr = constr_substituted Lazy.t * substitution list
+type lazy_constr =
+  | Indirect of substitution list * DirPath.t * int (* lib,index *)
+  | Direct of constr_substituted (* opaque in section or interactive session *)
 
-let force_lazy_constr (c,l) =
-  List.fold_right subst_constr_subst l (Lazy.force c)
+(* TODO : this hcons function could probably be improved (for instance
+   hash the dir_path in the Indirect case) *)
 
-let lazy_constr_is_val (c,_) = Lazy.lazy_is_val c
+let hcons_lazy_constr = function
+  | Direct c -> Direct (from_val (hcons_constr (force c)))
+  | Indirect _ as lc -> lc
 
-let make_lazy_constr c = (c, [])
+let subst_lazy_constr sub = function
+  | Direct cs -> Direct (subst_constr_subst sub cs)
+  | Indirect (l,dp,i) -> Indirect (sub::l,dp,i)
 
-let force_opaque lc = force (force_lazy_constr lc)
+let default_get_opaque dp _ =
+  Errors.error
+    ("Cannot access an opaque term in library " ^ DirPath.to_string dp)
+
+let default_mk_opaque _ = None
+
+let get_opaque = ref default_get_opaque
+let mk_opaque = ref default_mk_opaque
+let set_indirect_opaque_accessor f = (get_opaque := f)
+let set_indirect_opaque_creator f = (mk_opaque := f)
+let reset_indirect_opaque_creator () = (mk_opaque := default_mk_opaque)
 
-let opaque_from_val c = (Lazy.lazy_from_val (from_val c), [])
+let force_lazy_constr = function
+  | Direct c -> c
+  | Indirect (l,dp,i) ->
+    List.fold_right subst_constr_subst l (from_val (!get_opaque dp i))
 
-let subst_lazy_constr sub (c,l) = (c,sub::l)
+let turn_indirect lc = match lc with
+  | Indirect _ ->
+    Errors.anomaly (Pp.str "Indirecting an already indirect opaque")
+  | Direct c ->
+    (* this constr_substituted shouldn't have been substituted yet *)
+    assert (fst (Mod_subst.repr_substituted c) == None);
+    match !mk_opaque (force c) with
+      | None -> lc
+      | Some (dp,i) -> Indirect ([],dp,i)
+
+let force_opaque lc = force (force_lazy_constr lc)
 
+let opaque_from_val c = Direct (from_val c)