flambda-backend: Fix flambda_o3 and flambda_oclassic attributes (#536)

* Fix flambda_o3 and flambda_oclassic attributes

The implementations of the `flambda_o3` and `flambda_oclassic`
attributes were calling into `Clflags`, but the flambda backend
implements optimization flags by circumventing `Clflags` entirely.
The only obvious solution is to add a hook to `Clflags` so we can
simply override what `Clflags.set_o3 ()` does. Fortunately, doing it
this way means that the other two ways of setting the flags - the
command line and `OCAMLPARAM` - no longer need to do anything
special.

Tested manually using the included .ml source file.

Note that `[@@@flambda_o3]` does nothing if `-Oclassic` is on. This
actually reflects existing behavior: `-Oclassic -O3` and `-O3
-Oclassic` are, as far as I can tell, effectively the same as
`-Oclassic`.

* Make later -O flags completely override earlier ones

Also document the test more thoroughly.

* Don't have -O* clobber earlier options

Now `-flambda2-cse-depth 7 -O3` will do the same thing as
`-O3 -flambda2-cse-depth 7`.

* Minimize the diff a bit

* Install optimization-flag handler in native toplevel

* Restore the behavior that -Oclassic implies -linscan

* Add missing settings to O levels

The explicit setting of `fallback_inlining_heuristic` to `false` in
the old `o2_flags` was redundant, but it's easier to review this way.

* Formatting

Author: lukemaurer

driver/compenv.ml

@@ -193,6 +193,14 @@ let check_bool ppf name s =
       "bad value %s for %s" s name;
     false
 
+let check_int ppf name s =
+  match int_of_string s with
+  | i -> Some i
+  | exception _ ->
+      Printf.ksprintf (print_error ppf)
+        "bad value %s for %s" s name;
+      None
+
 let decode_compiler_pass ppf v ~name ~filter =
   let module P = Clflags.Compiler_pass in
   let passes = P.available_pass_names ~filter ~native:!native_code in

driver/compenv.mli

@@ -54,6 +54,7 @@ val setter :
     Format.formatter -> (bool -> 'a) -> string -> 'a ref list -> string -> unit
 val int_setter : Format.formatter -> string -> int ref -> string -> unit
 val check_bool : Format.formatter -> string -> string -> bool
+val check_int : Format.formatter -> string -> string -> int option
 
 (* [is_unit_name name] returns true only if [name] can be used as a
    correct module name *)

driver/main_args.ml

@@ -219,7 +219,7 @@ let mk_inline_max_unroll f =
 let mk_classic_inlining f =
   "-Oclassic", Arg.Unit f, " Make inlining decisions at function definition \
      time rather than at the call site (replicates previous behaviour of the \
-     compiler)"
+     compiler).  Implies -linscan (and causes -nolinscan to be ignored)."
 ;;
 
 let mk_inline_cost arg descr default f =

utils/clflags.ml

@@ -502,23 +502,42 @@ end
 let is_flambda2 () =
   Config.flambda2 && !native_code
 
-let set_oclassic () =
-  classic_inlining := true;
-  default_simplify_rounds := 1;
-  use_inlining_arguments_set classic_arguments;
-  unbox_free_vars_of_closures := false;
-  unbox_specialised_args := false
-
-let set_o2 () =
-  default_simplify_rounds := 2;
-  use_inlining_arguments_set o2_arguments;
-  use_inlining_arguments_set ~round:0 o1_arguments
-
-let set_o3 () =
-  default_simplify_rounds := 3;
-  use_inlining_arguments_set o3_arguments;
-  use_inlining_arguments_set ~round:1 o2_arguments;
-  use_inlining_arguments_set ~round:0 o1_arguments
+module Opt_flag_handler = struct
+  type t = {
+    set_oclassic : unit -> unit;
+    set_o2 : unit -> unit;
+    set_o3 : unit -> unit;
+  }
+
+  let default =
+    let set_oclassic () =
+      classic_inlining := true;
+      default_simplify_rounds := 1;
+      use_inlining_arguments_set classic_arguments;
+      unbox_free_vars_of_closures := false;
+      unbox_specialised_args := false
+    in
+    let set_o2 () =
+      default_simplify_rounds := 2;
+      use_inlining_arguments_set o2_arguments;
+      use_inlining_arguments_set ~round:0 o1_arguments
+    in
+    let set_o3 () =
+      default_simplify_rounds := 3;
+      use_inlining_arguments_set o3_arguments;
+      use_inlining_arguments_set ~round:1 o2_arguments;
+      use_inlining_arguments_set ~round:0 o1_arguments
+    in
+    { set_oclassic; set_o2; set_o3 }
+
+  let current = ref default
+
+  let set t = current := t
+end
+
+let set_oclassic () = (!Opt_flag_handler.current).set_oclassic ()
+let set_o2 () = (!Opt_flag_handler.current).set_o2 ()
+let set_o3 () = (!Opt_flag_handler.current).set_o3 ()
 
 (* This is used by the -stop-after option. *)
 module Compiler_pass = struct

utils/clflags.mli

@@ -229,6 +229,18 @@ val unboxed_types : bool ref
 val insn_sched : bool ref
 val insn_sched_default : bool
 
+module Opt_flag_handler : sig
+  type t = {
+    set_oclassic : unit -> unit;
+    set_o2 : unit -> unit;
+    set_o3 : unit -> unit;
+  }
+
+  val default : t
+
+  val set : t -> unit
+end
+
 val set_oclassic : unit -> unit
 val set_o2 : unit -> unit
 val set_o3 : unit -> unit