Rename Un_cps -> To_cmm (#261)

Author: mshinwell

driver/flambda_backend_main.ml

@@ -6,4 +6,4 @@ let () =
    | Native -> Memtrace.trace_if_requested ~context:"ocamlopt" ()
    | Bytecode | Other _ -> ());
   exit (Optmaindriver.main Sys.argv Format.err_formatter
-    ~flambda2_backend ~flambda2_to_cmm:Flambda2_to_cmm.Un_cps.unit)
+    ~flambda2_backend ~flambda2_to_cmm:Flambda2_to_cmm.To_cmm.unit)

middle_end/flambda2/cmx/exported_offsets.ml

@@ -16,7 +16,7 @@
 
 (** Offsets for closures and environment variables inside sets of closures.
     They're computed for elements defined in the current compilation unit by
-    [Un_cps_closure], and read from cmx files for external symbols. Because an
+    [To_cmm_closure], and read from cmx files for external symbols. Because an
     external cmx can reference elements from another cmx that the current
     compilation cannot see, all offsets read from external cmx files must be
     re-exported. *)

middle_end/flambda2/cmx/flambda_cmx.ml

@@ -124,7 +124,7 @@ let prepare_cmx_file_contents ~return_cont_env:cont_uses_env
     in
     let exported_offsets =
       (* The offsets computations for newly defined elements will be added after
-         Un_cps_closure *)
+         To_cmm_closure *)
       Exported_offsets.imported_offsets ()
     in
     Some

middle_end/flambda2/docs/to_cmm.md

@@ -7,17 +7,12 @@ existing translation from clambda to cmm. However, that gave very little control
 to flambda in terms of unboxing, since most optimizations relating to unboxing
 happens during the clambda to cmm translation.
 
-The translation from flambda2 to cmm is currently named `un_cps` for historical
-reasons (because it `un`does the `cps` form of flambda2), but it is expected to
-change toward a less obscure name at one point.
-
-
 ## Overview
 
 See [this file](term_language.md) for a description of the flamdba2 language,
 and [the cmm doc](cmm.md) for an overview of the cmm language.
 
-This section provides an overview of the main tasks of the `un_cps`
+This section provides an overview of the main tasks of the `to_cmm`
 translation. First these "tasks" are listed, and then are explained in details,
 together with their motivations and requirements. The technical aspect of how
 these tasks are implemented will be discussed in the following section).
@@ -70,7 +65,7 @@ and lower these operations are explicit, e.g.:
 
 One good point compared to cmmgen is that we can assume that the flambda
 simplifier will already have unboxed things that can be unboxed, so contrary to
-`cmmgen`, `un_cps` does not need to do the work of trying to find unboxing
+`cmmgen`, `to_cmm` does not need to do the work of trying to find unboxing
 optimizations.
 
 #### "Big" and "small" values
@@ -93,7 +88,7 @@ ocaml values across functions.
 
 "small" values are values which are strictly smaller than register, and whose
 semantics usually need this smaller value space; typically, these are 32-bit
-integers on 64-bit platforms.  For these values, `un_cps` need to choose one
+integers on 64-bit platforms.  For these values, `to_cmm` need to choose one
 encoding into 64-bits registers, and translate the abstract operations from
 flambda2 on these types to concrete operations on registers in a way that
 preserve the expected semantics.
@@ -132,7 +127,7 @@ compared to generating A-normal forms; some of these reasons are:
   Conversely, when this is not the case, the compiler pipeline will
   automatically add a (= 0) comparison, resulting in a few more instructions.
 
-Thus `un_cps` does the following:
+Thus `to_cmm` does the following:
 - remove pure and co-effectful-only expressions which are never used
 - substitute pure and co-effectful-only expressions which are used exactly once
 - if the option is set, substitute effectful expressions which are used exactly once
@@ -178,7 +173,7 @@ not inline sets of closures across modules anymore, and thus all sharing are
 restricted to the current module, there should not be any instance where
 the offset computation can fail.
 
