[wasm] Provide backoff implementations for the Fxx rounding instructions

test/cctest/compiler/codegen-tester.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 #define V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/raw-machine-assembler.h"
@@ skipping 22 matching lines @@
         RawMachineAssembler(
             main_isolate(), new (main_zone()) Graph(main_zone()),
             Linkage::GetSimplifiedCDescriptor(
                 main_zone(),
                 CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0,
                                 p1, p2, p3, p4),
                 true),
             MachineType::PointerRepresentation(),
             InstructionSelector::SupportedMachineOperatorFlags()) {}
 
+  virtual ~RawMachineAssemblerTester() {}
+
   void CheckNumber(double expected, Object* number) {
     CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
   }
 
   void CheckString(const char* expected, Object* string) {
     CHECK(
         this->isolate()->factory()->InternalizeUtf8String(expected)->SameValue(
             string));
   }
 
@@ skipping 26 matching lines @@
 class BufferedRawMachineAssemblerTester
     : public RawMachineAssemblerTester<int32_t> {
  public:
   BufferedRawMachineAssemblerTester(MachineType p0 = MachineType::None(),
                                     MachineType p1 = MachineType::None(),
                                     MachineType p2 = MachineType::None(),
                                     MachineType p3 = MachineType::None())
       : BufferedRawMachineAssemblerTester(ComputeParameterCount(p0, p1, p2, p3),
                                           p0, p1, p2, p3) {}
 
+  virtual byte* Generate() { return RawMachineAssemblerTester::Generate(); }
 
   // The BufferedRawMachineAssemblerTester does not pass parameters directly
   // to the constructed IR graph. Instead it passes a pointer to the parameter
   // to the IR graph, and adds Load nodes to the IR graph to load the
   // parameters from memory. Thereby it is possible to pass 64 bit parameters
   // to the IR graph.
   Node* Parameter(size_t index) {
     CHECK(index < 4);
     return parameter_nodes_[index];
   }
@@ skipping 139 matching lines @@
                               ? nullptr
                               : Load(p1, RawMachineAssembler::Parameter(1));
     parameter_nodes_[2] = p2 == MachineType::None()
                               ? nullptr
                               : Load(p2, RawMachineAssembler::Parameter(2));
     parameter_nodes_[3] = p3 == MachineType::None()
                               ? nullptr
                               : Load(p3, RawMachineAssembler::Parameter(3));
   }
 
+  virtual byte* Generate() { return RawMachineAssemblerTester::Generate(); }
+
   // The BufferedRawMachineAssemblerTester does not pass parameters directly
   // to the constructed IR graph. Instead it passes a pointer to the parameter
   // to the IR graph, and adds Load nodes to the IR graph to load the
   // parameters from memory. Thereby it is possible to pass 64 bit parameters
   // to the IR graph.
   Node* Parameter(size_t index) {
     CHECK(index >= 0 && index < 4);
     return parameter_nodes_[index];
   }
 
@@ skipping 258 matching lines @@
  public:
   virtual void gen(RawMachineAssemblerTester<int32_t>* m, Node* a, Node* b) = 0;
   virtual T expected(T a, T b) = 0;
   virtual ~BinopGen() {}
 };
 
 // A helper class to generate various combination of input shape combinations
 // and run the generated code to ensure it produces the correct results.
 class Int32BinopInputShapeTester {
  public:
-  explicit Int32BinopInputShapeTester(BinopGen<int32_t>* g) : gen(g) {}
+  explicit Int32BinopInputShapeTester(BinopGen<int32_t>* g)
+      : gen(g), input_a(0), input_b(0) {}
 
   void TestAllInputShapes();
 
  private:
   BinopGen<int32_t>* gen;
   int32_t input_a;
   int32_t input_b;
 
   void Run(RawMachineAssemblerTester<int32_t>* m);
   void RunLeft(RawMachineAssemblerTester<int32_t>* m);
@@ skipping 15 matching lines @@
   } else {
     CHECK_EQ(x, y);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_CODEGEN_TESTER_H_