Merge remote-tracking branch 'origin/main' into nroberts/layouts-are-…

…strings-in-parsetree

.github/workflows/build.yml

@@ -1,5 +1,5 @@
 name: build
-on: [push, pull_request]
+on: [push]
 jobs:
   build:
     name: ${{ matrix.name }}
@@ -112,15 +112,17 @@ jobs:
       run: sudo apt-get install afl++
 
     - name: Install AFL (for macOS workers)
+      # The "afl-fuzz" package is deprecated (2023-10) and can no longer be installed
       if: matrix.os == 'macos-latest'
-      run: HOMEBREW_NO_INSTALL_CLEANUP=TRUE brew install afl-fuzz
+      run: true
+      # run: HOMEBREW_NO_INSTALL_CLEANUP=TRUE brew install afl-fuzz
 
-    - name: Cache OCaml 4.14 and dune
+    - name: Cache OCaml 4.14, dune and menhir
       uses: actions/cache@v2
       id: cache
       with:
         path: ${{ github.workspace }}/ocaml-414/_install
-        key: ${{ matrix.os }}-cache-ocaml-414-dune-361
+        key: ${{ matrix.os }}-cache-ocaml-414-dune-361-menhir-20210419
 
     - name: Checkout OCaml 4.14
       uses: actions/checkout@master
@@ -155,6 +157,29 @@ jobs:
         PATH=$GITHUB_WORKSPACE/ocaml-414/_install/bin:$PATH make release
         cp _boot/dune.exe $GITHUB_WORKSPACE/ocaml-414/_install/bin/dune
 
+    # CR mshinwell: This should use git@gitlab.inria.fr:fpottier/menhir.git
+    - name: Checkout menhir github repo
+      uses: actions/checkout@master
+      if: steps.cache.outputs.cache-hit != 'true'
+      with:
+        repository: 'LexiFi/menhir'
+        ref: '20210419'
+        path: 'menhir'
+
+    - name: Build menhir
+      working-directory: menhir
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        PATH=$GITHUB_WORKSPACE/ocaml-414/_install/bin:$PATH dune build
+        cp _build/install/default/bin/menhir $GITHUB_WORKSPACE/ocaml-414/_install/bin/menhir
+        # Our dune rule uses `menhirLib.mli`, which we can't simply `cp`
+        # because it's a symbolic link to a relative path.
+        export SOURCE_DIR=_build/install/default/lib/menhirLib
+        export TARGET_DIR=$GITHUB_WORKSPACE/ocaml-414/_install/lib/menhirLib
+        mkdir -p $TARGET_DIR
+        cat $SOURCE_DIR/menhirLib.mli > $TARGET_DIR/menhirLib.mli
+        cat $SOURCE_DIR/menhirLib.ml > $TARGET_DIR/menhirLib.ml
+
     - name: Install GNU parallel
       if: matrix.os == 'macos-latest'
       run: HOMEBREW_NO_INSTALL_CLEANUP=TRUE brew install parallel

.github/workflows/coverage.yml

@@ -35,7 +35,12 @@ jobs:
       id: cache
       with:
         path: ${{ github.workspace }}/_opam
-        key: ${{ matrix.os }}-cache-ocaml-414-dune-2.9.1-g7606d586
+        key: ${{ matrix.os }}-cache-ocaml-414-dune-2.9.1-g7606d586-menhir20210419
+
+    - name: Install menhir
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: |
+        opam pin menhir 20210419
 
     - name: Build bisect_ppx
       if: steps.cache.outputs.cache-hit != 'true'

.vscode/settings.json

@@ -2,5 +2,11 @@
         "ocaml.sandbox": {
                 "kind": "opam",
                 "switch": "4.14.1"
+        },
+        "files.associations": {
+                "*.mlp": "ocaml",
+                "smmintrin.h": "c",
+                "tmmintrin.h": "c",
+                "pmmintrin.h": "c"
         }
-}
+}

HACKING.md

@@ -92,9 +92,13 @@ Depending on the initial changes, it might be necessary to do this multiple time
 ## Rebuilding during dev work
 
 To rebuild after making changes, you can just type `make`. You need to
-have a working OCaml 4.14 compiler on your PATH before doing so,
+have a working OCaml 4.14 or 4.14.1 compiler on your PATH before doing so,
 e.g. installed via OPAM.
 