-Currently, `un_cps` implements a greedy algorithm for filling out sets of
+Currently, `to_cmm` implements a greedy algorithm for filling out sets of
 closures and assign offsets. It iterates over closures, assigning the lowest
 offset that is free in all sets of closures where it appears, and then does the
 same for all env vars. While not optimal as it may leave gaps, this should
@@ -198,24 +193,24 @@ flambda2.
 
 ### Organization of the code and main control flow of the translation
 
-`un_cps` translate flambda2 expressions using two traversals of an flambda2
+`to_cmm` translate flambda2 expressions using two traversals of an flambda2
 body.
 
 The first traversal iterates over all sets of closures defined by the body.
 This allows to assign offsets to all members of sets of closures (taking into
 account constraints due to a potential sharing of closures of env vars beetween
-sets of closures), using the code in `un_cps_closure.ml`.
+sets of closures), using the code in `to_cmm_closure.ml`.
 
-After that, `un_cps` operates the second, and main traversal of the
+After that, `to_cmm` operates the second, and main traversal of the
 expression, accumulating information (about continuations, substitutions, etc)
-in an environment (defined in `un_cps_env.ml`), and then returning two
+in an environment (defined in `to_cmm_env.ml`), and then returning two
 values: the resulting cmm expression, and a static result that contains all
 the constants that should be pre-allocated (in comparison, `cmmgen` uses a global
 reference to store that information during translation). This static result
-(defined in `un_cps_result.ml`) will be grown by the translation, by either
+(defined in `to_cmm_result.ml`) will be grown by the translation, by either
 `let_symbol` bindings or sets of closures bindings. Translations of flambda2
 expression that can result in pre-allocation of static constants go through
-the `un_cps_static.ml` file.
+the `to_cmm_static.ml` file.
 
 ### Tagging and unboxing
 
@@ -225,7 +220,7 @@ of values, e.g. boxed integers are identified with their size, tagged integers
 are differentiated from untagged integers, ... . Together with information
 about what the cmm primitives expect (i.e. which primitive expect or return
 a tagged integer, and which deal with untagged integers), this offers a
-rather comprehensive way for `un_cps` to know when or where to tag/untag
+rather comprehensive way for `to_cmm` to know when or where to tag/untag
 things. See the following for more details:
 - `middle_end/flambda/terms/flambda_primitive.ml` for the data about kinds
   consumed/returned by flambda primitives (particularly the
@@ -234,11 +229,11 @@ things. See the following for more details:
   (this is still a TODO)
 
 Unboxing is also straightforward: as mentioned earlier, flambda2 already
-takes care of identifying and applying all the unboxing we want, so `un_cps`
+takes care of identifying and applying all the unboxing we want, so `to_cmm`
 only introduces the boxing and unboxing as needed, using the same information
 as for tagging/untagging.
 
-For the concrete implementation, `un_cps` mostly re-uses code from
+For the concrete implementation, `to_cmm` mostly re-uses code from
 `cmm_helpers`.
 
 ### "Big" and "small" values
@@ -254,13 +249,13 @@ bits and its higher bits, and then carried on two registers.  Handling these
 is relatively straightforward since the low-level operations are already
 written in `cmm_helpers`.
 
-A difference between `cmmgen` and `un_cps` is that flambda2 has explicit
+A difference between `cmmgen` and `to_cmm` is that flambda2 has explicit
 box/unbox operations on these, and as such, where `cmmgen` is in control of the
 boxing and thus most of the time generate calls to function that handle the
-boxed version of Int64s, `un_cps` actually has to mostly deal with unboxed
+boxed version of Int64s, `to_cmm` actually has to mostly deal with unboxed
 Int64, and generate calls that handle the unboxed variant.
 
-Currently, there may be some cases in `un_cps` that will raise a fatal error
+Currently, there may be some cases in `to_cmm` that will raise a fatal error
 because there was not yet an unboxed version of the required function in the
 runtime.
 
@@ -298,8 +293,8 @@ a trap mechanism to mirror that of flambda2.
 
 ### Let-binding substitution
 
-This is the most complex part of `un_cps` and also the part most sensitive
-to changes (even innocuous changes in `un_cps` might break becasue of this).
+This is the most complex part of `to_cmm` and also the part most sensitive
+to changes (even innocuous changes in `to_cmm` might break becasue of this).
 The goal is to substitute let-bound variable's bodies during translation, because
 it allows for more optimizations. There are two technical challenges
 with this:
@@ -309,7 +304,7 @@ with this:
   continuations, in which case the expression might be evaluated more than once).
 
 Most of the code to deal with this is in the definition of the translation
