Fix an issue with riscv_platform involving flow typing

- Refactor the flow typing implementation in the type-checker. This
  should fix an issue involving riscv_platform. Specifically it should
  now work better when an if statement contains multiple conditions
  combined with and/or, only some of which imply constraints at the
  type level. This change also simplifies the implementation of flow
  typing, and removes some obscure features that were hardly used -
  specifically, flow typing could modify types, but this was fairly
  obscure and doesn't seem to affect any of our specifications. More
  testing is needed to ensure that this change hasn't inadvertantly
  broken anything, but it does pass all our tests and continue to
  typecheck arm, riscv and cheri.

- Also adds a option for generating faster undefined functions for
  enum and variant types. Previously I tried to optimise away such
  functions in the C backend, because they could be slow and cause
  considerable uneccessary allocation, however this was error prone
  and it turns out a much simpler solution is to simply make the
  functions themselves much faster, at the cost of hard-coding certain
  decisions about what undefined means for these types at compile tile
  (which is fine for fast emulation). This almost doubles the
  performance of the generated C code.

- Add a wrapper for right shift to avoid UB when shifting by 64 or
  more places.

1 files changed, 12 insertions, 1 deletions

diff --git a/src/initial_check.mli b/src/initial_check.mli
index 757959f7..e6b29216 100644
--- a/src/initial_check.mli
+++ b/src/initial_check.mli
@@ -51,9 +51,20 @@
 open Ast
 open Ast_util
 
-(* Generate undefined_T functions for every type T *)
+(* Generate undefined_T functions for every type T. False by
+   default. *)
 val opt_undefined_gen : bool ref
 
+(* Generate faster undefined_T functions. Rather than generating
+   functions that allow for the undefined values of enums and variants
+   to be picked at runtime using a RNG or similar, this creates
+   undefined_T functions for those types that simply return a specific
+   member of the type chosen at compile time, which is much
+   faster. These functions don't have the right effects, so the
+   -no_effects flag may be needed if this is true. False by
+   default. *)
+val opt_fast_undefined : bool ref
+
 (* Allow # in identifiers when set, like the GHC option of the same name *)
 val opt_magic_hash : bool ref