Enables language tests for SIMMIPS.

runtime/vm/simulator_mips.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <math.h>  // for isnan.
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
@@ skipping 74 matching lines @@
 
   void Stop(Instr* instr, const char* message);
   void Debug();
   char* ReadLine(const char* prompt);
 
  private:
   Simulator* sim_;
 
   bool GetValue(char* desc, uint32_t* value);
   bool GetFValue(char* desc, double* value);
+  bool GetDValue(char* desc, double* value);
 
   // Set or delete a breakpoint. Returns true if successful.
   bool SetBreakpoint(Instr* breakpc);
   bool DeleteBreakpoint(Instr* breakpc);
 
   // Undo and redo all breakpoints. This is needed to bracket disassembly and
   // execution to skip past breakpoints when run from the debugger.
   void UndoBreakpoints();
   void RedoBreakpoints();
 };
@@ skipping 114 matching lines @@
         return false;
       }
       *value = *(reinterpret_cast<float*>(addr));
       return true;
     }
   }
   return false;
 }
 
 
+bool SimulatorDebugger::GetDValue(char* desc, double* value) {
+  FRegister freg = LookupFRegisterByName(desc);
+  if (freg != kNoFRegister) {
+    *value = sim_->get_fregister_double(freg);
+    return true;
+  }
+  if (desc[0] == '*') {
+    uint32_t addr;
+    if (GetValue(desc + 1, &addr)) {
+      if (Simulator::IsIllegalAddress(addr)) {
+        return false;
+      }
+      *value = *(reinterpret_cast<double*>(addr));
+      return true;
+    }
+  }
+  return false;
+}
+
+
 bool SimulatorDebugger::SetBreakpoint(Instr* breakpc) {
   // Check if a breakpoint can be set. If not return without any side-effects.
   if (sim_->break_pc_ != NULL) {
     return false;
   }
 
   // Set the breakpoint.
   sim_->break_pc_ = breakpc;
   sim_->break_instr_ = breakpc->InstructionBits();
   // Not setting the breakpoint instruction in the code itself. It will be set
@@ skipping 115 matching lines @@
           if (GetFValue(arg1, &dvalue)) {
             uint64_t long_value = bit_cast<uint64_t, double>(dvalue);
             OS::Print("%s: %llu 0x%llx %.8g\n",
                 arg1, long_value, long_value, dvalue);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printfloat <dreg or *addr>\n");
         }
+      } else if ((strcmp(cmd, "pd") == 0) ||
+                 (strcmp(cmd, "printdouble") == 0)) {
+        if (args == 2) {
+          double dvalue;
+          if (GetDValue(arg1, &dvalue)) {
+            uint64_t long_value = bit_cast<uint64_t, double>(dvalue);
+            OS::Print("%s: %llu 0x%llx %.8g\n",
+                arg1, long_value, long_value, dvalue);
+          } else {
+            OS::Print("%s unrecognized\n", arg1);
+          }
+        } else {
+          OS::Print("printfloat <dreg or *addr>\n");
+        }
       } else if ((strcmp(cmd, "po") == 0) ||
                  (strcmp(cmd, "printobject") == 0)) {
         if (args == 2) {
           uint32_t value;
           // Make the dereferencing '*' optional.
           if (((arg1[0] == '*') && GetValue(arg1 + 1, &value)) ||
               GetValue(arg1, &value)) {
             if (Isolate::Current()->heap()->Contains(value)) {
               OS::Print("%s: \n", arg1);
 #if defined(DEBUG)
@@ skipping 208 matching lines @@
 class Redirection {
  public:
   uword address_of_break_instruction() {
     return reinterpret_cast<uword>(&break_instruction_);
   }
 
   uword external_function() const { return external_function_; }
 
   Simulator::CallKind call_kind() const { return call_kind_; }
 
+  int argument_count() const { return argument_count_; }
+
   static Redirection* Get(uword external_function,
-                          Simulator::CallKind call_kind) {
+                          Simulator::CallKind call_kind,
+                          int argument_count) {
     Redirection* current;
     for (current = list_; current != NULL; current = current->next_) {
       if (current->external_function_ == external_function) return current;
     }
-    return new Redirection(external_function, call_kind);
+    return new Redirection(external_function, call_kind, argument_count);
   }
 
   static Redirection* FromBreakInstruction(Instr* break_instruction) {
     char* addr_of_break = reinterpret_cast<char*>(break_instruction);
     char* addr_of_redirection =
         addr_of_break - OFFSET_OF(Redirection, break_instruction_);
     return reinterpret_cast<Redirection*>(addr_of_redirection);
   }
 
  private:
   static const int32_t kRedirectInstruction =
     Instr::kBreakPointInstruction | (Instr::kRedirectCode << kBreakCodeShift);
 
-  Redirection(uword external_function, Simulator::CallKind call_kind)
+  Redirection(uword external_function,
+              Simulator::CallKind call_kind,
+              int argument_count)
       : external_function_(external_function),
         call_kind_(call_kind),
+        argument_count_(argument_count),
         break_instruction_(kRedirectInstruction),
         next_(list_) {
     list_ = this;
   }
 
   uword external_function_;
   Simulator::CallKind call_kind_;
+  int argument_count_;
   uint32_t break_instruction_;
   Redirection* next_;
   static Redirection* list_;
 };
 
 
 Redirection* Redirection::list_ = NULL;
 
 
-uword Simulator::RedirectExternalReference(uword function, CallKind call_kind) {
-  Redirection* redirection = Redirection::Get(function, call_kind);
+uword Simulator::RedirectExternalReference(uword function,
+                                           CallKind call_kind,
+                                           int argument_count) {
+  Redirection* redirection =
+      Redirection::Get(function, call_kind, argument_count);
   return redirection->address_of_break_instruction();
 }
 
 
 // Get the active Simulator for the current isolate.
 Simulator* Simulator::Current() {
   Simulator* simulator = Isolate::Current()->simulator();
   if (simulator == NULL) {
     simulator = new Simulator();
     Isolate::Current()->set_simulator(simulator);
@@ skipping 240 matching lines @@
 }
 
 
 // Calls into the Dart runtime are based on this interface.
 typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
 
 // Calls to leaf Dart runtime functions are based on this interface.
 typedef int32_t (*SimulatorLeafRuntimeCall)(
     int32_t r0, int32_t r1, int32_t r2, int32_t r3);
 
+// Calls to leaf float Dart runtime functions are based on this interface.
+typedef double (*SimulatorLeafFloatRuntimeCall)(double d0, double d1);
+
 // Calls to native Dart functions are based on this interface.
 typedef void (*SimulatorNativeCall)(NativeArguments* arguments);
 
 
 void Simulator::DoBreak(Instr *instr) {
   ASSERT(instr->OpcodeField() == SPECIAL);
   ASSERT(instr->FunctionField() == BREAK);
   if (instr->BreakCodeField() == Instr::kStopMessageCode) {
     SimulatorDebugger dbg(this);
     const char* message = *reinterpret_cast<const char**>(
@@ skipping 15 matching lines @@
     SimulatorSetjmpBuffer buffer(this);
 
     if (!setjmp(buffer.buffer_)) {
       int32_t saved_ra = get_register(RA);
       Redirection* redirection = Redirection::FromBreakInstruction(instr);
       uword external = redirection->external_function();
       if (FLAG_trace_sim) {
         OS::Print("Call to host function at 0x%"Pd"\n", external);
       }
 
-      if (redirection->call_kind() != kLeafRuntimeCall) {
+        if ((redirection->call_kind() == kRuntimeCall) ||
+            (redirection->call_kind() == kNativeCall)) {
         // The top_exit_frame_info of the current isolate points to the top of
         // the simulator stack.
         ASSERT((StackTop() - Isolate::Current()->top_exit_frame_info()) <
                Isolate::GetSpecifiedStackSize());
         // Set the top_exit_frame_info of this simulator to the native stack.
         set_top_exit_frame_info(reinterpret_cast<uword>(&buffer));
       }
       if (redirection->call_kind() == kRuntimeCall) {
         NativeArguments arguments;
         ASSERT(sizeof(NativeArguments) == 4*kWordSize);
         arguments.isolate_ = reinterpret_cast<Isolate*>(get_register(A0));
         arguments.argc_tag_ = get_register(A1);
         arguments.argv_ = reinterpret_cast<RawObject*(*)[]>(get_register(A2));
         arguments.retval_ = reinterpret_cast<RawObject**>(get_register(A3));
         SimulatorRuntimeCall target =
             reinterpret_cast<SimulatorRuntimeCall>(external);
         target(arguments);
         set_register(V0, icount_);  // Zap result register from void function.
       } else if (redirection->call_kind() == kLeafRuntimeCall) {
         int32_t a0 = get_register(A0);
         int32_t a1 = get_register(A1);
         int32_t a2 = get_register(A2);
         int32_t a3 = get_register(A3);
         SimulatorLeafRuntimeCall target =
             reinterpret_cast<SimulatorLeafRuntimeCall>(external);
         a0 = target(a0, a1, a2, a3);
         set_register(V0, a0);  // Set returned result from function.
+      } else if (redirection->call_kind() == kLeafFloatRuntimeCall) {
+        ASSERT((0 <= redirection->argument_count()) &&
+               (redirection->argument_count() <= 2));
+        // double values are passed and returned in vfp registers.

[regis, 2013/06/15 09:52:48]

Is "vfp" a meaningful term for MIPS?

[zra, 2013/06/17 15:58:15]

Changed to 'floating point'.

+        SimulatorLeafFloatRuntimeCall target =
+            reinterpret_cast<SimulatorLeafFloatRuntimeCall>(external);
+        double d0 = 0.0;
+        double d6 = get_fregister_double(F12);
+        double d7 = get_fregister_double(F14);
+        d0 = target(d6, d7);
+        set_fregister_double(F0, d0);
       } else {
         ASSERT(redirection->call_kind() == kNativeCall);
         NativeArguments* arguments;
         arguments = reinterpret_cast<NativeArguments*>(get_register(A0));
         SimulatorNativeCall target =
             reinterpret_cast<SimulatorNativeCall>(external);
         target(arguments);
         set_register(V0, icount_);  // Zap result register from void function.
       }
       set_top_exit_frame_info(0);
@@ skipping 13 matching lines @@
 
       set_register(A0, icount_);
       set_register(A1, icount_);
       set_register(A2, icount_);
       set_register(A3, icount_);
       set_register(TMP, icount_);
       set_register(RA, icount_);
 
       // Zap floating point registers.
       int32_t zap_dvalue = icount_;
-      for (int i = F0; i <= F31; i++) {
+      for (int i = F4; i <= F18; i++) {
         set_fregister(static_cast<FRegister>(i), zap_dvalue);
       }
 
       // Return. Subtract to account for pc_ increment after return.
       set_pc(saved_ra - Instr::kInstrSize);
     } else {
       // Coming via long jump from a throw. Continue to exception handler.
       set_top_exit_frame_info(0);
       // Adjust for extra pc increment.
       set_pc(get_pc() - Instr::kInstrSize);
@@ skipping 102 matching lines @@
       break;
     }
     case MFLO: {
       ASSERT(instr->RsField() == 0);
       ASSERT(instr->RtField() == 0);
       ASSERT(instr->SaField() == 0);
       // Format(instr, "mflo 'rd");
       set_register(instr->RdField(), get_lo_register());
       break;
     }
+    case MOVCI: {
+      ASSERT(instr->SaField() == 0);
+      ASSERT(instr->Bit(17) == 0);
+      int32_t rs_val = get_register(instr->RsField());
+      uint32_t cc, fcsr_cc, test, status;
+      cc = instr->Bits(18, 3);
+      fcsr_cc = get_fcsr_condition_bit(cc);
+      test = instr->Bit(16);
+      status = test_fcsr_bit(fcsr_cc);
+      if (test == status) {
+        set_register(instr->RdField(), rs_val);
+      }
+      break;
+    }
     case MOVN: {
       ASSERT(instr->SaField() == 0);
       // Format(instr, "movn 'rd, 'rs, 'rt");
       int32_t rt_val = get_register(instr->RtField());
       int32_t rs_val = get_register(instr->RsField());
       if (rt_val != 0) {
         set_register(instr->RdField(), rs_val);
       }
       break;
     }
@@ skipping 391 matching lines @@
         break;
       }
       case COP1_CVT_D: {
         switch (instr->FormatField()) {
           case FMT_W: {
             int32_t fs_int = get_fregister(instr->FsField());
             double fs_dbl = static_cast<double>(fs_int);
             set_fregister_double(instr->FdField(), fs_dbl);
             break;
           }
+          case FMT_S: {
+            float fs_flt = get_fregister_float(instr->FsField());
+            double fs_dbl = static_cast<double>(fs_flt);
+            set_fregister_double(instr->FdField(), fs_dbl);
+            break;
+          }
           case FMT_L: {
             int64_t fs_int = get_fregister_long(instr->FsField());
             double fs_dbl = static_cast<double>(fs_int);
             set_fregister_double(instr->FdField(), fs_dbl);
             break;
           }
           default: {
             OS::PrintErr("DecodeCop1: 0x%x\n", instr->InstructionBits());
             UnimplementedInstruction(instr);
             break;
@@ skipping 519 matching lines @@
     set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   }
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_MIPS)
 
 #endif  // defined TARGET_ARCH_MIPS