Merge branch 'master' into fix_not_vec

Author: rmalmain

.github/workflows/main.yml

@@ -19,4 +19,4 @@ jobs:
     # build and test with multiple LLVM versions
     - run: docker build --build-arg LLVM_VERSION=${{ matrix.llvm_versions }} -t symqemu .
     - run: docker run -t symqemu make -C build check
-    - run: docker run -t symqemu sh -c "cd tests/symqemu && python3 -m unittest test.py"
+    - run: docker run -t symqemu sh -c "cd tests/symqemu && python3.11 -m unittest test.py"

.gitignore

@@ -20,3 +20,5 @@ GTAGS
 *.swp
 *.patch
 *.gcov
+
+**/generated_outputs/

Dockerfile

@@ -6,7 +6,7 @@ RUN apt update && apt install -y \
     libglib2.0-dev \
     llvm \
     git \
-    python3 \
+    python3.11 \
     python3-pip \
     cmake \
     wget \

tcg/tcg-op.c

@@ -426,15 +426,28 @@ void tcg_gen_discard_i32(TCGv_i32 arg)
     tcg_gen_op1_i32(INDEX_op_discard, arg);
 }
 
-void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
+static void tcg_gen_mov_i32_internal(TCGv_i32 ret, TCGv_i32 arg, bool concrete)
 {
     if (ret != arg) {
-        tcg_gen_op2_i64(INDEX_op_mov_i64, tcgv_i32_expr_num(ret),
-                        tcgv_i32_expr_num(arg));
+        if (!concrete) {
+            tcg_gen_op2_i64(INDEX_op_mov_i64, tcgv_i32_expr_num(ret),
+                            tcgv_i32_expr_num(arg));
+        }
+
         tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
     }
 }
 
+void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
+{
+    tcg_gen_mov_i32_internal(ret, arg, false);
+}
+
+void tcg_gen_mov_i32_concrete(TCGv_i32 ret, TCGv_i32 arg)
+{
+    tcg_gen_mov_i32_internal(ret, arg, true);
+}
+
 void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
 {
     /* TODO : Make movi rely on the inline mov_i32 */
@@ -3504,8 +3517,7 @@ void tcg_gen_extrl_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
     } else {*/
         gen_helper_sym_trunc_i64_i32(tcgv_i32_expr(ret), tcgv_i64_expr(arg));
         /* We don't want symbolic handling of this mov. */
-        if (ret != (TCGv_i32)arg)
-            tcg_gen_op2_i32(INDEX_op_mov_i32, ret, (TCGv_i32)arg);
+        tcg_gen_mov_i32_concrete(ret, (TCGv_i32)arg);
     /* } */
 }
 
@@ -3521,7 +3533,7 @@ void tcg_gen_extrh_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
         tcg_gen_shri_i64(t, arg, 32);
         gen_helper_sym_trunc_i64_i32(tcgv_i32_expr(ret), tcgv_i64_expr(t));
         /* We don't want symbolic handling of this mov. */
-        tcg_gen_op2_i32(INDEX_op_mov_i32, ret, (TCGv_i32)t);
+        tcg_gen_mov_i32_concrete(ret, (TCGv_i32)t);
         tcg_temp_free_i64(t);
     /*}*/
 }

tests/symqemu/test.py

@@ -1,10 +1,10 @@
-import filecmp
 import pathlib
 import shutil
 import unittest
 import tempfile
 import subprocess
 import os
+import hashlib
 
 import util
 
@@ -19,33 +19,30 @@ def run_symqemu_and_assert_correct_result(self, binary_name):
 
         util.run_symqemu_on_test_binary(binary_name=binary_name, generated_test_cases_output_dir=symqemu_gen_output_dir)
 
-        # `filecmp.dircmp` does a "shallow" comparison, but this is not a problem here because
-        # the timestamps should always be different, so the actual content of the files will be compared.
-        # See https://docs.python.org/3/library/filecmp.html#filecmp.dircmp
-        expected_vs_actual_output_comparison = filecmp.dircmp(symqemu_gen_output_dir, symqemu_ref_output_dir)
-
-        for diff_file in expected_vs_actual_output_comparison.diff_files:
-            ref_file = symqemu_ref_output_dir / diff_file
-            gen_file = symqemu_gen_output_dir / diff_file
-
-            tmp_ref = tempfile.NamedTemporaryFile("w+")
-            subprocess.run(["xxd", f"{ref_file}"], stdout=tmp_ref, check=True)
-
-            tmp_gen = tempfile.NamedTemporaryFile("w+")
-            subprocess.run(["xxd", f"{gen_file}"], stdout=tmp_gen, check=True)
-
-            wdiff = subprocess.run(["wdiff", f"{tmp_ref.name}", f"{tmp_gen.name}"], capture_output=True)
-            colordiff = subprocess.run(["colordiff"], input=wdiff.stdout, capture_output=True)
-
-            print(f"===== Diff found in {diff_file} ======")
-            print(f"{colordiff.stdout.decode('utf-8').strip()}")
-            print(f"=================================")
-            print()
-
-        self.assertEqual(expected_vs_actual_output_comparison.diff_files, [])
-        self.assertEqual(expected_vs_actual_output_comparison.left_only, [])
-        self.assertEqual(expected_vs_actual_output_comparison.right_only, [])
-        self.assertEqual(expected_vs_actual_output_comparison.funny_files, [])
+        expected_hashes = {}
+        for ref_file in symqemu_ref_output_dir.iterdir():
+            with open(ref_file, 'rb', buffering=0) as f:
+                f_hash = hashlib.file_digest(f, "sha256").hexdigest()
+                expected_hashes[f_hash] = [False, ref_file]
+
+        testcase_not_found = False
+        for gen_file in symqemu_gen_output_dir.iterdir():
+            with open(gen_file, 'rb', buffering=0) as f:
+                f_hash = hashlib.file_digest(f, "sha256").hexdigest()
+                ret = expected_hashes.get(f_hash)
+                if ret is not None:
+                    ret[0] = True
+                    expected_hashes[f_hash] = ret
+                else:
+                    print(f"Error: content of file {gen_file} not found in expected testcases.");
+                    testcase_not_found = True
+
+        for (is_found, fname) in expected_hashes.values():
+            # (is_found, fname) = tuple(ret)
+            if not is_found:
+                print(f"Warning: expected testcase {fname} has not been generated.")
+
+        self.assertFalse(testcase_not_found)
 
     def test_simple(self):
         self.run_symqemu_and_assert_correct_result('simple')