Merge branch 'bittrick_tests' into 'derivgrind'

Add tests of bit-trick finder instrumentation.

See merge request aehle/valgrind!26

Author: maxaehle

.gitlab-ci.yml

@@ -59,6 +59,14 @@ test_bar_amd64:
     - apt-get install -y build-essential gfortran gdb gcc-multilib g++-multilib gfortran-multilib libc6-dbg clang libomp-dev python3 python3-numpy
     - cd derivgrind/diff_tests && python3 run_tests.py bar_amd64* --prefix=$PWD/../../install_lightweight
 
+test_trick_amd64:
+  stage: test
+  script:
+    - export DEBIAN_FRONTEND=noninteractive
+    - apt-get update
+    - apt-get install -y build-essential python3 libgcrypt20-dev zlib1g-dev
+    - cd derivgrind/trick_tests && python3 trick-tests.py --prefix=$PWD/../../install_lightweight
+
 test_perf_x86:
   stage: test
   script:

derivgrind/bar/dg_bar.c

@@ -375,14 +375,18 @@ void* dg_bar_operation(DiffEnv* diffenv, IROp op,
   }
 }
 
+void* dg_bar_ccall(DiffEnv* diffenv, IRCallee* cee, IRType retty, IRExpr** args, void** modified_args){
+  return NULL;
+}
+
 const ExpressionHandling dg_bar_expressionhandling = {
   &dg_bar_wrtmp,&dg_bar_rdtmp,
   &dg_bar_puti,&dg_bar_geti,
   &dg_bar_store,&dg_bar_load,
   &dg_bar_dirty_storeF80le,&dg_bar_dirty_loadF80le,
   &dg_bar_constant,&dg_bar_default_,
   &dg_bar_compare,&dg_bar_ite,
-  &dg_bar_operation
+  &dg_bar_operation,&dg_bar_ccall
 };
 
 void dg_bar_handle_statement(DiffEnv* diffenv, IRStmt* st_orig){

derivgrind/dg_expressionhandling.c

@@ -83,6 +83,15 @@ void* dg_modify_expression(DiffEnv* diffenv, ExpressionHandling eh, IRExpr* ex){
     return eh.geti(diffenv,ex->Iex.GetI.bias,Ity_INVALID,ex->Iex.GetI.descr,ex->Iex.GetI.ix);
   } else if (ex->tag==Iex_Load) {
     return eh.load(diffenv,ex->Iex.Load.addr,ex->Iex.Load.ty);
+  } else if (ex->tag==Iex_CCall) {
+    IRExpr** args = ex->Iex.CCall.args;
+    int nargs = 0;
+    while(args[nargs]!=NULL) nargs++;
+    void** modified_args = LibVEX_Alloc(nargs*sizeof(void*));
+    for(int i=0; i<nargs; i++){
+      modified_args[i] = dg_modify_expression(diffenv,eh,args[i]);
+    }
+    return eh.ccall(diffenv,ex->Iex.CCall.cee,ex->Iex.CCall.retty,args,modified_args);
   } else {
     return NULL;
   }
@@ -217,7 +226,7 @@ void add_statement_modified(DiffEnv* diffenv, ExpressionHandling eh, IRStmt* st_
       IRExpr** args = det->args;
       IRExpr* addr = args[0];
       IRExpr* expr = args[1];
-      IRExpr* modified_expr = dg_modify_expression_or_default(diffenv,eh,expr,False,"");
+      void* modified_expr = dg_modify_expression_or_default(diffenv,eh,expr,False,"");
       eh.dirty_storeF80le(diffenv,addr, modified_expr);
     }
     // The x86g_dirtyhelper_loadF80le dirty call loads 80 bit from

derivgrind/dg_expressionhandling.h

@@ -51,9 +51,10 @@
 
 /*! Tuple of functions defining how to modify expressions and to instrument statements.
  * 
- * We define two instances:
+ * We define three instances:
  * - dg_dot_expressionhandling in dot/dg_dot.c for forward-mode instrumentation.
  * - dg_bar_expressionhandling in bar/dg_bar.c for recording-mode instrumentation.
+ * - dg_trick_expressionhandling in trick/dg_trick.c for bit-trick-finder instrumentation.
  */
 typedef struct {
 
@@ -158,6 +159,15 @@ typedef struct {
                      IRExpr* arg1, IRExpr* arg2, IRExpr* arg3, IRExpr* arg4,
                      void* mod1, void* mod2, void* mod3, void* mod4);
 
+  /*! Handling of CCalls.
+   *  \param diffenv - General setup.
+   *  \param cee - Function wrapped by the CCall.
+   *  \param retty - Type of return value of the CCall.
+   *  \param args - NULL-terminated list of argument expressions.
+   *  \param modified_args - NULL-terminated list of the corresponding modified arguments.
+   */
+  void* (*ccall)(DiffEnv* diffenv, IRCallee* cee, IRType retty, IRExpr** args, void** modified_args);
+
 } ExpressionHandling;
 
 /*! Return expression modified for use in the instrumented statement.

derivgrind/dot/dg_dot.c

@@ -231,14 +231,18 @@ void* dg_dot_operation(DiffEnv* diffenv, IROp op,
   }
 }
 
+void* dg_dot_ccall(DiffEnv* diffenv, IRCallee* cee, IRType retty, IRExpr** args, void** modified_args){
+  return NULL;
+}
+
 const ExpressionHandling dg_dot_expressionhandling = {
   &dg_dot_wrtmp,&dg_dot_rdtmp,
   &dg_dot_puti,&dg_dot_geti,
   &dg_dot_store,&dg_dot_load,
   &dg_dot_dirty_storeF80le,&dg_dot_dirty_loadF80le,
   &dg_dot_constant,&dg_dot_default_,
   &dg_dot_compare,&dg_dot_ite,
-  &dg_dot_operation
+  &dg_dot_operation,&dg_dot_ccall
 };
 
 void dg_dot_handle_statement(DiffEnv* diffenv, IRStmt* st_orig){

derivgrind/trick/dg_trick.c

@@ -202,14 +202,30 @@ void* dg_trick_operation(DiffEnv* diffenv, IROp op,
   }
 }
 
+void* dg_trick_ccall(DiffEnv* diffenv, IRCallee* cee, IRType retty, IRExpr** args, void** modified_args){
+  // The result is active if there is an operand with non-zero activity flags.
+  IRExpr* notActive = IRExpr_Const(IRConst_U1(True));
+  int i=0;
+  while(args[i]){
+    IRType argtype = typeOfIRExpr(diffenv->sb_out->tyenv, args[i]);
+    notActive = IRExpr_Binop(Iop_And1,notActive,isZero(((IRExpr**)(modified_args[i]))[0],argtype));
+    i++;
+  }
+  IRExpr* flagsLo = IRExpr_ITE(notActive,mkIRConst_zero(retty),mkIRConst_ones(retty));
+  // The result is always discrete, as we do not consider expressions in the
+  // AD expression handling right now.
+  IRExpr* flagsHi = mkIRConst_ones(retty);
+  return mkIRExprVec_2(flagsLo,flagsHi);
+}
+
 const ExpressionHandling dg_trick_expressionhandling = {
   &dg_bar_wrtmp,&dg_bar_rdtmp,
   &dg_bar_puti,&dg_bar_geti,
   &dg_bar_store,&dg_bar_load,
   &dg_trick_dirty_storeF80le,&dg_trick_dirty_loadF80le,
   &dg_bar_constant,&dg_bar_default_,
   &dg_bar_compare,&dg_bar_ite,
-  &dg_trick_operation
+  &dg_trick_operation,&dg_trick_ccall
 };
 
 void dg_trick_handle_statement(DiffEnv* diffenv, IRStmt* st_orig){

derivgrind/trick_tests/trick-tests.py

@@ -0,0 +1,93 @@
+import sys
+import subprocess
+import fnmatch
+import tempfile
+
+install_dir = "../../install"
+temp_dir = None
+selected_testcase = "*" # The user might specify a pattern in order to run only a subset of all bit-trick tests.
+no_external_dependencies = False # suppress testcases that require external dependencies
+for arg in sys.argv[1:]:
+  if arg.startswith("--prefix="):
+    install_dir = arg[len("--prefix="):]
+  elif arg.startswith('--tempdir='):
+    temp_dir = arg[len('--tempdir='):]
+  elif arg.startswith('--no-external-dependencies'):
+    no_external_dependencies = True
+  elif arg in ['-h', '--help']:
+    print(
+"""Test script to run testcases of the "tricky program" under Derivgrind's
+forward-mode and bit-trick-finder instrumentation.
+Arguments: 
+  --prefix=path    .. Path of Derivgrind installation.
+  --tempdir=path   .. Temporary directory used by this script.
+  --no-external-dependencies  
+    .. If certain libraries required for some testcases (libgcrypt,libz) are 
+       missing, do not run these.
+  testcase_name    .. Run only a single or few testcases; "*" is a wildcard.
+""")
+    exit(0)
+
+
+  else:
+    selected_testcase = arg
+if temp_dir == None:
+  t = tempfile.TemporaryDirectory()
+  temp_dir = t.name
+
+subprocess.run(["g++"] + (["-DTRICKTEST_NO_EXTERNAL_DEPENDENCIES"] if no_external_dependencies else []) +["tricky-program.cpp", "-o", temp_dir+"/tricky-program", "-O0", "-mfpmath=sse", "-g", "-I"+install_dir+"/include"] + ([] if no_external_dependencies else ["-lgcrypt","-lz"]) )
+
+# Map testcase name to a tuple of booleans.
+# The first element indicates whether external dependencies are required.
+# The secomd element indicates whether a wrong derivative is reported as an error. 
+# As we mostly test unsupported bit-tricks here, this will usually be False.
+# The third element indicates whether a wrong derivative without bit-trick finder
+# warning is reported as an error. This is usually True, except for known false negatives.
+tests = {
+  "integer_addition_to_exponent_double": (False,False,True),
+  "integer_addition_to_exponent_float": (False,False,True),
+  "incomplete_masking_to_perform_frexp_double": (False,False,True),
+  "incomplete_masking_to_perform_frexp_float": (False,False,True),
+  "exploiting_imprecisions_for_rounding_double": (False,False,False),
+  "exploiting_imprecisions_for_rounding_float": (False,False,False),
+  "encrypt_decrypt": (True,False,True),
+  "compress_inflate": (True,False,False),
+  "multiple_mmap": (True,False,False),
+}
+fail = False
+for test in tests:
+  if fnmatch.fnmatchcase(test,selected_testcase):
+    print(test+":")
+    # If test requires external dependencies but they are disabled, skip.
+    if tests[test][0] and no_external_dependencies:
+      print("  ext deps disabled  - SKIP")
+      continue
+
+    # Test correctness of forward-mode derivatives.
+    forwardrun = subprocess.run([install_dir+"/bin/valgrind", "--tool=derivgrind", temp_dir+"/tricky-program", test], capture_output=True)
+    forward_correct = (forwardrun.stdout.decode("utf-8").find("WRONG FORWARD-MODE DERIVATIVE")==-1)
+    if forward_correct:
+      forward_output = "correct derivative - OK  "
+    elif not tests[test][1]:
+      forward_output = "wrong derivative   - OK  "
+    else:
+      forward_output = "wrong derivative   - FAIL"
+      fail = True
+    print("  "+forward_output)
+
+    # Test whether the bit-trick finding instrumentation produces a warning.
+    trickrun = subprocess.run([install_dir+"/bin/valgrind", "--tool=derivgrind", "--trick=yes", temp_dir+"/tricky-program", test], capture_output=True)
+    trick_found = (trickrun.stderr.decode("utf-8").find("Active discrete data used as floating-point operand.")!=-1)
+    if trick_found:
+      trick_output = "trick found        - OK  "
+    elif not tests[test][2]:
+      trick_output = "trick not found    - OK  "
+    else:
+      trick_output = "trick not found    - FAIL"
+      fail = True
+    print("  "+trick_output) 
+
+exit(fail)
+
+
+