+<!-- CR someone: investigate this -->
+The build currently fails when using the latest version of `dune` (3.11.1).
+To install a known-good dune, run `opam pin add dune 3.8.1`.
+
 There is a special target `make hacking` which starts Dune in polling mode.  The rebuild
 performed here is equivalent to `make ocamlopt` in the upstream distribution: it rebuilds the
 compiler itself, but doesn't rebuild the stdlib or anything else with the new compiler.

Makefile

@@ -151,7 +151,8 @@ build_and_test_upstream: build_upstream
 	if $$(which gfortran > /dev/null 2>&1); then \
 	  export LIBRARY_PATH=$$(dirname $$(gfortran -print-file-name=libgfortran.a)); \
 	fi; \
-	cd _build_upstream/testsuite \
+	export OCAMLSRCDIR=$$(pwd)/_build_upstream \
+         && cd _build_upstream/testsuite \
 	 && if $$(which parallel > /dev/null 2>&1); \
             then \
 	      echo "Running testsuite in parallel (nproc=$$(nproc))"; \

backend/.ocamlformat-enable

@@ -16,7 +16,7 @@ peephole/**/*.ml
 peephole/**/*.mli
 regalloc/**/*.ml
 regalloc/**/*.mli
-amd64/simd.ml 
-arm64/simd.ml 
-amd64/simd_selection.ml 
-arm64/simd_selection.ml 
+amd64/simd*.ml
+arm64/simd*.ml
+generic_fns.ml
+generic_fns.mli

backend/CSEgen.ml

@@ -202,12 +202,13 @@ let kill_addr_regs n =
 
 (* Prepend a set of moves before [i] to assign [srcs] to [dsts].  *)
 
-let insert_single_move i src dst = instr_cons (Iop Imove) [|src|] [|dst|] i
+let insert_single_move i src dst =
+  instr_cons_debug (Iop Imove) [|src|] [|dst|] i.dbg i
 
 let insert_move srcs dsts i =
   match Array.length srcs with
   | 0 -> i
-  | 1 -> instr_cons (Iop Imove) srcs dsts i
+  | 1 -> instr_cons_debug (Iop Imove) srcs dsts i.dbg i
   | _ -> (* Parallel move: first copy srcs into tmps one by one,
             then copy tmps into dsts one by one *)
          let tmps = Reg.createv_like srcs in
@@ -237,12 +238,13 @@ method class_of_operation op =
   | Icall_ind | Icall_imm _ | Itailcall_ind | Itailcall_imm _
   | Iextcall _ | Iprobe _ | Iopaque -> assert false  (* treated specially *)
   | Istackoffset _ -> Op_other
-  | Iload(_,_,mut) -> Op_load mut
+  | Iload { mutability = Mutable } -> Op_load Mutable
+  | Iload { mutability = Immutable } -> Op_load Immutable
   | Istore(_,_,asg) -> Op_store asg
   | Ialloc _ | Ipoll _ -> assert false     (* treated specially *)
-  | Iintop(Icheckbound) -> Op_checkbound
+  | Iintop(Icheckbound|Icheckalign _) -> Op_checkbound
   | Iintop _ -> Op_pure
-  | Iintop_imm(Icheckbound, _) -> Op_checkbound
+  | Iintop_imm((Icheckbound|Icheckalign _), _) -> Op_checkbound
   | Iintop_imm(_, _) -> Op_pure
   | Iintop_atomic _ -> Op_store true
   | Icompf _
@@ -253,6 +255,7 @@ method class_of_operation op =
   | Iname_for_debugger _ -> Op_other
   | Iprobe_is_enabled _ -> Op_other
   | Ibeginregion | Iendregion -> Op_other