-environment in `un_cps_env`: the environment accumulates all let-bindings
+environment in `to_cmm_env`: the environment accumulates all let-bindings
 (whether that can be substituted or not), since we have to be able to
 substitute through a non-substitutable binding. A nice consequence of that is
 that translating a let-binding can then be tail-rec, which is very useful.
@@ -322,7 +317,7 @@ Let-bindings are stored in the environment in a few structures:
   or a single effectful binding.
 These two structures are used to store enough information to perform substitution
 if needed. Additionally, another map is used to relate all flambda2 variables to
-corresponding cmm variables. This mapping is used when `un_cps` decides not to
+corresponding cmm variables. This mapping is used when `to_cmm` decides not to
 substitute a variable's body.
 
 When a let-bound variable has to be translated, a special env lookup is used,

middle_end/flambda2/from_lambda/closure_conversion.ml

@@ -219,7 +219,7 @@ let close_c_call acc ~let_bound_var
     let prim_name =
       if String.equal prim_native_name "" then prim_name else prim_native_name
     in
-    (* CR mshinwell: fix "extern" mess (see Un_cps) *)
+    (* CR mshinwell: fix "extern" mess (see To_cmm) *)
     Symbol.create
       (Compilation_unit.external_symbols ())
       (Linkage_name.create prim_name)

middle_end/flambda2/simplify/expr_builder.ml

@@ -419,7 +419,7 @@ let create_let_symbols uacc lifted_constant ~body =
              symbol" that we've just created, we'll always end up here, avoiding
              any problem about where to do the projection versus the
              initialisation of a possibly-recursive group of symbols. We may end
-             up with a "variable = variable" [Let] here, but [Un_cps] (or a
+             up with a "variable = variable" [Let] here, but [To_cmm] (or a
              subsequent pass of [Simplify]) will remove it. This is the same
              situation as when continuations are inlined; we can't use a name
              permutation to resolve the problem as both [var] and [var'] may

middle_end/flambda2/simplify/simplify_apply_cont_expr.ml

@@ -30,7 +30,7 @@ let inline_linearly_used_continuation uacc ~create_apply_cont ~params ~handler
        isn't the correct accumulator and environment any more. However there's
        no need to simplify the inlined body except to make use of
        parameter-to-argument bindings; we just leave them for a subsequent round
-       of [Simplify] or [Un_cps] to clean up. *)
+       of [Simplify] or [To_cmm] to clean up. *)
     let args = AC.args apply_cont in
     if List.compare_lengths params args <> 0
     then

middle_end/flambda2/simplify/simplify_expr.ml

@@ -39,7 +39,7 @@ let rec simplify_expr dacc expr ~down_to_up =
     Simplify_switch_expr.simplify_switch ~simplify_let dacc switch ~down_to_up
   | Invalid _ ->
     (* CR mshinwell: Make sure that a program can be simplified to just
-       [Invalid]. [Un_cps] should translate any [Invalid] that it sees as if it
+       [Invalid]. [To_cmm] should translate any [Invalid] that it sees as if it
        were [Halt_and_catch_fire]. *)
     down_to_up dacc ~rebuild:EB.rebuild_invalid
 

middle_end/flambda2/terms/flambda_primitive.ml

@@ -302,7 +302,7 @@ let reading_from_an_array (array_kind : Array_kind.t)
     match array_kind with
     | Immediates | Values | Naked_floats -> No_effects
     | Float_array_opt_dynamic ->
