Finishing up tests

libraries/chain/wasm_interface.cpp

@@ -1245,37 +1245,37 @@ class compiler_builtins : public context_aware_api {
       }
       int __eqtf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return f128_eq( a, b );
       }
       int __netf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return !f128_eq( a, b );
       }
       int __getf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return !f128_lt( a, b );
       }
       int __gttf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return !f128_lt( a, b ) && !f128_eq( a, b );
       }
       int __letf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return f128_le( a, b );
       }
       int __lttf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          return f128_lt( a, b );
       }
       int __cmptf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          if ( f128_lt( a, b ) )
             return -1;
          if ( f128_eq( a, b ) )
@@ -1284,7 +1284,7 @@ class compiler_builtins : public context_aware_api {
       }
       int __unordtf2( uint64_t la, uint64_t ha, uint64_t lb, uint64_t hb ) {
          float128_t a = {{ la, ha }};
-         float128_t b = {{ la, ha }};
+         float128_t b = {{ lb, hb }};
          if ( f128_isSignalingNaN( a ) || f128_isSignalingNaN( b ) )
             return 1;
          return 0;

softfloat @ 72f025ba

-Subproject commit 0d5d0aa60bef30848d73521d39e0ca80665b308e
+Subproject commit 72f025ba240d49a6531d40148ca229a358404f78

tests/wasm_tests/test_wasts.hpp

@@ -33,6 +33,23 @@ static const char aligned_ref_wast[] = R"=====(
 )
 )=====";
 
+static const char aligned_ptr_wast[] = R"=====(
+(module
+ (import "env" "diveq_i128" (func $diveq_i128 (param i32 i32)))
+ (table 0 anyfunc)
+ (memory $0 32)
+ (data (i32.const 16) "random stuff")
+ (export "apply" (func $apply))
+ (func $apply (param $0 i64) (param $1 i64) (param $2 i64)
+  (call $diveq_i128
+   (i32.const 16)
+   (i32.const 16)
+  )
+ )
+)
+)=====";
+
+
 static const char aligned_const_ref_wast[] = R"=====(
 (module
  (import "env" "sha256" (func $sha256 (param i32 i32 i32)))
@@ -42,16 +59,48 @@ static const char aligned_const_ref_wast[] = R"=====(
  (data (i32.const 4) "hello")
  (export "apply" (func $apply))
  (func $apply (param $0 i64) (param $1 i64) (param $2 i64)
-  (local $0 i32)
+  (local $3 i32)
   (call $sha256
    (i32.const 4)
    (i32.const 5)
-   (get_local $0)
+   (i32.const 16)
   )
   (call $assert_sha256
    (i32.const 4)
    (i32.const 5)
-   (get_local $0)
+   (i32.const 16)
+  )
+ )
+)
+)=====";
+
+static const char misaligned_ptr_wast[] = R"=====(
+(module
+ (import "env" "diveq_i128" (func $diveq_i128 (param i32 i32)))
+ (table 0 anyfunc)
+ (memory $0 32)
+ (data (i32.const 16) "random stuff")
+ (export "apply" (func $apply))
+ (func $apply (param $0 i64) (param $1 i64) (param $2 i64)
+  (call $diveq_i128
+   (i32.const 17)
+   (i32.const 16)
+  )
+ )
+)
+)=====";
+
+static const char misaligned_const_ptr_wast[] = R"=====(
+(module
+ (import "env" "diveq_i128" (func $diveq_i128 (param i32 i32)))
+ (table 0 anyfunc)
+ (memory $0 32)
+ (data (i32.const 16) "random stuff")
+ (export "apply" (func $apply))
+ (func $apply (param $0 i64) (param $1 i64) (param $2 i64)
+  (call $diveq_i128
+   (i32.const 16)
+   (i32.const 17)
   )
  )
 )
@@ -76,17 +125,31 @@ static const char misaligned_ref_wast[] = R"=====(
 
 static const char misaligned_const_ref_wast[] = R"=====(
 (module
+ (import "env" "sha256" (func $sha256 (param i32 i32 i32)))
  (import "env" "assert_sha256" (func $assert_sha256 (param i32 i32 i32)))
+ (import "env" "memcpy" (func $memcpy (param i32 i32 i32) (result i32)))
  (table 0 anyfunc)
  (memory $0 32)
  (data (i32.const 4) "hello")
- (data (i32.const 23) "5891B5B522D5DF086D0FF0B110FBD9D21BB4FC7163AF34D08286A2E846F6BE03")
  (export "apply" (func $apply))
  (func $apply (param $0 i64) (param $1 i64) (param $2 i64)
-  (call $assert_sha256
+  (local $3 i32)
+  (call $sha256
    (i32.const 4)
    (i32.const 5)
+   (i32.const 16)
+  )
+  (set_local $3
+   (call $memcpy
+    (i32.const 17)
+    (i32.const 16)
+    (i32.const 64) 
+   )
+  )
+  (call $assert_sha256
+   (i32.const 4)
    (i32.const 5)
+   (i32.const 17)
   )
  )
 )

tests/wasm_tests/wasm_tests.cpp

@@ -94,7 +94,7 @@ uint32_t last_fnc_err = 0;
 #define CAPTURE(STREAM, EXEC) \
    {\
       capture.clear(); \
-      bio::stream_buffer<MySink> sb; sb.open(MySink()); \
+      boost::iostreams::stream_buffer<MySink> sb; sb.open(MySink()); \
       std::streambuf *oldbuf = std::STREAM.rdbuf(&sb); \
       EXEC; \
       std::STREAM.rdbuf(oldbuf); \
@@ -517,10 +517,14 @@ BOOST_FIXTURE_TEST_CASE(misaligned_tests, tester ) try {
       BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
    };
 
-   check_aligned(aligned_ref_wast);
+   CAPTURE( std::stderr, check_aligned(aligned_ref_wast) );
+   //std::cout << "CAPTURED {" << capture[0] << "\n";
    check_aligned(misaligned_ref_wast);
-   //check_aligned(aligned_const_ref_wast);
+   check_aligned(aligned_const_ref_wast);
    check_aligned(misaligned_const_ref_wast);
+   check_aligned(aligned_ptr_wast);
+   check_aligned(misaligned_ptr_wast);
+   check_aligned(misaligned_const_ptr_wast);
 } FC_LOG_AND_RETHROW()
 
 // test cpu usage