+  | Idls_get -> Op_load Mutable
 
 (* Operations that are so cheap that it isn't worth factoring them. *)
 
@@ -321,8 +324,7 @@ method private cse n i k =
               (* This operation was computed earlier. *)
               (* Are there registers that hold the results computed earlier? *)
               begin match find_regs_containing n1 vres with
-              | Some res when (not (self#is_cheap_operation op))
-                           && (not (Proc.regs_are_volatile res)) ->
+              | Some res when (not (self#is_cheap_operation op)) ->
                   (* We can replace res <- op args with r <- move res,
                      provided res are stable (non-volatile) registers.
                      If the operation is very cheap to compute, e.g.

backend/afl_instrument.ml

@@ -14,7 +14,6 @@
 
 (* Insert instrumentation for afl-fuzz *)
 
-open Lambda
 open Cmm
 
 module V = Backend_var
@@ -43,13 +42,19 @@ let rec with_afl_logging b dbg =
     let afl_area = V.create_local "shared_mem" in
     let op oper args = Cop (oper, args, dbg) in
     Clet(VP.create afl_area,
-      op (Cload (Word_int, Asttypes.Mutable)) [afl_area_ptr dbg],
-      Clet(VP.create cur_pos, op Cxor [op (Cload (Word_int, Asttypes.Mutable))
+         op (Cload ({memory_chunk=Word_int;
+                     mutability=Asttypes.Mutable;
+                     is_atomic=false})) [afl_area_ptr dbg],
+         Clet(VP.create cur_pos, op Cxor [op (Cload {memory_chunk=Word_int;
+                                                     mutability=Asttypes.Mutable;
+                                                     is_atomic=false})
         [afl_prev_loc dbg]; Cconst_int (cur_location, dbg)],
       Csequence(
         op (Cstore(Byte_unsigned, Assignment))
           [op Cadda [Cvar afl_area; Cvar cur_pos];
-            op Cadda [op (Cload (Byte_unsigned, Asttypes.Mutable))
+           op Cadda [op (Cload {memory_chunk=Byte_unsigned;
+                                mutability=Asttypes.Mutable;
+                                is_atomic=false})
                         [op Cadda [Cvar afl_area; Cvar cur_pos]];
                       Cconst_int (1, dbg)]],
         op (Cstore(Word_int, Assignment))
@@ -105,15 +110,13 @@ let instrument_initialiser c dbg =
   (* Each instrumented module calls caml_setup_afl at
      initialisation, which is a no-op on the second and subsequent
      calls *)
-  with_afl_logging
-    (Csequence
-       (Cop (Cextcall { func = "caml_setup_afl";
-                        builtin = false;
-                        returns = true;
-                        effects = Arbitrary_effects;
-                        coeffects = Has_coeffects;
-                        ty = typ_int; alloc = false; ty_args = []; },
-             [Cconst_int (0, dbg ())],
-             dbg ()),
-        c))
-    (dbg ())
+  Csequence
+    (Cop (Cextcall { func = "caml_setup_afl";
+                     builtin = false;
+                     returns = true;
+                     effects = Arbitrary_effects;
+                     coeffects = Has_coeffects;
+                     ty = typ_int; alloc = false; ty_args = []; },
+          [Cconst_int (0, dbg ())],
+          dbg ()),
+     with_afl_logging c (dbg ()))

backend/amd64/CSE.ml

@@ -33,10 +33,9 @@ method! class_of_operation op =
     | Istore_int(_, _, is_asg) -> Op_store is_asg
     | Ioffset_loc(_, _) -> Op_store true
     | Ifloatarithmem _ | Ifloatsqrtf _ -> Op_load Mutable
-    | Ibswap _ | Isqrtf -> super#class_of_operation op
+    | Ibswap _ -> super#class_of_operation op
     | Irdtsc | Irdpmc
     | Ilfence | Isfence | Imfence -> Op_other
-    | Ifloat_iround | Ifloat_min | Ifloat_max | Ifloat_round _ -> Op_pure
     | Isimd op ->
       begin match Simd.class_of_operation op with
       | Pure -> Op_pure
@@ -53,7 +52,7 @@ method! class_of_operation op =
   | Istackoffset _ | Iload _ | Istore _ | Ialloc _
   | Iintop _ | Iintop_imm _ | Iintop_atomic _
   | Iname_for_debugger _ | Iprobe _ | Iprobe_is_enabled _ | Iopaque
-  | Ibeginregion | Iendregion | Ipoll _
+  | Ibeginregion | Iendregion | Ipoll _ | Idls_get
     -> super#class_of_operation op
 
 end

backend/amd64/NOTES.md

@@ -19,3 +19,5 @@ Debian architecture name: `amd64`
   _OS X ABI Function Call Guide: x86-64 Function Calling Conventions_
 * Windows 64 application binary interface:
   _x64 Software Conventions_ from MSDN
+* SIMD Intrinsics API
+  [Intel Intrinsics Guide](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html)