-      (* See [Un_cps_helpers.array_load] and [Cmm_helpers.float_array_ref]. If
+      (* See [To_cmm_helpers.array_load] and [Cmm_helpers.float_array_ref]. If
          the array (dynamically) has tag [Double_array_tag], then the read will
          allocate. [Immutable] here means that the returned float itself is
          immutable. *)

middle_end/flambda2/to_cmm/un_cps.ml renamed to middle_end/flambda2/to_cmm/to_cmm.ml

@@ -15,9 +15,9 @@
 [@@@ocaml.warning "+a-4-30-40-41-42"]
 
 open! Flambda.Import
-module Env = Un_cps_env
+module Env = To_cmm_env
 module Ece = Effects_and_coeffects
-module R = Un_cps_result
+module R = To_cmm_result
 
 (* Notes:
 
@@ -32,7 +32,7 @@ module R = Un_cps_result
 (* Cmm helpers *)
 module C = struct
   include Cmm_helpers
-  include Un_cps_helper
+  include To_cmm_helper
 end
 
 (* Shortcuts for useful cmm machtypes *)
@@ -397,7 +397,7 @@ let binary_float_comp_primitive_yielding_int _env dbg x y =
 
 let nullary_primitive _env dbg prim : _ * Cmm.expression =
   match (prim : Flambda_primitive.nullary_primitive) with
-  | Optimised_out _ -> Misc.fatal_errorf "TODO: phantom let-bindings in un_cps"
+  | Optimised_out _ -> Misc.fatal_errorf "TODO: phantom let-bindings in to_cmm"
   | Probe_is_enabled { name } -> None, Cop (Cprobe_is_enabled { name }, [], dbg)
 
 let unary_primitive env dbg f arg =
@@ -452,7 +452,7 @@ let unary_primitive env dbg f arg =
     | Some _, None | None, Some _ | None, None ->
       (* Note that if a closure var is missing from a set of closures
          environment, then [Env.closure_offset] might return [None], even though
-         the set of closures has been seen by [Un_cps_closure]. *)
+         the set of closures has been seen by [To_cmm_closure]. *)
       None, C.unreachable)
 
 let binary_primitive env dbg f x y =
@@ -715,7 +715,7 @@ and let_symbol env res bound_symbols consts body =
     Env.add_to_scope env (Bound_symbols.everything_being_defined bound_symbols)
   in
   let env, res, update_opt =
-    Un_cps_static.static_consts env res ~params_and_body bound_symbols consts
+    To_cmm_static.static_consts env res ~params_and_body bound_symbols consts
   in
   match update_opt with
   | None ->
@@ -730,7 +730,7 @@ and let_set_of_closures env res body closure_vars
   let fun_decls = Set_of_closures.function_decls s in
   let decls = Function_declarations.funs_in_order fun_decls in
   let elts =
-    Un_cps_closure.filter_closure_vars s
+    To_cmm_closure.filter_closure_vars s
       ~used_closure_vars:(Env.used_closure_vars env)
   in
   if Var_within_closure.Map.is_empty elts
@@ -967,7 +967,7 @@ and apply_call env e =
     if not (check_arity param_arity args)
     then
       Misc.fatal_errorf
-        "Un_cps expects indirect_known_arity calls to be full applications in \
+        "To_cmm expects indirect_known_arity calls to be full applications in \
          order to translate it"
     else
       let f, env, _ = simple env f in
@@ -1328,7 +1328,7 @@ and let_static_set_of_closures env res body closure_vars s =
   in
   (* Statically allocate the set of closures *)
   let env, static_data, updates =
-    Un_cps_static.static_set_of_closures env closure_symbols s None
+    To_cmm_static.static_set_of_closures env closure_symbols s None
   in
   (* As there is no env vars for the set of closures, there must be no
      updates *)
@@ -1341,7 +1341,7 @@ and let_static_set_of_closures env res body closure_vars s =
   (* update the result with the new static data *)
   let res = R.archive_data (R.set_data res static_data) in
   (* Bind the variables to the symbols for closure ids. CR gbury: inline the
-     variables (require to extend un_cps_enc to inline pure variables more than
+     variables (require to extend to_cmm_enc to inline pure variables more than
      once). *)
   let env =
     List.fold_left2
@@ -1410,7 +1410,7 @@ and fill_layout decls startenv elts env effs acc i = function
     fill_layout decls startenv elts env effs acc offset r
 
 and fill_slot decls startenv elts env acc offset slot =
-  match (slot : Un_cps_closure.layout_slot) with
+  match (slot : To_cmm_closure.layout_slot) with
   | Infix_header ->
     let field = C.alloc_infix_header (offset + 1) Debuginfo.none in
     field :: acc, offset + 1, env, Ece.pure
@@ -1444,7 +1444,7 @@ and fill_slot decls startenv elts env acc offset slot =
       acc, offset + 3, env, Ece.pure
 
 and fill_up_to j acc i =
-  if i > j then Misc.fatal_errorf "Problem while filling up a closure in un_cps";
+  if i > j then Misc.fatal_errorf "Problem while filling up a closure in to_cmm";
   if i = j then acc else fill_up_to j (C.int 1 :: acc) (i + 1)
 
 (* Translate a function declaration. *)
@@ -1504,7 +1504,7 @@ let unit (middle_end_result : Flambda_middle_end.middle_end_result) =
   let functions_info = middle_end_result.all_code in
   Profile.record_call "flambda_to_cmm" (fun () ->
       let offsets =
-        Un_cps_closure.compute_offsets offsets functions_info unit
+        To_cmm_closure.compute_offsets offsets functions_info unit
       in
       begin
         match middle_end_result.cmx with

middle_end/flambda2/to_cmm/un_cps.mli renamed to middle_end/flambda2/to_cmm/to_cmm.mli

@@ -207,7 +207,7 @@ let gen_variable v =
 
 let add_variable env v v' =
   let v'' = Backend_var.With_provenance.var v' in
-  let vars = Variable.Map.add v (Un_cps_helper.var v'') env.vars in
+  let vars = Variable.Map.add v (To_cmm_helper.var v'') env.vars in
   { env with vars }
 
 let create_variable env v =
@@ -245,7 +245,7 @@ let get_jump_id env k =
 let get_k env k =
   match Continuation.Map.find k env.conts with
   | exception Not_found ->
-    Misc.fatal_errorf "Could not find continuation %a in env during un_cps"
+    Misc.fatal_errorf "Could not find continuation %a in env during to_cmm"
       Continuation.print k
   | res -> res
 
@@ -300,7 +300,7 @@ let env_var_offset env env_var =
   Exported_offsets.env_var_offset env.offsets env_var
 
 let layout env closures env_vars =
-  Un_cps_closure.layout env.offsets closures env_vars
+  To_cmm_closure.layout env.offsets closures env_vars
 
 (* Printing
 
@@ -321,7 +321,7 @@ let next_order =
 
 let classify effs =
   match (effs : Effects_and_coeffects.t) with
-  (* For the purpose of un_cps, generative effects, i.e. allocations, will be
+  (* For the purpose of to_cmm, generative effects, i.e. allocations, will be
      considered to have effects because the mutable state of the gc that
      allocations actually effect can be observed by coeffects performed by
      function calls (particularly coming from the Gc module). *)
@@ -341,7 +341,7 @@ let mk_binding ?extra env inline effs var cmm_expr =
   let cmm_var = gen_variable var in
   let b = { order; inline; effs; cmm_var; cmm_expr } in
   let v = Backend_var.With_provenance.var cmm_var in
-  let e = Un_cps_helper.var v in
+  let e = To_cmm_helper.var v in
   let env = { env with vars = Variable.Map.add var e env.vars } in
   let env =
     match extra with
@@ -377,7 +377,7 @@ let inline_res env b = b.cmm_expr, env, b.effs
 
 let inline_not env b =
   let v' = Backend_var.With_provenance.var b.cmm_var in
-  Un_cps_helper.var v', env, Effects_and_coeffects.pure
+  To_cmm_helper.var v', env, Effects_and_coeffects.pure
 
 let inline_not_found env v =
   match Variable.Map.find v env.vars with
@@ -453,7 +453,7 @@ let flush_delayed_lets env =
         order_map stages
     in
     M.fold
-      (fun _ b acc -> Un_cps_helper.letin b.cmm_var b.cmm_expr acc)
+      (fun _ b acc -> To_cmm_helper.letin b.cmm_var b.cmm_expr acc)
       order_map e
   in
   let wrap e = wrap_aux env.pures env.stages e in